PIVOT ON support #3390

egor-ryashin · 2023-11-06T14:27:11Z

No description provided.

begelundmuller · 2023-11-07T13:25:31Z

runtime/drivers/duckdb/olap.go

+func rowsToSchema(r *sqlx.Rows) (*runtimev1.StructType, error) {
+	if r == nil {
+		return nil, nil
+	}
+
+	cts, err := r.ColumnTypes()
+	if err != nil {
+		return nil, err
+	}
+
+	fields := make([]*runtimev1.StructType_Field, len(cts))
+	for i, ct := range cts {
+		nullable, ok := ct.Nullable()
+		if !ok {
+			nullable = true
+		}
+
+		t, err := DatabaseTypeToPB(ct.DatabaseTypeName(), nullable)
+		if err != nil {
+			return nil, err
+		}
+
+		fields[i] = &runtimev1.StructType_Field{
+			Name: ct.Name(),
+			Type: t,
+		}
+	}
+
+	return &runtimev1.StructType{Fields: fields}, nil
+}


Seems like a duplicate of RowsToSchema?

Almost, the parameter type is different though

begelundmuller · 2023-11-07T13:25:58Z

runtime/queries/metricsview_aggregation.go

+	duckdbolap "github.com/rilldata/rill/runtime/drivers/duckdb"
+
+	databasesql "database/sql"
+	"database/sql/driver"
+	"sync"
+
+	"github.com/marcboeker/go-duckdb"
+	"github.com/rilldata/rill/runtime/pkg/pbutil"
+	"google.golang.org/protobuf/types/known/structpb"


Broken formatting – std lib should be in first group, other libs in second group

begelundmuller · 2023-11-07T13:38:11Z

runtime/queries/metricsview_aggregation.go

@@ -129,16 +268,47 @@ func (q *MetricsViewAggregation) Export(ctx context.Context, rt *runtime.Runtime

 	return nil
 }
+func RowsToSchema(r *databasesql.Rows) (*runtimev1.StructType, error) {


Duplicate of duckdb.RowsToSchema?

begelundmuller · 2023-11-07T13:41:27Z

runtime/queries/metricsview_aggregation.go

+	return r.Err()
+}
+
+func rowsToSchema(r *databasesql.Rows) (*runtimev1.StructType, error) {


Another duplicate?

begelundmuller · 2023-11-07T13:43:25Z

runtime/queries/metricsview_aggregation.go

+	return query, nil
+}
+
+func pbTypeToDuckDB(t *runtimev1.Type) (string, error) {


Duplicate from runtime/drivers/duckdb/transporter

begelundmuller · 2023-11-07T13:43:38Z

runtime/queries/metricsview_aggregation.go

+func createTableQuery(schema *runtimev1.StructType, name string) (string, error) {
+	query := fmt.Sprintf("CREATE OR REPLACE TABLE %s(", safeName(name))


Should use TEMPORARY TABLE

begelundmuller · 2023-11-07T13:44:24Z

runtime/queries/metricsview_aggregation.go

+		return err
+	}
+	defer func() {
+		_, _ = db.ExecContext(ctx, `DROP TABLE "`+temporaryTableName+`"`)


Also change here – DROP TEMPORARY TABLE

DROP doesn't have TEMPORARY clause

begelundmuller · 2023-11-07T13:47:28Z

runtime/queries/metricsview_aggregation.go

+	schema, data, err := olapQuery(ctx, olap, priority, sqlString, args)
+	if err != nil {
+		return err
+	}


It's worth optimizing to avoid serializing and deserializing when the DB is already DuckDB. Additionally, it's also worth pushing exports into DuckDB. So the control flow needs to be something like:

On DuckDB, run a create temporary table ... as select ...

On Druid, we need to run the olapQuery and create and insert it into a new temporary table

Then we should execute the pivot against the temporary table OR execute the export against the temporary table

Lastly, drop the temporary table

begelundmuller · 2023-11-07T14:04:00Z

runtime/queries/metricsview_aggregation.go

+	var connErr error
+	var db *databasesql.DB
+	dbOnce.Do(func() {
+		connector, connErr = duckdb.NewConnector("", func(conn driver.ExecerContext) error {
+			_, err := conn.ExecContext(context.Background(), "INSTALL 'json'; LOAD 'json';", nil)
+			return err
+		})
+
+		db = databasesql.OpenDB(connector)
+		db.SetMaxOpenConns(1)
+	})
+	if connErr != nil {
+		return connErr
+	}
+
+	conn, err := connector.Connect(ctx)
+	if err != nil {
+		return err
+	}
+	defer conn.Close()


The db variable will be nil on every invocation after the first (which triggers dbOnce). Generally, this code mixes up db and conn multiple places.

I would propose moving the entire olapQuery -> temporary table in a temporary DuckDB handle logic into a util function. Something like:

schema, data, err := olapQuery(...) if err != nil {...} conn, tableName, release, err := ephemeralDuckDBForResult(schema, data) // ...

If you use that for Druid, combined with a call to WithConnection for the DuckDB case (which provides access to the underlying conn *sql.Conn in the callback), you might be able to have common logic for doing the pivot (and export) for both. But it's also worth considering treating both cases completely separately, even if it's more verbose.

Regardless, I think the various bugs around connection management here show that it's worth putting some time into thinking about how to make the logic flows here as simple to understand/review as possible.

begelundmuller · 2023-11-07T14:06:03Z

runtime/queries/metricsview_aggregation.go

+
+var (
+	dbOnce    sync.Once
+	connector driver.Connector


It's not safe to reuse a connector for multiple DBs. So it should be created at the same time as the OpenDB call, every time.

mindspank · 2023-11-23T22:30:12Z

runtime/queries/metricsview_aggregation.go

@@ -25,6 +43,7 @@ type MetricsViewAggregation struct {
 	Offset             int64                                        `json:"offset,omitempty"`
 	MetricsView        *runtimev1.MetricsViewSpec                   `json:"-"`
 	ResolvedMVSecurity *runtime.ResolvedMetricsViewSecurity         `json:"security"`
+	PivotOn            []string                                     `json:"pviot_on,omitempty"`


pviot_on > pivot_on

egor-ryashin · 2023-11-29T12:58:56Z

First benchmarks:

Running tool: /opt/homebrew/opt/go/libexec/bin/go test -benchmem -run=^$ -bench ^(BenchmarkMetricsViewsAggregation|BenchmarkMetricsViewsAggregation_pivot|BenchmarkMetricsViewsAggregation_spending|BenchmarkMetricsViewsAggregation_spending_pivot)$ github.com/rilldata/rill/runtime/queries -count=1

goos: darwin
goarch: arm64
pkg: github.com/rilldata/rill/runtime/queries
BenchmarkMetricsViewsAggregation-10                   	     268	   4406848 ns/op	   15070 B/op	     383 allocs/op
BenchmarkMetricsViewsAggregation_pivot-10             	     218	   5671571 ns/op	   19537 B/op	     432 allocs/op
BenchmarkMetricsViewsAggregation_spending-10          	      64	  16482316 ns/op	   15826 B/op	     373 allocs/op
BenchmarkMetricsViewsAggregation_spending_pivot-10    	      38	  32526113 ns/op	   77312 B/op	    1238 allocs/op

The growth is non-linear (may be due to the temporary table - as it isn't limited).

egor-ryashin · 2023-11-30T11:33:21Z

With the limit on subquery the benchmarks are:

Running tool: /opt/homebrew/opt/go/libexec/bin/go test -benchmem -run=^$ -bench ^(BenchmarkMetricsViewsAggregation|BenchmarkMetricsViewsAggregation_pivot|BenchmarkMetricsViewsAggregation_spending|BenchmarkMetricsViewsAggregation_spending_100|BenchmarkMetricsViewsAggregation_spending_pivot|BenchmarkMetricsViewsAggregation_spending_pivot_100)$ github.com/rilldata/rill/runtime/queries -count=1

goos: darwin
goarch: arm64
pkg: github.com/rilldata/rill/runtime/queries
BenchmarkMetricsViewsAggregation-10                       	     280	   4274759 ns/op	   15055 B/op	     383 allocs/op
BenchmarkMetricsViewsAggregation_pivot-10                 	     216	   5512721 ns/op	   18784 B/op	     407 allocs/op
BenchmarkMetricsViewsAggregation_spending-10              	      67	  16572626 ns/op	   15875 B/op	     373 allocs/op
BenchmarkMetricsViewsAggregation_spending_100-10          	      61	  16938342 ns/op	   87936 B/op	    2356 allocs/op
BenchmarkMetricsViewsAggregation_spending_pivot-10        	      66	  18002439 ns/op	   21155 B/op	     440 allocs/op
BenchmarkMetricsViewsAggregation_spending_pivot_100-10    	      51	  20305096 ns/op	  195780 B/op	    3670 allocs/op

begelundmuller

Lastly, it's not currently adding any limits on the source Druid data. I would suggest we put a cap at e.g. 100k rows, and return an error if it's exceeded (an error is better than returning incorrect/partial pivoted data)

begelundmuller · 2023-12-06T15:14:44Z

runtime/drivers/duckdb/utils.go

 // rawConn is similar to *sql.Conn.Raw, but additionally unwraps otelsql (which we use for instrumentation).
-func rawConn(conn *sql.Conn, f func(driver.Conn) error) error {
+func RawConn(conn *sql.Conn, f func(driver.Conn) error) error {
 	return conn.Raw(func(raw any) error {
 		// For details, see: https://github.com/XSAM/otelsql/issues/98


This is an implementation detail we should try to avoid leaking from the driver

begelundmuller · 2023-12-06T15:15:35Z

runtime/queries/metricsview_aggregation.go

+	// execute druid query
+	sqlString, args, err := q.buildMetricsAggregationSQL(q.MetricsView, olap.Dialect(), q.ResolvedMVSecurity)


Comment doesn't match

begelundmuller · 2023-12-06T15:44:07Z

runtime/queries/metricsview_aggregation.go

+	dbOnce.Do(func() {
+		handle, errHandle = duckdbolap.Driver{}.Open(map[string]any{"pool_size": 10}, false, activity.NewNoopClient(), zap.NewNop())
+	})
+	if errHandle != nil {
+		return errHandle
+	}
+
+	schema, data, err := olapQuery(ctx, olap, priority, sqlString, args)
+	if err != nil {
+		return err
+	}
+
+	duckDBOLAP, _ := handle.AsOLAP("")
+	err = duckDBOLAP.WithConnection(ctx, priority, false, false, func(ctx context.Context, ensuredCtx context.Context, conn *databasesql.Conn) error {
+		temporaryTableName := tempName("_for_pivot_")
+		createTableSQL, err := duckdbolap.CreateTableQuery(schema, temporaryTableName)


We should avoid using our DuckDB OLAP driver for this kind of ephemeral in-memory transformation. A few reasons:

Our driver has a lot of extra overhead, like loading a bunch of extensions, migrations for catalog tables, emitting DB stats telemetry, etc.

It leaks some pretty internal details of the driver into the runtime/queries package (like the RawConn func should not be public)

Lifecycle management of the DuckDB handle becomes tricky with a global here, since DuckDB doesn't release memory it has taken. Since this is just for exports, it's probably better to open/close a handle on each call initially.

As discussed previously, I would suggest creating a generic runtime/pkg/duckdbpivot package with a Pivot function that takes a sqlx.Rows iterator as an argument, and returns a pivoted sqlx.Rows. Internally, it would use database/sql to directly open an in-memory DuckDB handle to just create the temporary table and do the pivot.

That would also encapsulate the appender logic in a scoped package, and allow easier testing of the code.

===

An implication for the above is that here, the DuckDB and Druid cases become pretty different (since we want to avoid the overhead of converting from our DuckDB driver to duckdbpivot), but since the pivot SQL is pretty simple, I think some duplication is the best way to keep it simple.

I've run some benchmarks to compare DB initialising vs keeping for a table of 10k rows - 3x slower. My thoughts, yes, there are usually low time requirements for exports, but eventually it's 3x CPU load - though, it's OK until exports is a small part of Runtime CPU consumption (this speculation considers the cloud-based mostly):

Running tool: /opt/homebrew/opt/go/libexec/bin/go test -benchmem -run=^$ -bench ^(BenchmarkTestCreate|BenchmarkTestNoCreate)$ github.com/rilldata/rill/runtime/drivers/duckdb -count=1 goos: darwin goarch: arm64 pkg: github.com/rilldata/rill/runtime/drivers/duckdb BenchmarkTestCreate-10 36 34185877 ns/op 353456 B/op 26358 allocs/op BenchmarkTestNoCreate-10 97 11942874 ns/op 351659 B/op 26322 allocs/op PASS ok github.com/rilldata/rill/runtime/drivers/duckdb 4.416s

package duckdb import ( "context" "testing" "time" "github.com/stretchr/testify/require" ) // func initDb(t *testing.B) (*sql.DB, error) { // connector, err := duckdb.NewConnector("", func(execer driver.ExecerContext) error { // bootQueries := []string{ // "INSTALL 'icu'", // "LOAD 'icu'", // } // for _, qry := range bootQueries { // _, err := execer.ExecContext(context.Background(), qry, nil) // if err != nil { // return err // } // } // return nil // }) // if err != nil { // return nil, err // } // db := sql.OpenDB(connector) // return db, nil // } func BenchmarkTestCreate(b *testing.B) { for i := 0; i < b.N; i++ { func() { db, err := initDb(b) require.NoError(b, err) defer db.Close() _, err = db.ExecContext(context.Background(), ` CREATE TEMPORARY TABLE tm as select range from range(timestamptz '2022-01-01', timestamptz '2023-01-01', interval '1 hour')`) require.NoError(b, err) r, err := db.Query("select time_bucket(interval '1 minute', range, 'Asia/Kathmandu') as bucket, count(*) as cnt from tm group by bucket") require.NoError(b, err) var cnt int var tm time.Time for r.Next() { err = r.Scan(&tm, &cnt) require.NoError(b, err) } r.Close() _, err = db.ExecContext(context.Background(), `DROP TABLE tm`) require.NoError(b, err) }() } } func BenchmarkTestNoCreate(b *testing.B) { db, err := initDb(b) require.NoError(b, err) defer db.Close() b.ResetTimer() for i := 0; i < b.N; i++ { _, err = db.ExecContext(context.Background(), ` CREATE TEMPORARY TABLE tm as select range from range(timestamptz '2022-01-01', timestamptz '2023-01-01', interval '1 hour')`) require.NoError(b, err) r, err := db.Query("select time_bucket(interval '1 minute', range, 'Asia/Kathmandu') as bucket, count(*) as cnt from tm group by bucket") require.NoError(b, err) var cnt int var tm time.Time for r.Next() { err = r.Scan(&tm, &cnt) require.NoError(b, err) } r.Close() _, err = db.ExecContext(context.Background(), `DROP TABLE tm`) require.NoError(b, err) } }

Pivot function that takes a sqlx.Rows iterator as an argument, and returns a pivoted sqlx.Rows. Internally, it would use database/sql to directly open an in-memory DuckDB handle to just create the temporary table and do the pivot.

won't work. The function creates a handle but doesn't return it and it's not closed

btw, I cannot pass sqlx.Rows because I have drivers.Result from the OLAPStore

Our driver has a lot of extra overhead, like loading a bunch of extensions, migrations for catalog tables, emitting DB stats telemetry, etc.
It leaks some pretty internal details of the driver into the runtime/queries package (like the RawConn func should not be public)
Lifecycle management of the DuckDB handle becomes tricky with a global here, since DuckDB doesn't release memory it has taken. Since this is just for exports, it's probably better to open/close a handle on each call initially.

Addressed those.

begelundmuller · 2023-12-06T15:46:02Z

runtime/queries/metricsview_aggregation.go

+		sn := safeName(m.Name)
 		switch m.BuiltinMeasure {
 		case runtimev1.BuiltinMeasure_BUILTIN_MEASURE_UNSPECIFIED:
 			expr, err := metricsViewMeasureExpression(mv, m.Name)
 			if err != nil {
 				return "", nil, err
 			}
-			selectCols = append(selectCols, fmt.Sprintf("%s as %s", expr, safeName(m.Name)))
+			selectCols = append(selectCols, fmt.Sprintf("%s as %s", expr, sn))


sn only referenced once in the scope – probably simpler to keep as before

begelundmuller · 2023-12-06T15:56:58Z

runtime/queries/metricsview_aggregation.go

+	var sql string
+	if q.PivotOn != nil {
+		// select m1, m2, d1, d2 from t, lateral unnest(t.d1) tbl(unnested_d1_) where d1 = 'a' group by d1, d2
+		sql = fmt.Sprintf("SELECT %[1]s FROM %[2]s %[3]s %[4]s %[5]s %[6]s %[7]s",
+			strings.Join(selectCols, ", "),  // 1
+			safeName(mv.Table),              // 2
+			strings.Join(unnestClauses, ""), // 3
+			whereClause,                     // 4
+			groupClause,                     // 5
+			orderClause,                     // 6
+			limitClause,                     // 7
+		)
+	} else {
+		sql = fmt.Sprintf("SELECT %s FROM %s %s %s %s %s %s OFFSET %d",
+			strings.Join(selectCols, ", "),
+			safeName(mv.Table),
+			strings.Join(unnestClauses, ""),
+			whereClause,
+			groupClause,
+			orderClause,
+			limitClause,
+			q.Offset,
+		)
+	}


They seem equivalent apart from the offset clause? I would suggest we return an error if passing q.Offset together with q.PivotOn, since that's not easy to support right now

egor-ryashin · 2023-12-15T13:32:10Z

Benchmarks (updated):

goos: darwin
goarch: arm64
pkg: github.com/rilldata/rill/runtime/queries
BenchmarkMetricsViewsAggregation-10                           	     273	   4442161 ns/op	   15247 B/op	     385 allocs/op
BenchmarkMetricsViewsAggregation_pivot_2_measures-10          	     128	   8201447 ns/op	   82682 B/op	     601 allocs/op
BenchmarkMetricsViewsAggregation_pivot-10                     	     211	   5994564 ns/op	   19126 B/op	     413 allocs/op
BenchmarkMetricsViewsAggregation_spending-10                  	      58	  21029836 ns/op	   15980 B/op	     375 allocs/op
BenchmarkMetricsViewsAggregation_spending_100-10              	      60	  17369018 ns/op	   88083 B/op	    2358 allocs/op
BenchmarkMetricsViewsAggregation_spending_pivot-10            	      60	  18621535 ns/op	   21492 B/op	     446 allocs/op
BenchmarkMetricsViewsAggregation_spending_pivot_100-10        	      54	  19336074 ns/op	  196108 B/op	    3676 allocs/op
BenchmarkMetricsViewsAggregation_Druid-10                     	      27	  84698711 ns/op	   17516 B/op	     328 allocs/op
BenchmarkMetricsViewsAggregation_Druid_2_measures-10          	      16	  77315091 ns/op	   21221 B/op	     389 allocs/op
BenchmarkMetricsViewsAggregation_Druid_pivot-10               	      24	  42822396 ns/op	   14174 B/op	     229 allocs/op
BenchmarkMetricsViewsAggregation_Druid_pivot_2_measures-10    	      14	  94477979 ns/op	   19540 B/op	     307 allocs/op
PASS
ok  	github.com/rilldata/rill/runtime/queries	80.870s

begelundmuller · 2023-12-18T11:59:52Z

runtime/queries/metricsview_aggregation.go

+				if count >= batchSize {
+					appender.Flush()
+					count = 0
+				}
+			}


Should additionally enforce a limit on the number of cells to be pivoted (i.e. len(columns) * count < maxPivotCells). Maybe something like 1m cells?

Would be good to implement the same against DuckDB (can use a LIMIT clause of maxPivotCells+1 to enforce, and run a count query against the temporary table to determine if the maxPivotCells was exceeded).

begelundmuller

There are also some merge conflicts to address

begelundmuller · 2023-12-21T07:27:54Z

runtime/queries/metricsview_aggregation.go

+	} else if q.PivotOn != nil {
+		l := 1_000_000 / cols
+		limitClause = fmt.Sprintf("LIMIT %d", l)
 	}


Pull the number into a constant at the top of the file, as suggested in the previous comment

We need to return an error if the limit is exceeded (for both DuckDB and Druid). Since otherwise people would get partial/wrong results. So the limit probably needs to be maxPivotCells + 1 and then after querying, it count the number of rows and check it's <= maxPivotCells.

pivot-on

ca628b5

egor-ryashin force-pushed the pivot-on branch from 163090c to ca628b5 Compare November 6, 2023 14:30

pivot-on

137367e

begelundmuller assigned egor-ryashin Nov 6, 2023

pivot-on

0b48abe

egor-ryashin requested a review from begelundmuller November 6, 2023 16:03

begelundmuller requested changes Nov 7, 2023

View reviewed changes

Egor Ryashin added 3 commits November 7, 2023 17:46

pivot-on

a5b60db

pivot with an olap store

9b89a0e

pivot on: optimized DuckDB

a1ff2df

mindspank reviewed Nov 23, 2023

View reviewed changes

pivot on: druid

78cc055

egor-ryashin marked this pull request as ready for review November 24, 2023 13:24

egor-ryashin mentioned this pull request Nov 24, 2023

Runtime: Support pivoted exports for MetricsViewAggregation #3309

Closed

Egor Ryashin added 5 commits November 24, 2023 16:49

pivot on: druid

fe28fd6

pivot on: druid

55aa9bc

pivot on: druid

17df06e

Merge remote-tracking branch 'origin/main' into pivot-on

32cc6a7

merge fix

0303594

egor-ryashin requested a review from begelundmuller November 27, 2023 10:37

pivot on: benchmarks

f20e289

pivot limit

5c4988f

nishantmonu51 added blocker A release blocker issue that should be resolved before a new release and removed blocker A release blocker issue that should be resolved before a new release labels Dec 5, 2023

begelundmuller requested changes Dec 6, 2023

View reviewed changes

Egor Ryashin added 3 commits December 11, 2023 11:50

removed a comment

79f78fb

refactoring

2bc33c3

refactoring

7a2233f

Egor Ryashin added 2 commits December 12, 2023 22:05

refactoring

fb995ec

druid benchmarks

fa470dc

Egor Ryashin added 4 commits December 15, 2023 16:35

Merge remote-tracking branch 'origin/main' into pivot-on

a24dd5e

Merge remote-tracking branch 'origin/main' into pivot-on

18ccdd5

test fix

a879eb0

test fix

b3f4302

begelundmuller requested changes Dec 18, 2023

View reviewed changes

pivot limit

84a8fe0

begelundmuller requested changes Dec 21, 2023

View reviewed changes

Egor Ryashin added 5 commits December 22, 2023 15:33

pivot limit

9a38291

Merge remote-tracking branch 'origin/main' into pivot-on

1a70bb4

Merge remote-tracking branch 'origin/main' into pivot-on

e279681

Merge remote-tracking branch 'origin/main' into pivot-on

98dd97f

merge fix

815ba63

egor-ryashin requested a review from begelundmuller December 22, 2023 16:47

begelundmuller approved these changes Jan 2, 2024

View reviewed changes

begelundmuller merged commit 10e5cfe into main Jan 2, 2024
7 checks passed

begelundmuller deleted the pivot-on branch January 2, 2024 14:08

ericpgreen2 mentioned this pull request Jan 11, 2024

Dashboard: Add "Export" button for the TDD view #3833

Closed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

PIVOT ON support #3390

PIVOT ON support #3390

egor-ryashin commented Nov 6, 2023

begelundmuller Nov 7, 2023

egor-ryashin Nov 7, 2023

egor-ryashin Nov 24, 2023

begelundmuller Nov 7, 2023

begelundmuller Nov 7, 2023

begelundmuller Nov 7, 2023

begelundmuller Nov 7, 2023

egor-ryashin Nov 24, 2023

begelundmuller Nov 7, 2023

begelundmuller Nov 7, 2023

egor-ryashin Nov 22, 2023

begelundmuller Nov 7, 2023

begelundmuller Nov 7, 2023

begelundmuller Nov 7, 2023

mindspank Nov 23, 2023

egor-ryashin commented Nov 29, 2023 •

edited

Loading

egor-ryashin commented Nov 30, 2023

begelundmuller left a comment •

edited

Loading

begelundmuller Dec 6, 2023

begelundmuller Dec 6, 2023

begelundmuller Dec 6, 2023

egor-ryashin Dec 8, 2023 •

edited

Loading

egor-ryashin Dec 11, 2023

egor-ryashin Dec 11, 2023

egor-ryashin Dec 12, 2023

begelundmuller Dec 6, 2023

begelundmuller Dec 6, 2023

egor-ryashin commented Dec 15, 2023 •

edited

Loading

begelundmuller Dec 18, 2023

begelundmuller Dec 18, 2023

begelundmuller left a comment

begelundmuller Dec 21, 2023

		func createTableQuery(schema *runtimev1.StructType, name string) (string, error) {
		query := fmt.Sprintf("CREATE OR REPLACE TABLE %s(", safeName(name))

		// execute druid query
		sqlString, args, err := q.buildMetricsAggregationSQL(q.MetricsView, olap.Dialect(), q.ResolvedMVSecurity)

PIVOT ON support #3390

PIVOT ON support #3390

Conversation

egor-ryashin commented Nov 6, 2023

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

egor-ryashin commented Nov 29, 2023 • edited Loading

egor-ryashin commented Nov 30, 2023

begelundmuller left a comment • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

egor-ryashin Dec 8, 2023 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

egor-ryashin commented Dec 15, 2023 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

begelundmuller left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

egor-ryashin commented Nov 29, 2023 •

edited

Loading

begelundmuller left a comment •

edited

Loading

egor-ryashin Dec 8, 2023 •

edited

Loading

egor-ryashin commented Dec 15, 2023 •

edited

Loading