This is an automated email from the ASF dual-hosted git repository.
cwylie pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/druid.git
The following commit(s) were added to refs/heads/master by this push:
new f6aca21e82 Web console: update DQT to version 0.17 (#13323)
f6aca21e82 is described below
commit f6aca21e8203c003e6467d0112840a63223bc859
Author: Vadim Ogievetsky <[email protected]>
AuthorDate: Mon Nov 7 17:47:11 2022 -0800
Web console: update DQT to version 0.17 (#13323)
* update to DQT 17
* update licenses
* after npm i
---
licenses.yaml | 2 +-
web-console/e2e-tests/tutorial-batch.spec.ts | 4 +-
web-console/package-lock.json | 14 +--
web-console/package.json | 2 +-
.../cell-filter-menu/cell-filter-menu.tsx | 21 +++--
.../record-table-pane/record-table-pane.tsx | 4 +-
.../datasource-columns-table.tsx | 4 +-
.../datasource-preview-pane.tsx | 4 +-
.../lookup-values-table/lookup-values-table.tsx | 4 +-
.../external-config/external-config.ts | 17 ++--
.../ingest-query-pattern/ingest-query-pattern.ts | 8 +-
.../workbench-query/workbench-query-part.ts | 8 +-
.../workbench-query/workbench-query.ts | 15 ++-
.../src/helpers/execution/sql-task-execution.ts | 4 +-
web-console/src/helpers/spec-conversion.ts | 101 ++++++++++-----------
web-console/src/react-table/react-table-utils.ts | 17 ++--
web-console/src/utils/druid-query.ts | 4 +-
web-console/src/utils/query-cursor.ts | 15 +--
web-console/src/utils/sample-query.tsx | 20 ++--
web-console/src/utils/sql.ts | 4 +-
.../views/datasources-view/datasources-view.tsx | 5 +-
.../src/views/segments-view/segments-view.tsx | 21 +++--
.../column-actions/column-actions.tsx | 47 ++++------
.../ingestion-progress-dialog.tsx | 4 +-
.../expression-entry/expression-entry.tsx | 4 +-
.../schema-step/preview-table/preview-table.tsx | 4 +-
.../rollup-analysis-pane/rollup-analysis-pane.tsx | 12 +--
.../schema-step/schema-step.tsx | 22 ++---
.../sql-data-loader-view/sql-data-loader-view.tsx | 2 +-
.../number-menu-items/number-menu-items.tsx | 38 ++++----
.../string-menu-items/string-menu-items.tsx | 83 +++++++----------
.../time-menu-items/time-menu-items.tsx | 58 ++++--------
.../workbench-view/column-tree/column-tree.tsx | 67 ++++++++------
.../flexible-query-input/flexible-query-input.tsx | 8 +-
.../ingest-success-pane/ingest-success-pane.tsx | 4 +-
.../input-format-step/input-format-step.tsx | 4 +-
.../recent-query-task-panel.tsx | 8 +-
.../result-table-pane/result-table-pane.tsx | 57 ++++--------
.../time-floor-menu-item/time-floor-menu-item.tsx | 22 ++---
39 files changed, 322 insertions(+), 420 deletions(-)
diff --git a/licenses.yaml b/licenses.yaml
index e20e0119cb..5b70fadb1d 100644
--- a/licenses.yaml
+++ b/licenses.yaml
@@ -5683,7 +5683,7 @@ license_category: binary
module: web-console
license_name: Apache License version 2.0
copyright: Imply Data
-version: 0.16.1
+version: 0.17.1
---
diff --git a/web-console/e2e-tests/tutorial-batch.spec.ts
b/web-console/e2e-tests/tutorial-batch.spec.ts
index 9420f74def..914850a96a 100644
--- a/web-console/e2e-tests/tutorial-batch.spec.ts
+++ b/web-console/e2e-tests/tutorial-batch.spec.ts
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-import { SqlTableRef } from 'druid-query-toolkit';
+import { T } from 'druid-query-toolkit';
import * as playwright from 'playwright-chromium';
import { DatasourcesOverview } from './component/datasources/overview';
@@ -167,7 +167,7 @@ async function validateDatasourceStatus(page:
playwright.Page, datasourceName: s
async function validateQuery(page: playwright.Page, datasourceName: string) {
const queryOverview = new QueryOverview(page, UNIFIED_CONSOLE_URL);
- const query = `SELECT * FROM ${SqlTableRef.create(datasourceName)} ORDER BY
__time`;
+ const query = `SELECT * FROM ${T(datasourceName)} ORDER BY __time`;
const results = await queryOverview.runQuery(query);
expect(results).toBeDefined();
expect(results.length).toBeGreaterThan(0);
diff --git a/web-console/package-lock.json b/web-console/package-lock.json
index 31d0a107ac..c78e7c0c7f 100644
--- a/web-console/package-lock.json
+++ b/web-console/package-lock.json
@@ -22,7 +22,7 @@
"d3-axis": "^2.1.0",
"d3-scale": "^3.3.0",
"d3-selection": "^2.0.0",
- "druid-query-toolkit": "^0.16.1",
+ "druid-query-toolkit": "^0.17.1",
"file-saver": "^2.0.2",
"follow-redirects": "^1.14.7",
"fontsource-open-sans": "^3.0.9",
@@ -8967,9 +8967,9 @@
}
},
"node_modules/druid-query-toolkit": {
- "version": "0.16.1",
- "resolved":
"https://registry.npmjs.org/druid-query-toolkit/-/druid-query-toolkit-0.16.1.tgz";,
- "integrity":
"sha512-HiovpGh1m2QTvexBX1AvQAz5ONc9sChazL0hsXl0qEvHcIQ69pksJZWXZOStBI2T9fJAXQpSUVB4DUSdE6UXmQ==",
+ "version": "0.17.1",
+ "resolved":
"https://registry.npmjs.org/druid-query-toolkit/-/druid-query-toolkit-0.17.1.tgz";,
+ "integrity":
"sha512-uXybPbUgY5fKMRSduPKSTLHQ8zhfvGT2/jWl+fPIXruFjFnZTDp8YPkJtYq1LzSCvEfgKLw1vwBtNhyUY/CdVg==",
"dependencies": {
"tslib": "^2.3.1"
},
@@ -34591,9 +34591,9 @@
}
},
"druid-query-toolkit": {
- "version": "0.16.1",
- "resolved":
"https://registry.npmjs.org/druid-query-toolkit/-/druid-query-toolkit-0.16.1.tgz";,
- "integrity":
"sha512-HiovpGh1m2QTvexBX1AvQAz5ONc9sChazL0hsXl0qEvHcIQ69pksJZWXZOStBI2T9fJAXQpSUVB4DUSdE6UXmQ==",
+ "version": "0.17.1",
+ "resolved":
"https://registry.npmjs.org/druid-query-toolkit/-/druid-query-toolkit-0.17.1.tgz";,
+ "integrity":
"sha512-uXybPbUgY5fKMRSduPKSTLHQ8zhfvGT2/jWl+fPIXruFjFnZTDp8YPkJtYq1LzSCvEfgKLw1vwBtNhyUY/CdVg==",
"requires": {
"tslib": "^2.3.1"
}
diff --git a/web-console/package.json b/web-console/package.json
index 1d08bc4c4e..24875698c5 100644
--- a/web-console/package.json
+++ b/web-console/package.json
@@ -79,7 +79,7 @@
"d3-axis": "^2.1.0",
"d3-scale": "^3.3.0",
"d3-selection": "^2.0.0",
- "druid-query-toolkit": "^0.16.1",
+ "druid-query-toolkit": "^0.17.1",
"file-saver": "^2.0.2",
"follow-redirects": "^1.14.7",
"fontsource-open-sans": "^3.0.9",
diff --git a/web-console/src/components/cell-filter-menu/cell-filter-menu.tsx
b/web-console/src/components/cell-filter-menu/cell-filter-menu.tsx
index a5e9022537..20d200b6f9 100644
--- a/web-console/src/components/cell-filter-menu/cell-filter-menu.tsx
+++ b/web-console/src/components/cell-filter-menu/cell-filter-menu.tsx
@@ -19,13 +19,14 @@
import { Menu, MenuItem } from '@blueprintjs/core';
import { IconNames } from '@blueprintjs/icons';
import {
+ C,
Column,
+ L,
SqlComparison,
SqlExpression,
SqlLiteral,
SqlQuery,
SqlRecord,
- SqlRef,
trimString,
} from 'druid-query-toolkit';
import React from 'react';
@@ -36,7 +37,7 @@ function sqlLiteralForColumnValue(column: Column, value:
unknown): SqlLiteral |
if (column.sqlType === 'TIMESTAMP') {
const asDate = new Date(value as any);
if (!isNaN(asDate.valueOf())) {
- return SqlLiteral.create(asDate);
+ return L(asDate);
}
}
@@ -112,14 +113,14 @@ export function CellFilterMenu(props:
CellFilterMenuProps) {
let ex: SqlExpression | undefined;
let having = false;
if (query.hasStarInSelect()) {
- ex = SqlRef.column(column.name);
+ ex = C(column.name);
} else {
const selectValue = query.getSelectExpressionForIndex(headerIndex);
if (selectValue) {
const outputName = selectValue.getOutputName();
having = query.isAggregateSelectIndex(headerIndex);
if (having && outputName) {
- ex = SqlRef.column(outputName);
+ ex = C(outputName);
} else {
ex = selectValue.getUnderlyingExpression();
}
@@ -133,11 +134,11 @@ export function CellFilterMenu(props:
CellFilterMenuProps) {
icon={IconNames.FILTER}
text={`${having ? 'Having' : 'Filter on'}:
${prettyPrintSql(clause)}`}
onClick={() => {
- const column = clause.getUsedColumns()[0];
+ const columnName = clause.getUsedColumnNames()[0];
onQueryAction(
having
- ? q => q.removeFromHaving(column).addHaving(clause)
- : q => q.removeColumnFromWhere(column).addWhere(clause),
+ ? q => q.removeFromHaving(columnName).addHaving(clause)
+ : q => q.removeColumnFromWhere(columnName).addWhere(clause),
);
}}
/>
@@ -151,7 +152,7 @@ export function CellFilterMenu(props: CellFilterMenuProps) {
const currentClauses =
currentFilterExpression
?.decomposeViaAnd()
- ?.filter(ex => String(ex.getUsedColumns()) === column.name) || [];
+ ?.filter(ex => String(ex.getUsedColumnNames()) === column.name) || [];
const updatedClause =
currentClauses.length === 1 && val ? addToClause(currentClauses[0], val)
: undefined;
@@ -160,7 +161,7 @@ export function CellFilterMenu(props: CellFilterMenuProps) {
const jsonColumn = column.nativeType === 'COMPLEX<json>';
return (
<Menu>
- {ex?.getFirstColumn() && val && !jsonColumn && (
+ {ex?.getFirstColumnName() && val && !jsonColumn && (
<>
{updatedClause && filterOnMenuItem(updatedClause)}
{filterOnMenuItem(ex.equal(val))}
@@ -177,7 +178,7 @@ export function CellFilterMenu(props: CellFilterMenuProps) {
</Menu>
);
} else {
- const ref = SqlRef.column(column.name);
+ const ref = C(column.name);
const stringValue = stringifyValue(value);
const trimmedValue = trimString(stringValue, 50);
return (
diff --git a/web-console/src/components/record-table-pane/record-table-pane.tsx
b/web-console/src/components/record-table-pane/record-table-pane.tsx
index 1cd5833f56..e3f26ad18d 100644
--- a/web-console/src/components/record-table-pane/record-table-pane.tsx
+++ b/web-console/src/components/record-table-pane/record-table-pane.tsx
@@ -66,8 +66,8 @@ export const RecordTablePane = React.memo(function
RecordTablePane(props: Record
if (!parsedQuery ||
!parsedQuery.isRealOutputColumnAtSelectIndex(headerIndex)) return false;
return (
- parsedQuery.getEffectiveWhereExpression().containsColumn(header) ||
- parsedQuery.getEffectiveHavingExpression().containsColumn(header)
+ parsedQuery.getEffectiveWhereExpression().containsColumnName(header) ||
+ parsedQuery.getEffectiveHavingExpression().containsColumnName(header)
);
}
diff --git
a/web-console/src/dialogs/datasource-table-action-dialog/datasource-columns-table/datasource-columns-table.tsx
b/web-console/src/dialogs/datasource-table-action-dialog/datasource-columns-table/datasource-columns-table.tsx
index cd56dda85f..242ca19378 100644
---
a/web-console/src/dialogs/datasource-table-action-dialog/datasource-columns-table/datasource-columns-table.tsx
+++
b/web-console/src/dialogs/datasource-table-action-dialog/datasource-columns-table/datasource-columns-table.tsx
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-import { SqlLiteral } from 'druid-query-toolkit';
+import { L } from 'druid-query-toolkit';
import React from 'react';
import ReactTable from 'react-table';
@@ -44,7 +44,7 @@ export const DatasourceColumnsTable = React.memo(function
DatasourceColumnsTable
processQuery: async (datasourceId: string) => {
return await queryDruidSql<ColumnMetadata>({
query: `SELECT COLUMN_NAME, DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS
- WHERE TABLE_SCHEMA = 'druid' AND TABLE_NAME =
${SqlLiteral.create(datasourceId)}`,
+ WHERE TABLE_SCHEMA = 'druid' AND TABLE_NAME = ${L(datasourceId)}`,
});
},
});
diff --git
a/web-console/src/dialogs/datasource-table-action-dialog/datasource-preview-pane/datasource-preview-pane.tsx
b/web-console/src/dialogs/datasource-table-action-dialog/datasource-preview-pane/datasource-preview-pane.tsx
index 71c20d2202..8f3d664e93 100644
---
a/web-console/src/dialogs/datasource-table-action-dialog/datasource-preview-pane/datasource-preview-pane.tsx
+++
b/web-console/src/dialogs/datasource-table-action-dialog/datasource-preview-pane/datasource-preview-pane.tsx
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-import { QueryResult, QueryRunner, SqlTableRef } from 'druid-query-toolkit';
+import { QueryResult, QueryRunner, T } from 'druid-query-toolkit';
import React from 'react';
import { Loader, RecordTablePane } from '../../../components';
@@ -42,7 +42,7 @@ export const DatasourcePreviewPane = React.memo(function
DatasourcePreviewPane(
let result: QueryResult;
try {
result = await queryRunner.runQuery({
- query: `SELECT * FROM ${SqlTableRef.create(datasource)}`,
+ query: `SELECT * FROM ${T(datasource)}`,
extraQueryContext: { sqlOuterLimit: 100 },
cancelToken,
});
diff --git
a/web-console/src/dialogs/lookup-table-action-dialog/lookup-values-table/lookup-values-table.tsx
b/web-console/src/dialogs/lookup-table-action-dialog/lookup-values-table/lookup-values-table.tsx
index 2ffa3ecc22..ec962c4083 100644
---
a/web-console/src/dialogs/lookup-table-action-dialog/lookup-values-table/lookup-values-table.tsx
+++
b/web-console/src/dialogs/lookup-table-action-dialog/lookup-values-table/lookup-values-table.tsx
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-import { SqlRef } from 'druid-query-toolkit';
+import { N } from 'druid-query-toolkit';
import React from 'react';
import ReactTable from 'react-table';
@@ -43,7 +43,7 @@ export const LookupValuesTable = React.memo(function
LookupValuesTable(
const [entriesState] = useQueryManager<string, LookupRow[]>({
processQuery: async (lookupId: string) => {
return await queryDruidSql<LookupRow>({
- query: `SELECT "k", "v" FROM ${SqlRef.column(lookupId, 'lookup')}
LIMIT 5000`,
+ query: `SELECT "k", "v" FROM ${N('lookup').table(lookupId)} LIMIT
5000`,
});
},
initQuery: props.lookupId,
diff --git a/web-console/src/druid-models/external-config/external-config.ts
b/web-console/src/druid-models/external-config/external-config.ts
index d9dcb97cd1..900551741c 100644
--- a/web-console/src/druid-models/external-config/external-config.ts
+++ b/web-console/src/druid-models/external-config/external-config.ts
@@ -17,12 +17,14 @@
*/
import {
+ C,
+ F,
filterMap,
+ L,
SqlExpression,
SqlFunction,
SqlLiteral,
SqlQuery,
- SqlRef,
SqlStar,
} from 'druid-query-toolkit';
import * as JSONBig from 'json-bigint-native';
@@ -120,9 +122,9 @@ export function summarizeExternalConfig(externalConfig:
ExternalConfig): string
export function externalConfigToTableExpression(config: ExternalConfig):
SqlExpression {
return SqlExpression.parse(`TABLE(
EXTERN(
- ${SqlLiteral.create(JSONBig.stringify(config.inputSource))},
- ${SqlLiteral.create(JSONBig.stringify(config.inputFormat))},
- ${SqlLiteral.create(JSONBig.stringify(config.signature))}
+ ${L(JSONBig.stringify(config.inputSource))},
+ ${L(JSONBig.stringify(config.inputFormat))},
+ ${L(JSONBig.stringify(config.signature))}
)
)`);
}
@@ -135,11 +137,8 @@ export function externalConfigToInitDimensions(
return (timeExpression ? [timeExpression.as('__time')] : [])
.concat(
filterMap(config.signature, ({ name }, i) => {
- if (timeExpression && timeExpression.containsColumn(name)) return;
- return SqlRef.column(name).applyIf(
- isArrays[i],
- ex => SqlFunction.simple('MV_TO_ARRAY', [ex]).as(name) as any,
- );
+ if (timeExpression && timeExpression.containsColumnName(name)) return;
+ return C(name).applyIf(isArrays[i], ex => F('MV_TO_ARRAY',
ex).as(name) as any);
}),
)
.slice(0, MULTI_STAGE_QUERY_MAX_COLUMNS);
diff --git
a/web-console/src/druid-models/ingest-query-pattern/ingest-query-pattern.ts
b/web-console/src/druid-models/ingest-query-pattern/ingest-query-pattern.ts
index 53a6f2b6b8..f4dee926b6 100644
--- a/web-console/src/druid-models/ingest-query-pattern/ingest-query-pattern.ts
+++ b/web-console/src/druid-models/ingest-query-pattern/ingest-query-pattern.ts
@@ -23,8 +23,8 @@ import {
SqlPartitionedByClause,
SqlQuery,
SqlReplaceClause,
- SqlTableRef,
SqlWithPart,
+ T,
} from 'druid-query-toolkit';
import { filterMap, oneOf } from '../../utils';
@@ -150,10 +150,10 @@ export function fitIngestQueryPattern(query: SqlQuery):
IngestQueryPattern {
let overwriteWhere: SqlExpression | undefined;
if (query.insertClause) {
mode = 'insert';
- destinationTableName = query.insertClause.table.getTable();
+ destinationTableName = query.insertClause.table.getName();
} else if (query.replaceClause) {
mode = 'replace';
- destinationTableName = query.replaceClause.table.getTable();
+ destinationTableName = query.replaceClause.table.getName();
overwriteWhere = query.replaceClause.whereClause?.expression;
} else {
throw new Error(`Must have an INSERT or REPLACE clause`);
@@ -251,7 +251,7 @@ export function ingestQueryPatternToQuery(
partitionedBy,
clusteredBy,
} = ingestQueryPattern;
- return SqlQuery.from(SqlTableRef.create(mainExternalName))
+ return SqlQuery.from(T(mainExternalName))
.applyIf(!preview, q =>
mode === 'insert'
? q.changeInsertIntoTable(destinationTableName)
diff --git
a/web-console/src/druid-models/workbench-query/workbench-query-part.ts
b/web-console/src/druid-models/workbench-query/workbench-query-part.ts
index d78bd8bbe4..604cfb0132 100644
--- a/web-console/src/druid-models/workbench-query/workbench-query-part.ts
+++ b/web-console/src/druid-models/workbench-query/workbench-query-part.ts
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-import { SqlExpression, SqlQuery, SqlTableRef, SqlValues, SqlWithQuery } from
'druid-query-toolkit';
+import { SqlExpression, SqlQuery, SqlValues, SqlWithQuery, T } from
'druid-query-toolkit';
import Hjson from 'hjson';
import * as JSONBig from 'json-bigint-native';
@@ -71,7 +71,7 @@ export class WorkbenchQueryPart {
);
if (!fragmentQuery) return;
- return fragmentQuery.getIngestTable()?.getTable();
+ return fragmentQuery.getIngestTable()?.getName();
}
public readonly id: string;
@@ -179,7 +179,7 @@ export class WorkbenchQueryPart {
public getIngestDatasource(): string | undefined {
const { queryString, parsedQuery } = this;
if (parsedQuery) {
- return parsedQuery.getIngestTable()?.getTable();
+ return parsedQuery.getIngestTable()?.getName();
}
if (this.isJsonLike()) return;
@@ -241,7 +241,7 @@ export class WorkbenchQueryPart {
public toWithPart(): string {
const { queryName, queryString } = this;
- return `${SqlTableRef.create(queryName || 'q')} AS (\n${queryString}\n)`;
+ return `${T(queryName || 'q')} AS (\n${queryString}\n)`;
}
public duplicate(): WorkbenchQueryPart {
diff --git a/web-console/src/druid-models/workbench-query/workbench-query.ts
b/web-console/src/druid-models/workbench-query/workbench-query.ts
index 2a7f2b2e40..36c71cb07a 100644
--- a/web-console/src/druid-models/workbench-query/workbench-query.ts
+++ b/web-console/src/druid-models/workbench-query/workbench-query.ts
@@ -17,16 +17,16 @@
*/
import {
+ C,
+ F,
SqlClusteredByClause,
SqlExpression,
- SqlFunction,
SqlLiteral,
SqlOrderByClause,
SqlOrderByExpression,
SqlPartitionedByClause,
SqlQuery,
- SqlRef,
- SqlTableRef,
+ SqlTable,
} from 'druid-query-toolkit';
import Hjson from 'hjson';
import * as JSONBig from 'json-bigint-native';
@@ -201,10 +201,7 @@ export class WorkbenchQuery {
let partitionedByExpression = partitionedByClause.expression;
if (partitionedByExpression) {
if (partitionedByExpression instanceof SqlLiteral) {
- partitionedByExpression = SqlFunction.floor(
- SqlRef.column('__time'),
- partitionedByExpression,
- );
+ partitionedByExpression = F.floor(C('__time'),
partitionedByExpression);
}
orderByExpressions.push(SqlOrderByExpression.create(partitionedByExpression));
}
@@ -451,8 +448,8 @@ export class WorkbenchQuery {
const parsedQuery = this.getParsedQuery();
if (parsedQuery) {
const fromExpression = parsedQuery.getFirstFromExpression();
- if (fromExpression instanceof SqlTableRef) {
- const firstTable = fromExpression.getTable();
+ if (fromExpression instanceof SqlTable) {
+ const firstTable = fromExpression.getName();
ret = ret.changeQueryParts(
this.queryParts.map(queryPart =>
queryPart.queryName === firstTable ? queryPart.addPreviewLimit() :
queryPart,
diff --git a/web-console/src/helpers/execution/sql-task-execution.ts
b/web-console/src/helpers/execution/sql-task-execution.ts
index 03e08e6e55..e7f7250c53 100644
--- a/web-console/src/helpers/execution/sql-task-execution.ts
+++ b/web-console/src/helpers/execution/sql-task-execution.ts
@@ -17,7 +17,7 @@
*/
import { AxiosResponse, CancelToken } from 'axios';
-import { SqlLiteral } from 'druid-query-toolkit';
+import { L } from 'druid-query-toolkit';
import { Execution, QueryContext } from '../../druid-models';
import { Api } from '../../singletons';
@@ -227,7 +227,7 @@ export async function
updateExecutionWithDatasourceExistsIfNeeded(
COUNT(*) AS num_segments,
COUNT(*) FILTER (WHERE is_published = 1 AND is_available = 0) AS
loading_segments
FROM sys.segments
-WHERE datasource = ${SqlLiteral.create(execution.destination.dataSource)} AND
is_overshadowed = 0`,
+WHERE datasource = ${L(execution.destination.dataSource)} AND is_overshadowed
= 0`,
});
const numSegments: number = deepGet(segmentCheck, '0.num_segments') || 0;
diff --git a/web-console/src/helpers/spec-conversion.ts
b/web-console/src/helpers/spec-conversion.ts
index 76bdc16a92..d35433917f 100644
--- a/web-console/src/helpers/spec-conversion.ts
+++ b/web-console/src/helpers/spec-conversion.ts
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-import { RefName, SqlExpression, SqlLiteral, SqlRef, SqlTableRef } from
'druid-query-toolkit';
+import { C, L, RefName, SqlExpression, T } from 'druid-query-toolkit';
import * as JSONBig from 'json-bigint-native';
import {
@@ -38,10 +38,10 @@ export function getSpecDatasourceName(spec: IngestionSpec):
string {
function convertFilter(filter: any): SqlExpression {
switch (filter.type) {
case 'selector':
- return SqlRef.column(filter.dimension).equal(filter.value);
+ return C(filter.dimension).equal(filter.value);
case 'in':
- return SqlRef.column(filter.dimension).in(filter.values);
+ return C(filter.dimension).in(filter.values);
case 'not':
return convertFilter(filter.field).not();
@@ -57,7 +57,7 @@ function convertFilter(filter: any): SqlExpression {
}
}
-const SOURCE_REF = SqlTableRef.create('source');
+const SOURCE_TABLE = T('source');
export function convertSpecToSql(spec: any): QueryWithContext {
if (!oneOf(spec.type, 'index_parallel', 'index', 'index_hadoop')) {
@@ -108,8 +108,8 @@ export function convertSpecToSql(spec: any):
QueryWithContext {
}
let timeExpression: string;
- const column = timestampSpec.column || 'timestamp';
- const columnRef = SqlRef.column(column);
+ const timestampColumnName = timestampSpec.column || 'timestamp';
+ const timestampColumn = C(timestampColumnName);
const format = timestampSpec.format || 'auto';
const timeTransform = transforms.find(t => t.name === '__time');
if (timeTransform) {
@@ -117,46 +117,44 @@ export function convertSpecToSql(spec: any):
QueryWithContext {
} else {
switch (format) {
case 'auto':
- columns.unshift({ name: column, type: 'string' });
- timeExpression = `CASE WHEN CAST(${columnRef} AS BIGINT) > 0 THEN
MILLIS_TO_TIMESTAMP(CAST(${columnRef} AS BIGINT)) ELSE TIME_PARSE(${columnRef})
END`;
+ columns.unshift({ name: timestampColumnName, type: 'string' });
+ timeExpression = `CASE WHEN CAST(${timestampColumn} AS BIGINT) > 0
THEN MILLIS_TO_TIMESTAMP(CAST(${timestampColumn} AS BIGINT)) ELSE
TIME_PARSE(${timestampColumn}) END`;
break;
case 'iso':
- columns.unshift({ name: column, type: 'string' });
- timeExpression = `TIME_PARSE(${columnRef})`;
+ columns.unshift({ name: timestampColumnName, type: 'string' });
+ timeExpression = `TIME_PARSE(${timestampColumn})`;
break;
case 'posix':
- columns.unshift({ name: column, type: 'long' });
- timeExpression = `MILLIS_TO_TIMESTAMP(${columnRef} * 1000)`;
+ columns.unshift({ name: timestampColumnName, type: 'long' });
+ timeExpression = `MILLIS_TO_TIMESTAMP(${timestampColumn} * 1000)`;
break;
case 'millis':
- columns.unshift({ name: column, type: 'long' });
- timeExpression = `MILLIS_TO_TIMESTAMP(${columnRef})`;
+ columns.unshift({ name: timestampColumnName, type: 'long' });
+ timeExpression = `MILLIS_TO_TIMESTAMP(${timestampColumn})`;
break;
case 'micro':
- columns.unshift({ name: column, type: 'long' });
- timeExpression = `MILLIS_TO_TIMESTAMP(${columnRef} / 1000)`;
+ columns.unshift({ name: timestampColumnName, type: 'long' });
+ timeExpression = `MILLIS_TO_TIMESTAMP(${timestampColumn} / 1000)`;
break;
case 'nano':
- columns.unshift({ name: column, type: 'long' });
- timeExpression = `MILLIS_TO_TIMESTAMP(${columnRef} / 1000000)`;
+ columns.unshift({ name: timestampColumnName, type: 'long' });
+ timeExpression = `MILLIS_TO_TIMESTAMP(${timestampColumn} / 1000000)`;
break;
default:
- columns.unshift({ name: column, type: 'string' });
- timeExpression = `TIME_PARSE(${columnRef},
${SqlLiteral.create(format)})`;
+ columns.unshift({ name: timestampColumnName, type: 'string' });
+ timeExpression = `TIME_PARSE(${timestampColumn}, ${L(format)})`;
break;
}
}
if (timestampSpec.missingValue) {
- timeExpression = `COALESCE(${timeExpression},
TIME_PARSE(${SqlLiteral.create(
- timestampSpec.missingValue,
- )}))`;
+ timeExpression = `COALESCE(${timeExpression},
TIME_PARSE(${L(timestampSpec.missingValue)}))`;
}
timeExpression = convertQueryGranularity(
@@ -180,17 +178,17 @@ export function convertSpecToSql(spec: any):
QueryWithContext {
if (typeof dataSource !== 'string') throw new
Error(`spec.dataSchema.dataSource is not a string`);
if (deepGet(spec, 'spec.ioConfig.appendToExisting')) {
- lines.push(`INSERT INTO ${SqlTableRef.create(dataSource)}`);
+ lines.push(`INSERT INTO ${T(dataSource)}`);
} else {
const overwrite = deepGet(spec, 'spec.ioConfig.dropExisting')
? 'WHERE ' +
- SqlExpression.fromTimeRefAndInterval(
- SqlRef.column('__time'),
+ SqlExpression.fromTimeExpressionAndInterval(
+ C('__time'),
deepGet(spec, 'spec.dataSchema.granularitySpec.intervals'),
)
: 'ALL';
- lines.push(`REPLACE INTO ${SqlTableRef.create(dataSource)} OVERWRITE
${overwrite}`);
+ lines.push(`REPLACE INTO ${T(dataSource)} OVERWRITE ${overwrite}`);
}
let inputSource: any;
@@ -220,27 +218,24 @@ export function convertSpecToSql(spec: any):
QueryWithContext {
if (inputSource.type === 'druid') {
lines.push(
- `WITH ${SOURCE_REF} AS (`,
+ `WITH ${SOURCE_TABLE} AS (`,
` SELECT *`,
- ` FROM ${SqlTableRef.create(inputSource.dataSource)}`,
- ` WHERE ${SqlExpression.fromTimeRefAndInterval(
- SqlRef.column('__time'),
- inputSource.interval,
- )}`,
+ ` FROM ${T(inputSource.dataSource)}`,
+ ` WHERE ${SqlExpression.fromTimeExpressionAndInterval(C('__time'),
inputSource.interval)}`,
')',
);
} else {
lines.push(
- `WITH ${SOURCE_REF} AS (SELECT * FROM TABLE(`,
+ `WITH ${SOURCE_TABLE} AS (SELECT * FROM TABLE(`,
` EXTERN(`,
- ` ${SqlLiteral.create(JSONBig.stringify(inputSource))},`,
+ ` ${L(JSONBig.stringify(inputSource))},`,
);
const inputFormat = deepGet(spec, 'spec.ioConfig.inputFormat');
if (!inputFormat) throw new Error(`spec.ioConfig.inputFormat is not
defined`);
lines.push(
- ` ${SqlLiteral.create(JSONBig.stringify(inputFormat))},`,
- ` ${SqlLiteral.create(JSONBig.stringify(columns))}`,
+ ` ${L(JSONBig.stringify(inputFormat))},`,
+ ` ${L(JSONBig.stringify(columns))}`,
` )`,
`))`,
);
@@ -264,7 +259,7 @@ export function convertSpecToSql(spec: any):
QueryWithContext {
const relevantTransform = transforms.find(t => t.name === dimensionName);
return ` ${
relevantTransform ? `REWRITE_[${relevantTransform.expression}]_TO_SQL
AS ` : ''
- }${SqlRef.column(dimensionName)},${
+ }${C(dimensionName)},${
relevantTransform ? ` --:ISSUE: Transform for dimension could not be
converted` : ''
}`;
}),
@@ -282,7 +277,7 @@ export function convertSpecToSql(spec: any):
QueryWithContext {
.replace(/,(\s+--)/, '$1');
lines.push(selectExpressions.join('\n'));
- lines.push(`FROM ${SOURCE_REF}`);
+ lines.push(`FROM ${SOURCE_TABLE}`);
const filter = deepGet(spec, 'spec.dataSchema.transformSpec.filter');
if (filter) {
@@ -316,7 +311,7 @@ export function convertSpecToSql(spec: any):
QueryWithContext {
partitionsSpec.partitionDimensions ||
(partitionsSpec.partitionDimension ? [partitionsSpec.partitionDimension] :
undefined);
if (Array.isArray(partitionDimensions)) {
- lines.push(`CLUSTERED BY ${partitionDimensions.map(d =>
SqlRef.column(d)).join(', ')}`);
+ lines.push(`CLUSTERED BY ${partitionDimensions.map(d => C(d)).join(',
')}`);
}
return {
@@ -397,56 +392,56 @@ function metricSpecToSqlExpression(metricSpec:
MetricSpec): string | undefined {
}
if (!metricSpec.fieldName) return;
- const ref = SqlRef.column(metricSpec.fieldName);
+ const column = C(metricSpec.fieldName);
switch (metricSpec.type) {
case 'longSum':
case 'floatSum':
case 'doubleSum':
- return `SUM(${ref})`;
+ return `SUM(${column})`;
case 'longMin':
case 'floatMin':
case 'doubleMin':
- return `MIN(${ref})`;
+ return `MIN(${column})`;
case 'longMax':
case 'floatMax':
case 'doubleMax':
- return `MAX(${ref})`;
+ return `MAX(${column})`;
case 'doubleFirst':
case 'floatFirst':
case 'longFirst':
- return `EARLIEST(${ref})`;
+ return `EARLIEST(${column})`;
case 'stringFirst':
- return `EARLIEST(${ref}, ${SqlLiteral.create(metricSpec.maxStringBytes
|| 128)})`;
+ return `EARLIEST(${column}, ${L(metricSpec.maxStringBytes || 128)})`;
case 'doubleLast':
case 'floatLast':
case 'longLast':
- return `LATEST(${ref})`;
+ return `LATEST(${column})`;
case 'stringLast':
- return `LATEST(${ref}, ${SqlLiteral.create(metricSpec.maxStringBytes ||
128)})`;
+ return `LATEST(${column}, ${L(metricSpec.maxStringBytes || 128)})`;
case 'thetaSketch':
- return
`APPROX_COUNT_DISTINCT_DS_THETA(${ref}${extraArgs([metricSpec.size, 16384])})`;
+ return
`APPROX_COUNT_DISTINCT_DS_THETA(${column}${extraArgs([metricSpec.size,
16384])})`;
case 'HLLSketchBuild':
case 'HLLSketchMerge':
- return `APPROX_COUNT_DISTINCT_DS_HLL(${ref}${extraArgs(
+ return `APPROX_COUNT_DISTINCT_DS_HLL(${column}${extraArgs(
[metricSpec.lgK, 12],
[metricSpec.tgtHllType, 'HLL_4'],
)})`;
case 'quantilesDoublesSketch':
// For consistency with the above this should be APPROX_QUANTILE_DS but
that requires a post agg so it does not work quite right.
- return `DS_QUANTILES_SKETCH(${ref}${extraArgs([metricSpec.k, 128])})`;
+ return `DS_QUANTILES_SKETCH(${column}${extraArgs([metricSpec.k, 128])})`;
case 'hyperUnique':
- return `APPROX_COUNT_DISTINCT_BUILTIN(${ref})`;
+ return `APPROX_COUNT_DISTINCT_BUILTIN(${column})`;
default:
// The following things are (knowingly) not supported:
@@ -464,5 +459,5 @@ function extraArgs(...thingAndDefaults: [any, any?][]):
string {
}
if (!thingAndDefaults.length) return '';
- return ', ' + thingAndDefaults.map(([x, def]) => SqlLiteral.create(x ??
def)).join(', ');
+ return ', ' + thingAndDefaults.map(([x, def]) => L(x ?? def)).join(', ');
}
diff --git a/web-console/src/react-table/react-table-utils.ts
b/web-console/src/react-table/react-table-utils.ts
index 2563ceffd3..a87a733046 100644
--- a/web-console/src/react-table/react-table-utils.ts
+++ b/web-console/src/react-table/react-table-utils.ts
@@ -18,7 +18,7 @@
import { IconName } from '@blueprintjs/core';
import { IconNames } from '@blueprintjs/icons';
-import { SqlExpression, SqlFunction, SqlLiteral, SqlRef } from
'druid-query-toolkit';
+import { C, F, SqlExpression } from 'druid-query-toolkit';
import { Filter } from 'react-table';
import { addOrUpdate, caseInsensitiveContains } from '../utils';
@@ -142,24 +142,21 @@ export function sqlQueryCustomTableFilter(filter:
Filter): SqlExpression | undef
const modeAndNeedle = parseFilterModeAndNeedle(filter);
if (!modeAndNeedle) return;
const { mode, needle } = modeAndNeedle;
- const column = SqlRef.column(filter.id);
- const needleLiteral = SqlLiteral.create(needle);
+ const column = C(filter.id);
switch (mode) {
case '=':
- return column.equal(needleLiteral);
+ return column.equal(needle);
case '!=':
- return column.unequal(needleLiteral);
+ return column.unequal(needle);
case '<=':
- return column.lessThanOrEqual(needleLiteral);
+ return column.lessThanOrEqual(needle);
case '>=':
- return column.greaterThanOrEqual(needleLiteral);
+ return column.greaterThanOrEqual(needle);
default:
- return SqlFunction.simple('LOWER', [column]).like(
- SqlLiteral.create(`%${needle.toLowerCase()}%`),
- );
+ return F('LOWER', column).like(`%${needle.toLowerCase()}%`);
}
}
diff --git a/web-console/src/utils/druid-query.ts
b/web-console/src/utils/druid-query.ts
index 2253d4d6b3..668d4703cf 100644
--- a/web-console/src/utils/druid-query.ts
+++ b/web-console/src/utils/druid-query.ts
@@ -17,7 +17,7 @@
*/
import axios, { AxiosResponse } from 'axios';
-import { SqlRef } from 'druid-query-toolkit';
+import { C } from 'druid-query-toolkit';
import { Api } from '../singletons';
@@ -309,6 +309,6 @@ export interface QueryExplanation {
export function formatSignature(queryExplanation: QueryExplanation): string {
return queryExplanation.signature
- .map(({ name, type }) => `${SqlRef.columnWithoutQuotes(name)}::${type}`)
+ .map(({ name, type }) => `${C.optionalQuotes(name)}::${type}`)
.join(', ');
}
diff --git a/web-console/src/utils/query-cursor.ts
b/web-console/src/utils/query-cursor.ts
index c7a4a42235..a881b515c4 100644
--- a/web-console/src/utils/query-cursor.ts
+++ b/web-console/src/utils/query-cursor.ts
@@ -16,12 +16,12 @@
* limitations under the License.
*/
-import { SqlBase, SqlLiteral, SqlQuery } from 'druid-query-toolkit';
+import { L, SqlBase, SqlQuery } from 'druid-query-toolkit';
-export const EMPTY_LITERAL = SqlLiteral.create('');
+export const EMPTY_LITERAL = L('');
const CRAZY_STRING = '[email protected].$';
-const DOT_DOT_DOT_LITERAL = SqlLiteral.create('...');
+const DOT_DOT_DOT_LITERAL = L('...');
export function prettyPrintSql(b: SqlBase): string {
return b
@@ -44,14 +44,7 @@ export interface RowColumn {
}
export function findEmptyLiteralPosition(query: SqlQuery): RowColumn |
undefined {
- const subQueryString = query
- .walk(b => {
- if (b === EMPTY_LITERAL) {
- return SqlLiteral.create(CRAZY_STRING);
- }
- return b;
- })
- .toString();
+ const subQueryString = query.walk(b => (b === EMPTY_LITERAL ?
L(CRAZY_STRING) : b)).toString();
const crazyIndex = subQueryString.indexOf(CRAZY_STRING);
if (crazyIndex < 0) return;
diff --git a/web-console/src/utils/sample-query.tsx
b/web-console/src/utils/sample-query.tsx
index 01f4f2d43d..25765435e0 100644
--- a/web-console/src/utils/sample-query.tsx
+++ b/web-console/src/utils/sample-query.tsx
@@ -17,18 +17,18 @@
*/
import {
+ C,
Column,
+ F,
+ L,
LiteralValue,
QueryResult,
RefName,
SqlAlias,
SqlColumnList,
SqlExpression,
- SqlFunction,
- SqlLiteral,
SqlQuery,
SqlRecord,
- SqlRef,
SqlValues,
} from 'druid-query-toolkit';
@@ -50,13 +50,13 @@ export function sampleDataToQuery(sample: QueryResult):
SqlQuery {
SqlRecord.create(
row.map((r, i) => {
if (header[i].nativeType === 'COMPLEX<json>') {
- return SqlLiteral.create(JSON.stringify(r));
+ return L(JSON.stringify(r));
} else if (Array.isArray(r)) {
arrayIndexes[i] = true;
- return SqlLiteral.create(r.join(SAMPLE_ARRAY_SEPARATOR));
+ return L(r.join(SAMPLE_ARRAY_SEPARATOR));
} else {
- // Avoid actually using NULL literals as they create havc in
the VALUES type system and throw errors.
- return SqlLiteral.create(r == null ? nullForColumn(header[i])
: r);
+ // Avoid actually using NULL literals as they create havoc in
the VALUES type system and throw errors.
+ return L(r == null ? nullForColumn(header[i]) : r);
}
}),
),
@@ -67,11 +67,11 @@ export function sampleDataToQuery(sample: QueryResult):
SqlQuery {
}),
).changeSelectExpressions(
header.map((h, i) => {
- let ex: SqlExpression = SqlRef.column(`c${i}`);
+ let ex: SqlExpression = C(`c${i}`);
if (h.nativeType === 'COMPLEX<json>') {
- ex = SqlFunction.simple('PARSE_JSON', [ex]);
+ ex = F('PARSE_JSON', ex);
} else if (arrayIndexes[i]) {
- ex = SqlFunction.simple('STRING_TO_MV', [ex,
SqlLiteral.create(SAMPLE_ARRAY_SEPARATOR)]);
+ ex = F('STRING_TO_MV', ex, SAMPLE_ARRAY_SEPARATOR);
} else if (h.sqlType) {
ex = ex.cast(h.sqlType);
}
diff --git a/web-console/src/utils/sql.ts b/web-console/src/utils/sql.ts
index a98a0c2686..4e63f4a23c 100644
--- a/web-console/src/utils/sql.ts
+++ b/web-console/src/utils/sql.ts
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-import { SqlExpression, SqlFunction, SqlLiteral, SqlRef, SqlStar } from
'druid-query-toolkit';
+import { SqlColumn, SqlExpression, SqlFunction, SqlLiteral, SqlStar } from
'druid-query-toolkit';
export function timeFormatToSql(timeFormat: string): SqlExpression | undefined
{
switch (timeFormat) {
@@ -54,7 +54,7 @@ export function convertToGroupByExpression(ex:
SqlExpression): SqlExpression | u
if (interestingArgs.length !== 1) return;
const newEx = interestingArgs[0];
- if (newEx instanceof SqlRef) return newEx;
+ if (newEx instanceof SqlColumn) return newEx;
return newEx.as((ex.getOutputName() || 'grouped').replace(/^[a-z]+_/i, ''));
}
diff --git a/web-console/src/views/datasources-view/datasources-view.tsx
b/web-console/src/views/datasources-view/datasources-view.tsx
index b368fccf9e..7f384fc8bc 100644
--- a/web-console/src/views/datasources-view/datasources-view.tsx
+++ b/web-console/src/views/datasources-view/datasources-view.tsx
@@ -19,7 +19,7 @@
import { FormGroup, InputGroup, Intent, MenuItem, Switch } from
'@blueprintjs/core';
import { IconNames } from '@blueprintjs/icons';
import classNames from 'classnames';
-import { SqlQuery, SqlTableRef } from 'druid-query-toolkit';
+import { SqlQuery, T } from 'druid-query-toolkit';
import React from 'react';
import ReactTable, { Filter } from 'react-table';
@@ -830,8 +830,7 @@ ORDER BY 1`;
goToActions.push({
icon: IconNames.APPLICATION,
title: 'Query with SQL',
- onAction: () =>
- goToQuery({ queryString:
SqlQuery.create(SqlTableRef.create(datasource)).toString() }),
+ onAction: () => goToQuery({ queryString:
SqlQuery.create(T(datasource)).toString() }),
});
}
diff --git a/web-console/src/views/segments-view/segments-view.tsx
b/web-console/src/views/segments-view/segments-view.tsx
index 4f9ee21a29..8b5842bd85 100644
--- a/web-console/src/views/segments-view/segments-view.tsx
+++ b/web-console/src/views/segments-view/segments-view.tsx
@@ -19,7 +19,7 @@
import { Button, ButtonGroup, Intent, Label, MenuItem, Switch } from
'@blueprintjs/core';
import { IconNames } from '@blueprintjs/icons';
import classNames from 'classnames';
-import { SqlComparison, SqlExpression, SqlLiteral, SqlRef } from
'druid-query-toolkit';
+import { C, L, SqlComparison, SqlExpression } from 'druid-query-toolkit';
import * as JSONBig from 'json-bigint-native';
import React from 'react';
import ReactTable, { Filter } from 'react-table';
@@ -125,7 +125,7 @@ const tableColumns: Record<CapabilitiesMode, string[]> = {
};
function formatRangeDimensionValue(dimension: any, value: any): string {
- return
`${SqlRef.column(String(dimension))}=${SqlLiteral.create(String(value))}`;
+ return `${C(String(dimension))}=${L(String(value))}`;
}
export interface SegmentsViewProps {
@@ -281,20 +281,23 @@ END AS "time_span"`,
// Creates filters like `shard_spec LIKE '%"type":"numbered"%'`
const modeAndNeedle = parseFilterModeAndNeedle(f);
if (!modeAndNeedle) return;
- const shardSpecRef = SqlRef.column('shard_spec');
+ const shardSpecColumn = C('shard_spec');
switch (modeAndNeedle.mode) {
case '=':
- return SqlComparison.like(shardSpecRef,
`%"type":"${modeAndNeedle.needle}"%`);
+ return SqlComparison.like(shardSpecColumn,
`%"type":"${modeAndNeedle.needle}"%`);
case '!=':
- return SqlComparison.notLike(shardSpecRef,
`%"type":"${modeAndNeedle.needle}"%`);
+ return SqlComparison.notLike(
+ shardSpecColumn,
+ `%"type":"${modeAndNeedle.needle}"%`,
+ );
default:
- return SqlComparison.like(shardSpecRef,
`%"type":"${modeAndNeedle.needle}%`);
+ return SqlComparison.like(shardSpecColumn,
`%"type":"${modeAndNeedle.needle}%`);
}
} else if (f.id.startsWith('is_')) {
if (f.value === 'all') return;
- return SqlRef.column(f.id).equal(f.value === 'true' ? 1 : 0);
+ return C(f.id).equal(f.value === 'true' ? 1 : 0);
} else {
return sqlQueryCustomTableFilter(f);
}
@@ -335,7 +338,7 @@ END AS "time_span"`,
queryParts.push(
'ORDER BY ' +
sorted
- .map((sort: any) => `${SqlRef.column(sort.id)} ${sort.desc
? 'DESC' : 'ASC'}`)
+ .map((sort: any) => `${C(sort.id)} ${sort.desc ? 'DESC' :
'ASC'}`)
.join(', '),
);
}
@@ -352,7 +355,7 @@ END AS "time_span"`,
queryParts.push(
'ORDER BY ' +
sorted
- .map((sort: any) => `${SqlRef.column(sort.id)} ${sort.desc
? 'DESC' : 'ASC'}`)
+ .map((sort: any) => `${C(sort.id)} ${sort.desc ? 'DESC' :
'ASC'}`)
.join(', '),
);
}
diff --git
a/web-console/src/views/sql-data-loader-view/column-actions/column-actions.tsx
b/web-console/src/views/sql-data-loader-view/column-actions/column-actions.tsx
index c0c198f26d..363a6e290b 100644
---
a/web-console/src/views/sql-data-loader-view/column-actions/column-actions.tsx
+++
b/web-console/src/views/sql-data-loader-view/column-actions/column-actions.tsx
@@ -19,7 +19,7 @@
import { Button, FormGroup, Menu, MenuItem } from '@blueprintjs/core';
import { IconNames } from '@blueprintjs/icons';
import { Popover2 } from '@blueprintjs/popover2';
-import { QueryResult, SqlExpression, SqlFunction } from 'druid-query-toolkit';
+import { F, QueryResult, SqlExpression } from 'druid-query-toolkit';
import React from 'react';
import { possibleDruidFormatForValues, TIME_COLUMN } from
'../../../druid-models';
@@ -49,7 +49,7 @@ export const ColumnActions = React.memo(function
ExpressionEditor(props: ColumnA
const expression =
queryResult.sqlQuery?.getSelectExpressionForIndex(headerIndex);
- if (sqlQuery.getEffectiveWhereExpression().containsColumn(header)) {
+ if (sqlQuery.getEffectiveWhereExpression().containsColumnName(header)) {
removeFilterButton = (
<Button
icon={IconNames.FILTER_REMOVE}
@@ -147,7 +147,6 @@ export const ColumnActions = React.memo(function
ExpressionEditor(props: ColumnA
};
const underlyingSelectExpression =
expression.getUnderlyingExpression();
-
convertButton = (
<Popover2
content={
@@ -159,9 +158,7 @@ export const ColumnActions = React.memo(function
ExpressionEditor(props: ColumnA
text="Convert to SUM(...)"
onClick={() => {
convertToAggregate([
- SqlFunction.simple('SUM',
[underlyingSelectExpression]).as(
- `sum_${header}`,
- ),
+ F('SUM',
underlyingSelectExpression).as(`sum_${header}`),
]);
}}
/>
@@ -169,9 +166,7 @@ export const ColumnActions = React.memo(function
ExpressionEditor(props: ColumnA
text="Convert to MIN(...)"
onClick={() => {
convertToAggregate([
- SqlFunction.simple('MIN',
[underlyingSelectExpression]).as(
- `min_${header}`,
- ),
+ F('MIN',
underlyingSelectExpression).as(`min_${header}`),
]);
}}
/>
@@ -179,9 +174,7 @@ export const ColumnActions = React.memo(function
ExpressionEditor(props: ColumnA
text="Convert to MAX(...)"
onClick={() => {
convertToAggregate([
- SqlFunction.simple('MAX',
[underlyingSelectExpression]).as(
- `max_${header}`,
- ),
+ F('MAX',
underlyingSelectExpression).as(`max_${header}`),
]);
}}
/>
@@ -189,15 +182,9 @@ export const ColumnActions = React.memo(function
ExpressionEditor(props: ColumnA
text="Convert to SUM(...), MIN(...), and MAX(...)"
onClick={() => {
convertToAggregate([
- SqlFunction.simple('SUM',
[underlyingSelectExpression]).as(
- `sum_${header}`,
- ),
- SqlFunction.simple('MIN',
[underlyingSelectExpression]).as(
- `min_${header}`,
- ),
- SqlFunction.simple('MAX',
[underlyingSelectExpression]).as(
- `max_${header}`,
- ),
+ F('SUM',
underlyingSelectExpression).as(`sum_${header}`),
+ F('MIN',
underlyingSelectExpression).as(`min_${header}`),
+ F('MAX',
underlyingSelectExpression).as(`max_${header}`),
]);
}}
/>
@@ -207,9 +194,9 @@ export const ColumnActions = React.memo(function
ExpressionEditor(props: ColumnA
text="Convert to APPROX_COUNT_DISTINCT_DS_HLL(...)"
onClick={() => {
convertToAggregate([
- SqlFunction.simple('APPROX_COUNT_DISTINCT_DS_HLL',
[
- underlyingSelectExpression,
- ]).as(`unique_${header}`),
+ F('APPROX_COUNT_DISTINCT_DS_HLL',
underlyingSelectExpression).as(
+ `unique_${header}`,
+ ),
]);
}}
/>
@@ -217,9 +204,9 @@ export const ColumnActions = React.memo(function
ExpressionEditor(props: ColumnA
text="Convert to APPROX_COUNT_DISTINCT_DS_THETA(...)"
onClick={() => {
convertToAggregate([
-
SqlFunction.simple('APPROX_COUNT_DISTINCT_DS_THETA', [
- underlyingSelectExpression,
- ]).as(`unique_${header}`),
+ F('APPROX_COUNT_DISTINCT_DS_THETA',
underlyingSelectExpression).as(
+ `unique_${header}`,
+ ),
]);
}}
/>
@@ -227,9 +214,9 @@ export const ColumnActions = React.memo(function
ExpressionEditor(props: ColumnA
text="Convert to APPROX_COUNT_DISTINCT_BUILTIN(...)"
onClick={() => {
convertToAggregate([
-
SqlFunction.simple('APPROX_COUNT_DISTINCT_BUILTIN', [
- underlyingSelectExpression,
- ]).as(`unique_${header}`),
+ F('APPROX_COUNT_DISTINCT_BUILTIN',
underlyingSelectExpression).as(
+ `unique_${header}`,
+ ),
]);
}}
/>
diff --git
a/web-console/src/views/sql-data-loader-view/ingestion-progress-dialog/ingestion-progress-dialog.tsx
b/web-console/src/views/sql-data-loader-view/ingestion-progress-dialog/ingestion-progress-dialog.tsx
index 69dcd79918..3e911096c7 100644
---
a/web-console/src/views/sql-data-loader-view/ingestion-progress-dialog/ingestion-progress-dialog.tsx
+++
b/web-console/src/views/sql-data-loader-view/ingestion-progress-dialog/ingestion-progress-dialog.tsx
@@ -19,7 +19,7 @@
import { Button, Classes, Dialog, Intent } from '@blueprintjs/core';
import { IconNames } from '@blueprintjs/icons';
import classNames from 'classnames';
-import { SqlTableRef } from 'druid-query-toolkit';
+import { T } from 'druid-query-toolkit';
import React, { useState } from 'react';
import { Execution, QueryWithContext } from '../../../druid-models';
@@ -117,7 +117,7 @@ export const IngestionProgressDialog = React.memo(function
IngestionProgressDial
onClick={() => {
if (!insertResultState.data) return;
goToQuery({
- queryString: `SELECT * FROM ${SqlTableRef.create(
+ queryString: `SELECT * FROM ${T(
insertResultState.data.getIngestDatasource()!,
)}`,
});
diff --git
a/web-console/src/views/sql-data-loader-view/schema-step/column-list/expression-entry/expression-entry.tsx
b/web-console/src/views/sql-data-loader-view/schema-step/column-list/expression-entry/expression-entry.tsx
index eca01b3988..3a50976cc5 100644
---
a/web-console/src/views/sql-data-loader-view/schema-step/column-list/expression-entry/expression-entry.tsx
+++
b/web-console/src/views/sql-data-loader-view/schema-step/column-list/expression-entry/expression-entry.tsx
@@ -18,7 +18,7 @@
import { Icon } from '@blueprintjs/core';
import classNames from 'classnames';
-import { Column, QueryResult, SqlRef } from 'druid-query-toolkit';
+import { Column, QueryResult, SqlColumn } from 'druid-query-toolkit';
import React from 'react';
import { columnToIcon } from '../../../../../utils';
@@ -60,7 +60,7 @@ export const ExpressionEntry = function
ExpressionEntry(props: ExpressionEntryPr
{expression.getOutputName() || 'EXPR?'}
<span className="type-name">{` :: ${column.nativeType}`}</span>
</div>
- {!(expression instanceof SqlRef) && (
+ {!(expression instanceof SqlColumn) && (
<div className="expression">
{expression.getUnderlyingExpression().prettify({ keywordCasing:
'preserve' }).toString()}
</div>
diff --git
a/web-console/src/views/sql-data-loader-view/schema-step/preview-table/preview-table.tsx
b/web-console/src/views/sql-data-loader-view/schema-step/preview-table/preview-table.tsx
index 8744e16f89..aab5d9e4c9 100644
---
a/web-console/src/views/sql-data-loader-view/schema-step/preview-table/preview-table.tsx
+++
b/web-console/src/views/sql-data-loader-view/schema-step/preview-table/preview-table.tsx
@@ -76,8 +76,8 @@ export const PreviewTable = React.memo(function
PreviewTable(props: PreviewTable
if (!parsedQuery ||
!parsedQuery.isRealOutputColumnAtSelectIndex(headerIndex)) return false;
return (
- parsedQuery.getEffectiveWhereExpression().containsColumn(header) ||
- parsedQuery.getEffectiveHavingExpression().containsColumn(header)
+ parsedQuery.getEffectiveWhereExpression().containsColumnName(header) ||
+ parsedQuery.getEffectiveHavingExpression().containsColumnName(header)
);
}
diff --git
a/web-console/src/views/sql-data-loader-view/schema-step/rollup-analysis-pane/rollup-analysis-pane.tsx
b/web-console/src/views/sql-data-loader-view/schema-step/rollup-analysis-pane/rollup-analysis-pane.tsx
index a53eff6495..f6112b26b8 100644
---
a/web-console/src/views/sql-data-loader-view/schema-step/rollup-analysis-pane/rollup-analysis-pane.tsx
+++
b/web-console/src/views/sql-data-loader-view/schema-step/rollup-analysis-pane/rollup-analysis-pane.tsx
@@ -19,7 +19,7 @@
import { Button, Callout, Intent, Tag } from '@blueprintjs/core';
import { IconNames } from '@blueprintjs/icons';
import { CancelToken } from 'axios';
-import { QueryResult, SqlExpression, SqlFunction, SqlQuery } from
'druid-query-toolkit';
+import { F, QueryResult, SqlExpression, SqlFunction, SqlQuery } from
'druid-query-toolkit';
import React, { useEffect } from 'react';
import { Execution } from '../../../../druid-models';
@@ -47,8 +47,8 @@ function expressionCastToString(ex: SqlExpression):
SqlExpression {
return CAST_AS_VARCHAR_TEMPLATE.fillPlaceholders([ex]);
}
-function countDistinct(ex: SqlExpression): SqlExpression {
- return SqlFunction.simple('APPROX_COUNT_DISTINCT_DS_HLL', [ex]);
+function approxCountDistinct(ex: SqlExpression): SqlExpression {
+ return F('APPROX_COUNT_DISTINCT_DS_HLL', ex);
}
function within(a: number, b: number, percent: number): boolean {
@@ -159,13 +159,13 @@ export const RollupAnalysisPane = React.memo(function
RollupAnalysisPane(
const expressionPairs: SqlExpression[] = deep
? pairs(expressions.length).map(([i, j]) =>
- countDistinct(SqlFunction.simple('CONCAT', [groupedAsStrings[i],
groupedAsStrings[j]])),
+ approxCountDistinct(F('CONCAT', groupedAsStrings[i],
groupedAsStrings[j])),
)
: [];
const queryString = seedQuery
-
.changeSelectExpressions(groupedAsStrings.map(countDistinct).concat(expressionPairs))
- .addSelect(countDistinct(SqlFunction.simple('CONCAT',
groupedAsStrings)), {
+
.changeSelectExpressions(groupedAsStrings.map(approxCountDistinct).concat(expressionPairs))
+ .addSelect(approxCountDistinct(SqlFunction.simple('CONCAT',
groupedAsStrings)), {
insertIndex: 0,
})
.addSelect(SqlFunction.COUNT_STAR, { insertIndex: 0 })
diff --git
a/web-console/src/views/sql-data-loader-view/schema-step/schema-step.tsx
b/web-console/src/views/sql-data-loader-view/schema-step/schema-step.tsx
index 489c2f393e..d58e892cb0 100644
--- a/web-console/src/views/sql-data-loader-view/schema-step/schema-step.tsx
+++ b/web-console/src/views/sql-data-loader-view/schema-step/schema-step.tsx
@@ -32,14 +32,7 @@ import { IconNames } from '@blueprintjs/icons';
import { Popover2 } from '@blueprintjs/popover2';
import classNames from 'classnames';
import { select, selectAll } from 'd3-selection';
-import {
- QueryResult,
- QueryRunner,
- SqlExpression,
- SqlFunction,
- SqlQuery,
- SqlRef,
-} from 'druid-query-toolkit';
+import { C, F, QueryResult, QueryRunner, SqlExpression, SqlQuery } from
'druid-query-toolkit';
import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef,
useState } from 'react';
import { ClearableInput, LearnMore, Loader } from '../../../components';
@@ -361,10 +354,9 @@ export const SchemaStep = function SchemaStep(props:
SchemaStepProps) {
...ingestQueryPattern,
dimensions: without(ingestQueryPattern.dimensions, countExpression),
metrics: [
- (countExpression
- ? SqlFunction.simple('SUM',
[countExpression.getUnderlyingExpression()])
- : SqlFunction.COUNT_STAR
- ).as(countExpression?.getOutputName() || 'count'),
+ (countExpression ? F.sum(countExpression.getUnderlyingExpression())
: F.count()).as(
+ countExpression?.getOutputName() || 'count',
+ ),
],
});
}
@@ -460,8 +452,8 @@ export const SchemaStep = function SchemaStep(props:
SchemaStepProps) {
const unusedColumns = ingestQueryPattern
? ingestQueryPattern.mainExternalConfig.signature.filter(
({ name }) =>
- !ingestQueryPattern.dimensions.some(d => d.containsColumn(name)) &&
- !ingestQueryPattern.metrics?.some(m => m.containsColumn(name)),
+ !ingestQueryPattern.dimensions.some(d => d.containsColumnName(name))
&&
+ !ingestQueryPattern.metrics?.some(m => m.containsColumnName(name)),
)
: [];
@@ -714,7 +706,7 @@ export const SchemaStep = function SchemaStep(props:
SchemaStepProps) {
onClick={() => {
handleQueryAction(q =>
q.addSelect(
- SqlRef.column(column.name),
+ C(column.name),
ingestQueryPattern.metrics
? { insertIndex: 'last-grouping',
addToGroupBy: 'end' }
: {},
diff --git
a/web-console/src/views/sql-data-loader-view/sql-data-loader-view.tsx
b/web-console/src/views/sql-data-loader-view/sql-data-loader-view.tsx
index 162d2fd8c6..23c81d02d2 100644
--- a/web-console/src/views/sql-data-loader-view/sql-data-loader-view.tsx
+++ b/web-console/src/views/sql-data-loader-view/sql-data-loader-view.tsx
@@ -107,7 +107,7 @@ export const SqlDataLoaderView = React.memo(function
SqlDataLoaderView(
onDone={async () => {
const ingestDatasource = SqlQuery.parse(content.queryString)
.getIngestTable()
- ?.getTable();
+ ?.getName();
if (!ingestDatasource) {
AppToaster.show({ message: `Must have an ingest datasource`,
intent: Intent.DANGER });
diff --git
a/web-console/src/views/workbench-view/column-tree/column-tree-menu/number-menu-items/number-menu-items.tsx
b/web-console/src/views/workbench-view/column-tree/column-tree-menu/number-menu-items/number-menu-items.tsx
index c85ddbe9d3..3be7164570 100644
---
a/web-console/src/views/workbench-view/column-tree/column-tree-menu/number-menu-items/number-menu-items.tsx
+++
b/web-console/src/views/workbench-view/column-tree/column-tree-menu/number-menu-items/number-menu-items.tsx
@@ -18,12 +18,12 @@
import { MenuItem } from '@blueprintjs/core';
import { IconNames } from '@blueprintjs/icons';
-import { SqlExpression, SqlFunction, SqlLiteral, SqlQuery, SqlRef } from
'druid-query-toolkit';
+import { C, F, L, SqlExpression, SqlQuery } from 'druid-query-toolkit';
import React from 'react';
import { prettyPrintSql } from '../../../../../utils';
-const NINE_THOUSAND = SqlLiteral.create(9000);
+const NINE_THOUSAND = L(9000);
export interface NumberMenuItemsProps {
table: string;
@@ -36,7 +36,6 @@ export interface NumberMenuItemsProps {
export const NumberMenuItems = React.memo(function NumberMenuItems(props:
NumberMenuItemsProps) {
function renderFilterMenu(): JSX.Element {
const { columnName, parsedQuery, onQueryChange } = props;
- const ref = SqlRef.column(columnName);
function filterMenuItem(clause: SqlExpression) {
return (
@@ -49,17 +48,18 @@ export const NumberMenuItems = React.memo(function
NumberMenuItems(props: Number
);
}
+ const column = C(columnName);
return (
<MenuItem icon={IconNames.FILTER} text="Filter">
- {filterMenuItem(ref.greaterThan(NINE_THOUSAND))}
- {filterMenuItem(ref.lessThanOrEqual(NINE_THOUSAND))}
+ {filterMenuItem(column.greaterThan(NINE_THOUSAND))}
+ {filterMenuItem(column.lessThanOrEqual(NINE_THOUSAND))}
</MenuItem>
);
}
function renderRemoveFilter(): JSX.Element | undefined {
const { columnName, parsedQuery, onQueryChange } = props;
- if (!parsedQuery.getEffectiveWhereExpression().containsColumn(columnName))
return;
+ if
(!parsedQuery.getEffectiveWhereExpression().containsColumnName(columnName))
return;
return (
<MenuItem
@@ -75,7 +75,6 @@ export const NumberMenuItems = React.memo(function
NumberMenuItems(props: Number
function renderGroupByMenu(): JSX.Element | undefined {
const { columnName, parsedQuery, onQueryChange } = props;
if (!parsedQuery.hasGroupBy()) return;
- const ref = SqlRef.column(columnName);
function groupByMenuItem(ex: SqlExpression, alias?: string) {
return (
@@ -94,13 +93,11 @@ export const NumberMenuItems = React.memo(function
NumberMenuItems(props: Number
);
}
+ const column = C(columnName);
return (
<MenuItem icon={IconNames.GROUP_OBJECTS} text="Group by">
- {groupByMenuItem(ref)}
- {groupByMenuItem(
- SqlFunction.simple('TRUNC', [ref, SqlLiteral.create(-1)]),
- `${columnName}_truncated`,
- )}
+ {groupByMenuItem(column)}
+ {groupByMenuItem(F('TRUNC', column, -1), `${columnName}_truncated`)}
</MenuItem>
);
}
@@ -124,7 +121,6 @@ export const NumberMenuItems = React.memo(function
NumberMenuItems(props: Number
function renderAggregateMenu(): JSX.Element | undefined {
const { columnName, parsedQuery, onQueryChange } = props;
if (!parsedQuery.hasGroupBy()) return;
- const ref = SqlRef.column(columnName);
function aggregateMenuItem(ex: SqlExpression, alias: string) {
return (
@@ -137,17 +133,15 @@ export const NumberMenuItems = React.memo(function
NumberMenuItems(props: Number
);
}
+ const column = C(columnName);
return (
<MenuItem icon={IconNames.FUNCTION} text="Aggregate">
- {aggregateMenuItem(SqlFunction.simple('SUM', [ref]),
`sum_${columnName}`)}
- {aggregateMenuItem(SqlFunction.simple('MIN', [ref]),
`min_${columnName}`)}
- {aggregateMenuItem(SqlFunction.simple('MAX', [ref]),
`max_${columnName}`)}
- {aggregateMenuItem(SqlFunction.simple('AVG', [ref]),
`avg_${columnName}`)}
- {aggregateMenuItem(
- SqlFunction.simple('APPROX_QUANTILE', [ref,
SqlLiteral.create(0.98)]),
- `p98_${columnName}`,
- )}
- {aggregateMenuItem(SqlFunction.simple('LATEST', [ref]),
`latest_${columnName}`)}
+ {aggregateMenuItem(F('SUM', column), `sum_${columnName}`)}
+ {aggregateMenuItem(F('MIN', column), `min_${columnName}`)}
+ {aggregateMenuItem(F('MAX', column), `max_${columnName}`)}
+ {aggregateMenuItem(F('AVG', column), `avg_${columnName}`)}
+ {aggregateMenuItem(F('APPROX_QUANTILE', column, 0.98),
`p98_${columnName}`)}
+ {aggregateMenuItem(F('LATEST', column), `latest_${columnName}`)}
</MenuItem>
);
}
diff --git
a/web-console/src/views/workbench-view/column-tree/column-tree-menu/string-menu-items/string-menu-items.tsx
b/web-console/src/views/workbench-view/column-tree/column-tree-menu/string-menu-items/string-menu-items.tsx
index 807178cb0b..04cc2fe7fd 100644
---
a/web-console/src/views/workbench-view/column-tree/column-tree-menu/string-menu-items/string-menu-items.tsx
+++
b/web-console/src/views/workbench-view/column-tree/column-tree-menu/string-menu-items/string-menu-items.tsx
@@ -18,15 +18,7 @@
import { MenuItem } from '@blueprintjs/core';
import { IconNames } from '@blueprintjs/icons';
-import {
- SqlExpression,
- SqlFunction,
- SqlJoinPart,
- SqlLiteral,
- SqlQuery,
- SqlRef,
- SqlTableRef,
-} from 'druid-query-toolkit';
+import { C, F, N, SqlExpression, SqlJoinPart, SqlQuery, T } from
'druid-query-toolkit';
import React from 'react';
import { EMPTY_LITERAL, prettyPrintSql } from '../../../../../utils';
@@ -43,7 +35,6 @@ export interface StringMenuItemsProps {
export const StringMenuItems = React.memo(function StringMenuItems(props:
StringMenuItemsProps) {
function renderFilterMenu(): JSX.Element | undefined {
const { columnName, parsedQuery, onQueryChange } = props;
- const ref = SqlRef.column(columnName);
function filterMenuItem(clause: SqlExpression, run = true) {
return (
@@ -56,19 +47,20 @@ export const StringMenuItems = React.memo(function
StringMenuItems(props: String
);
}
+ const column = C(columnName);
return (
<MenuItem icon={IconNames.FILTER} text="Filter">
- {filterMenuItem(ref.isNotNull())}
- {filterMenuItem(ref.equal(EMPTY_LITERAL), false)}
- {filterMenuItem(ref.like(EMPTY_LITERAL), false)}
- {filterMenuItem(SqlFunction.simple('REGEXP_LIKE', [ref,
EMPTY_LITERAL]), false)}
+ {filterMenuItem(column.isNotNull())}
+ {filterMenuItem(column.equal(EMPTY_LITERAL), false)}
+ {filterMenuItem(column.like(EMPTY_LITERAL), false)}
+ {filterMenuItem(F('REGEXP_LIKE', column, EMPTY_LITERAL), false)}
</MenuItem>
);
}
function renderRemoveFilter(): JSX.Element | undefined {
const { columnName, parsedQuery, onQueryChange } = props;
- if (!parsedQuery.getEffectiveWhereExpression().containsColumn(columnName))
return;
+ if
(!parsedQuery.getEffectiveWhereExpression().containsColumnName(columnName))
return;
return (
<MenuItem
@@ -118,24 +110,12 @@ export const StringMenuItems = React.memo(function
StringMenuItems(props: String
);
}
+ const column = C(columnName);
return (
<MenuItem icon={IconNames.GROUP_OBJECTS} text="Group by">
- {groupByMenuItem(SqlRef.column(columnName))}
- {groupByMenuItem(
- SqlFunction.simple('SUBSTRING', [
- SqlRef.column(columnName),
- SqlLiteral.create(1),
- SqlLiteral.create(2),
- ]),
- `${columnName}_substring`,
- )}
- {groupByMenuItem(
- SqlFunction.simple('REGEXP_EXTRACT', [
- SqlRef.column(columnName),
- SqlLiteral.create('(\\d+)'),
- ]),
- `${columnName}_extract`,
- )}
+ {groupByMenuItem(column)}
+ {groupByMenuItem(F('SUBSTRING', column, 1, 2),
`${columnName}_substring`)}
+ {groupByMenuItem(F('REGEXP_EXTRACT', column, '(\\d+)'),
`${columnName}_extract`)}
</MenuItem>
);
}
@@ -143,7 +123,6 @@ export const StringMenuItems = React.memo(function
StringMenuItems(props: String
function renderAggregateMenu(): JSX.Element | undefined {
const { columnName, parsedQuery, onQueryChange } = props;
if (!parsedQuery.hasGroupBy()) return;
- const ref = SqlRef.column(columnName);
function aggregateMenuItem(ex: SqlExpression, alias: string, run = true) {
return (
@@ -156,18 +135,16 @@ export const StringMenuItems = React.memo(function
StringMenuItems(props: String
);
}
+ const column = C(columnName);
return (
<MenuItem icon={IconNames.FUNCTION} text="Aggregate">
- {aggregateMenuItem(SqlFunction.countDistinct(ref),
`dist_${columnName}`)}
+ {aggregateMenuItem(F.countDistinct(column), `dist_${columnName}`)}
{aggregateMenuItem(
- SqlFunction.COUNT_STAR.addWhereExpression(ref.equal(EMPTY_LITERAL)),
+ F.count().addWhereExpression(column.equal(EMPTY_LITERAL)),
`filtered_dist_${columnName}`,
false,
)}
- {aggregateMenuItem(
- SqlFunction.simple('LATEST', [ref, SqlLiteral.create(100)]),
- `latest_${columnName}`,
- )}
+ {aggregateMenuItem(F('LATEST', column, 100), `latest_${columnName}`)}
</MenuItem>
);
}
@@ -175,6 +152,8 @@ export const StringMenuItems = React.memo(function
StringMenuItems(props: String
function renderJoinMenu(): JSX.Element | undefined {
const { schema, table, columnName, parsedQuery, onQueryChange } = props;
if (schema !== 'lookup' || !parsedQuery) return;
+ const firstTableName = parsedQuery.getFirstTableName();
+ if (!firstTableName) return;
const { originalTableColumn, lookupColumn } = getJoinColumns(parsedQuery,
table);
@@ -188,13 +167,15 @@ export const StringMenuItems = React.memo(function
StringMenuItems(props: String
parsedQuery.addJoin(
SqlJoinPart.create(
'LEFT',
- SqlTableRef.create(table, schema),
- SqlRef.column(columnName, table, 'lookup').equal(
- SqlRef.column(
- lookupColumn === columnName ? originalTableColumn :
'XXX',
- parsedQuery.getFirstTableName(),
+ N(schema).table(table),
+ N('lookup')
+ .table(table)
+ .column(columnName)
+ .equal(
+ T(firstTableName).column(
+ lookupColumn === columnName ? originalTableColumn :
'XXX',
+ ),
),
- ),
),
),
false,
@@ -209,13 +190,15 @@ export const StringMenuItems = React.memo(function
StringMenuItems(props: String
parsedQuery.addJoin(
SqlJoinPart.create(
'INNER',
- SqlTableRef.create(table, schema),
- SqlRef.column(columnName, table, 'lookup').equal(
- SqlRef.column(
- lookupColumn === columnName ? originalTableColumn :
'XXX',
- parsedQuery.getFirstTableName(),
+ N(schema).table(table),
+ N('lookup')
+ .table(table)
+ .column(columnName)
+ .equal(
+ T(firstTableName).column(
+ lookupColumn === columnName ? originalTableColumn :
'XXX',
+ ),
),
- ),
),
),
false,
diff --git
a/web-console/src/views/workbench-view/column-tree/column-tree-menu/time-menu-items/time-menu-items.tsx
b/web-console/src/views/workbench-view/column-tree/column-tree-menu/time-menu-items/time-menu-items.tsx
index abfe0f6f26..e9517c0097 100644
---
a/web-console/src/views/workbench-view/column-tree/column-tree-menu/time-menu-items/time-menu-items.tsx
+++
b/web-console/src/views/workbench-view/column-tree/column-tree-menu/time-menu-items/time-menu-items.tsx
@@ -18,7 +18,7 @@
import { MenuDivider, MenuItem } from '@blueprintjs/core';
import { IconNames } from '@blueprintjs/icons';
-import { SqlExpression, SqlFunction, SqlLiteral, SqlQuery, SqlRef } from
'druid-query-toolkit';
+import { C, F, SqlExpression, SqlQuery } from 'druid-query-toolkit';
import React from 'react';
import { prettyPrintSql } from '../../../../../utils';
@@ -42,12 +42,12 @@ const BETWEEN: SqlExpression = SqlExpression.parse(`(? <= ?
AND ? < ?)`);
// ------------------------------------
function fillWithColumn(b: SqlExpression, columnName: string): SqlExpression {
- return b.fillPlaceholders([SqlRef.column(columnName)]);
+ return b.fillPlaceholders([C(columnName)]);
}
function fillWithColumnStartEnd(columnName: string, start: Date, end: Date):
SqlExpression {
- const ref = SqlRef.column(columnName);
- return BETWEEN.fillPlaceholders([SqlLiteral.create(start), ref, ref,
SqlLiteral.create(end)])!;
+ const column = C(columnName);
+ return BETWEEN.fillPlaceholders([start, column, column, end])!;
}
// ------------------------------------
@@ -160,7 +160,7 @@ export const TimeMenuItems = React.memo(function
TimeMenuItems(props: TimeMenuIt
function renderRemoveFilter(): JSX.Element | undefined {
const { columnName, parsedQuery, onQueryChange } = props;
- if (!parsedQuery.getEffectiveWhereExpression().containsColumn(columnName))
return;
+ if
(!parsedQuery.getEffectiveWhereExpression().containsColumnName(columnName))
return;
return (
<MenuItem
@@ -192,7 +192,6 @@ export const TimeMenuItems = React.memo(function
TimeMenuItems(props: TimeMenuIt
function renderGroupByMenu(): JSX.Element | undefined {
const { columnName, parsedQuery, onQueryChange } = props;
if (!parsedQuery.hasGroupBy()) return;
- const ref = SqlRef.column(columnName);
function groupByMenuItem(ex: SqlExpression, alias: string) {
return (
@@ -211,41 +210,18 @@ export const TimeMenuItems = React.memo(function
TimeMenuItems(props: TimeMenuIt
);
}
+ const column = C(columnName);
return (
<MenuItem icon={IconNames.GROUP_OBJECTS} text="Group by">
- {groupByMenuItem(
- SqlFunction.simple('TIME_FLOOR', [ref, SqlLiteral.create('PT1H')]),
- `${columnName}_by_hour`,
- )}
- {groupByMenuItem(
- SqlFunction.simple('TIME_FLOOR', [ref, SqlLiteral.create('P1D')]),
- `${columnName}_by_day`,
- )}
- {groupByMenuItem(
- SqlFunction.simple('TIME_FLOOR', [ref, SqlLiteral.create('P1M')]),
- `${columnName}_by_month`,
- )}
- {groupByMenuItem(
- SqlFunction.simple('TIME_FLOOR', [ref, SqlLiteral.create('P1Y')]),
- `${columnName}_by_year`,
- )}
+ {groupByMenuItem(F.timeFloor(column, 'PT1H'), `${columnName}_by_hour`)}
+ {groupByMenuItem(F.timeFloor(column, 'P1D'), `${columnName}_by_day`)}
+ {groupByMenuItem(F.timeFloor(column, 'P1M'), `${columnName}_by_month`)}
+ {groupByMenuItem(F.timeFloor(column, 'P1Y'), `${columnName}_by_year`)}
<MenuDivider />
- {groupByMenuItem(
- SqlFunction.simple('TIME_EXTRACT', [ref, SqlLiteral.create('HOUR')]),
- `hour_of_${columnName}`,
- )}
- {groupByMenuItem(
- SqlFunction.simple('TIME_EXTRACT', [ref, SqlLiteral.create('DAY')]),
- `day_of_${columnName}`,
- )}
- {groupByMenuItem(
- SqlFunction.simple('TIME_EXTRACT', [ref,
SqlLiteral.create('MONTH')]),
- `month_of_${columnName}`,
- )}
- {groupByMenuItem(
- SqlFunction.simple('TIME_EXTRACT', [ref, SqlLiteral.create('YEAR')]),
- `year_of_${columnName}`,
- )}
+ {groupByMenuItem(F('TIME_EXTRACT', column, 'HOUR'),
`hour_of_${columnName}`)}
+ {groupByMenuItem(F('TIME_EXTRACT', column, 'DAY'),
`day_of_${columnName}`)}
+ {groupByMenuItem(F('TIME_EXTRACT', column, 'MONTH'),
`month_of_${columnName}`)}
+ {groupByMenuItem(F('TIME_EXTRACT', column, 'YEAR'),
`year_of_${columnName}`)}
</MenuItem>
);
}
@@ -253,7 +229,6 @@ export const TimeMenuItems = React.memo(function
TimeMenuItems(props: TimeMenuIt
function renderAggregateMenu(): JSX.Element | undefined {
const { columnName, parsedQuery, onQueryChange } = props;
if (!parsedQuery.hasGroupBy()) return;
- const ref = SqlRef.column(columnName);
function aggregateMenuItem(ex: SqlExpression, alias: string) {
return (
@@ -266,10 +241,11 @@ export const TimeMenuItems = React.memo(function
TimeMenuItems(props: TimeMenuIt
);
}
+ const column = C(columnName);
return (
<MenuItem icon={IconNames.FUNCTION} text="Aggregate">
- {aggregateMenuItem(SqlFunction.simple('MAX', [ref]),
`max_${columnName}`)}
- {aggregateMenuItem(SqlFunction.simple('MIN', [ref]),
`min_${columnName}`)}
+ {aggregateMenuItem(F.max(column), `max_${columnName}`)}
+ {aggregateMenuItem(F.min(column), `min_${columnName}`)}
</MenuItem>
);
}
diff --git a/web-console/src/views/workbench-view/column-tree/column-tree.tsx
b/web-console/src/views/workbench-view/column-tree/column-tree.tsx
index f70439f4f2..3611630d76 100644
--- a/web-console/src/views/workbench-view/column-tree/column-tree.tsx
+++ b/web-console/src/views/workbench-view/column-tree/column-tree.tsx
@@ -20,13 +20,16 @@ import { HTMLSelect, Menu, MenuItem, Position, Tree,
TreeNodeInfo } from '@bluep
import { IconNames } from '@blueprintjs/icons';
import { Popover2 } from '@blueprintjs/popover2';
import {
+ C,
+ F,
+ N,
+ SqlColumn,
SqlComparison,
SqlExpression,
- SqlFunction,
SqlJoinPart,
SqlQuery,
- SqlRef,
- SqlTableRef,
+ SqlTable,
+ T,
} from 'druid-query-toolkit';
import React, { ChangeEvent } from 'react';
@@ -44,12 +47,12 @@ import { NumberMenuItems, StringMenuItems, TimeMenuItems }
from './column-tree-m
import './column-tree.scss';
-const COUNT_STAR = SqlFunction.COUNT_STAR.as('Count');
+const COUNT_STAR = F.count().as('Count');
function getCountExpression(columnNames: string[]): SqlExpression {
for (const columnName of columnNames) {
if (columnName === 'count' || columnName === '__count') {
- return SqlFunction.simple('SUM',
[SqlRef.column(columnName)]).as('Count');
+ return F.sum(C(columnName)).as('Count');
}
}
return COUNT_STAR;
@@ -96,22 +99,22 @@ function handleColumnShow(options:
HandleColumnClickOptions): void {
where = parsedQuery.getWhereExpression();
aggregates = parsedQuery.getAggregateSelectExpressions();
} else if (columnSchema === 'druid') {
- from = SqlTableRef.create(columnTable);
+ from = T(columnTable);
where = defaultWhere;
} else {
- from = SqlTableRef.create(columnTable, columnSchema);
+ from = N(columnSchema).table(columnTable);
}
if (!aggregates.length) {
aggregates.push(COUNT_STAR);
}
- const columnRef = SqlRef.column(columnName);
+ const column = C(columnName);
let query: SqlQuery;
if (columnSchema === 'druid' && columnType === 'TIMESTAMP') {
- query = TIME_QUERY.fillPlaceholders([columnRef, from]) as SqlQuery;
+ query = TIME_QUERY.fillPlaceholders([column, from]) as SqlQuery;
} else {
- query = STRING_QUERY.fillPlaceholders([columnRef, from]) as SqlQuery;
+ query = STRING_QUERY.fillPlaceholders([column, from]) as SqlQuery;
}
let newSelectExpressions = query.selectExpressions;
@@ -152,11 +155,11 @@ export function getJoinColumns(parsedQuery: SqlQuery,
_table: string) {
const firstOnExpression =
parsedQuery.fromClause.joinParts.first().onExpression;
if (firstOnExpression instanceof SqlComparison && firstOnExpression.op ===
'=') {
const { lhs, rhs } = firstOnExpression;
- if (lhs instanceof SqlRef && lhs.getNamespace() === 'lookup') {
- lookupColumn = lhs.getColumn();
+ if (lhs instanceof SqlColumn && lhs.getNamespaceName() === 'lookup') {
+ lookupColumn = lhs.getName();
}
- if (rhs instanceof SqlRef) {
- originalTableColumn = rhs.getColumn();
+ if (rhs instanceof SqlColumn) {
+ originalTableColumn = rhs.getName();
}
}
}
@@ -199,7 +202,7 @@ export class ColumnTree extends
React.PureComponent<ColumnTreeProps, ColumnTreeS
<Deferred
content={() => {
const parsedQuery = props.getParsedQuery();
- const tableRef = SqlTableRef.create(tableName);
+ const tableRef = T(tableName);
const prettyTableRef = prettyPrintSql(tableRef);
const countExpression = getCountExpression(
metadata.map(child => child.COLUMN_NAME),
@@ -207,7 +210,7 @@ export class ColumnTree extends
React.PureComponent<ColumnTreeProps, ColumnTreeS
const getQueryOnTable = () => {
return SqlQuery.create(
- SqlTableRef.create(
+ SqlTable.create(
tableName,
schemaName === 'druid' ? undefined : schemaName,
),
@@ -235,7 +238,7 @@ export class ColumnTree extends
React.PureComponent<ColumnTreeProps, ColumnTreeS
.changeSelectExpressions(
metadata
.map(child => child.COLUMN_NAME)
- .map(columnName =>
SqlRef.column(columnName)),
+ .map(columnName => C(columnName)),
)
.changeWhereExpression(getWhere()),
true,
@@ -297,13 +300,16 @@ export class ColumnTree extends
React.PureComponent<ColumnTreeProps, ColumnTreeS
.addJoin(
SqlJoinPart.create(
'LEFT',
- SqlTableRef.create(tableName,
schemaName),
- SqlRef.column(lookupColumn,
tableName, 'lookup').equal(
- SqlRef.column(
- originalTableColumn,
-
parsedQuery.getFirstTableName(),
+ N(schemaName).table(tableName),
+ N('lookup')
+ .table(tableName)
+ .column(lookupColumn)
+ .equal(
+ SqlColumn.create(
+ originalTableColumn,
+
parsedQuery.getFirstTableName(),
+ ),
),
- ),
),
),
false,
@@ -322,13 +328,16 @@ export class ColumnTree extends
React.PureComponent<ColumnTreeProps, ColumnTreeS
parsedQuery.addJoin(
SqlJoinPart.create(
'INNER',
- SqlTableRef.create(tableName,
schemaName),
- SqlRef.column(lookupColumn,
tableName, 'lookup').equal(
- SqlRef.column(
- originalTableColumn,
- parsedQuery.getFirstTableName(),
+ N(schemaName).table(tableName),
+ N('lookup')
+ .table(tableName)
+ .column(lookupColumn)
+ .equal(
+ SqlColumn.create(
+ originalTableColumn,
+
parsedQuery.getFirstTableName(),
+ ),
),
- ),
),
),
false,
diff --git
a/web-console/src/views/workbench-view/flexible-query-input/flexible-query-input.tsx
b/web-console/src/views/workbench-view/flexible-query-input/flexible-query-input.tsx
index 1559e7981c..7e73f4012d 100644
---
a/web-console/src/views/workbench-view/flexible-query-input/flexible-query-input.tsx
+++
b/web-console/src/views/workbench-view/flexible-query-input/flexible-query-input.tsx
@@ -21,7 +21,7 @@ import { ResizeSensor2 } from '@blueprintjs/popover2';
import type { Ace } from 'ace-builds';
import ace from 'ace-builds';
import classNames from 'classnames';
-import { SqlRef, SqlTableRef } from 'druid-query-toolkit';
+import { C, T } from 'druid-query-toolkit';
import escape from 'lodash.escape';
import React from 'react';
import AceEditor from 'react-ace';
@@ -164,7 +164,7 @@ export class FlexibleQueryInput extends React.PureComponent<
) {
const completions = ([] as any[]).concat(
uniq(columnMetadata.map(d => d.TABLE_SCHEMA)).map(v => ({
- value: SqlTableRef.create(v).toString(),
+ value: String(T(v)),
score: 10,
meta: 'schema',
})),
@@ -173,7 +173,7 @@ export class FlexibleQueryInput extends React.PureComponent<
.filter(d => (currentSchema ? d.TABLE_SCHEMA === currentSchema :
true))
.map(d => d.TABLE_NAME),
).map(v => ({
- value: SqlTableRef.create(v).toString(),
+ value: String(T(v)),
score: 49,
meta: 'datasource',
})),
@@ -186,7 +186,7 @@ export class FlexibleQueryInput extends React.PureComponent<
)
.map(d => d.COLUMN_NAME),
).map(v => ({
- value: SqlRef.column(v).toString(),
+ value: String(C(v)),
score: 50,
meta: 'column',
})),
diff --git
a/web-console/src/views/workbench-view/ingest-success-pane/ingest-success-pane.tsx
b/web-console/src/views/workbench-view/ingest-success-pane/ingest-success-pane.tsx
index 9903529256..11c0d958b9 100644
---
a/web-console/src/views/workbench-view/ingest-success-pane/ingest-success-pane.tsx
+++
b/web-console/src/views/workbench-view/ingest-success-pane/ingest-success-pane.tsx
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-import { SqlTableRef } from 'druid-query-toolkit';
+import { T } from 'druid-query-toolkit';
import React from 'react';
import { Execution, WorkbenchQuery } from '../../../druid-models';
@@ -47,7 +47,7 @@ export const IngestSuccessPane = React.memo(function
IngestSuccessPane(
? stages.getTotalCounterForStage(lastStage, 'input0', 'rows') // Assume
input0 since we know the segmentGenerator will only ever have one stage input
: -1;
- const table = SqlTableRef.create(datasource);
+ const table = T(datasource);
const warnings = stages?.getWarningCount() || 0;
diff --git
a/web-console/src/views/workbench-view/input-format-step/input-format-step.tsx
b/web-console/src/views/workbench-view/input-format-step/input-format-step.tsx
index 0b92ae3ba9..c6fce295dd 100644
---
a/web-console/src/views/workbench-view/input-format-step/input-format-step.tsx
+++
b/web-console/src/views/workbench-view/input-format-step/input-format-step.tsx
@@ -18,7 +18,7 @@
import { Button, Callout, FormGroup, Icon, Intent, Tag } from
'@blueprintjs/core';
import { IconNames } from '@blueprintjs/icons';
-import { SqlExpression, SqlRef } from 'druid-query-toolkit';
+import { C, SqlExpression } from 'druid-query-toolkit';
import React, { useState } from 'react';
import { AutoForm, CenterMessage, LearnMore, Loader } from
'../../../components';
@@ -135,7 +135,7 @@ export const InputFormatStep = React.memo(function
InputFormatStep(props: InputF
return {
column,
- timeExpression: formatSql.fillPlaceholders([SqlRef.column(column)]),
+ timeExpression: formatSql.fillPlaceholders([C(column)]),
};
})[0];
}
diff --git
a/web-console/src/views/workbench-view/recent-query-task-panel/recent-query-task-panel.tsx
b/web-console/src/views/workbench-view/recent-query-task-panel/recent-query-task-panel.tsx
index 5911eb1c50..d4069fd0ed 100644
---
a/web-console/src/views/workbench-view/recent-query-task-panel/recent-query-task-panel.tsx
+++
b/web-console/src/views/workbench-view/recent-query-task-panel/recent-query-task-panel.tsx
@@ -21,7 +21,7 @@ import { IconName, IconNames } from '@blueprintjs/icons';
import { Popover2 } from '@blueprintjs/popover2';
import classNames from 'classnames';
import copy from 'copy-to-clipboard';
-import { SqlTableRef } from 'druid-query-toolkit';
+import { T } from 'druid-query-toolkit';
import React, { useState } from 'react';
import { Loader } from '../../../components';
@@ -182,10 +182,8 @@ LIMIT 100`,
w.datasource !== WorkbenchQuery.INLINE_DATASOURCE_MARKER && (
<MenuItem
icon={IconNames.APPLICATION}
- text={`SELECT * FROM
${SqlTableRef.create(w.datasource)}`}
- onClick={() =>
- onChangeQuery(`SELECT * FROM
${SqlTableRef.create(w.datasource)}`)
- }
+ text={`SELECT * FROM ${T(w.datasource)}`}
+ onClick={() => onChangeQuery(`SELECT * FROM
${T(w.datasource)}`)}
/>
)}
<MenuItem
diff --git
a/web-console/src/views/workbench-view/result-table-pane/result-table-pane.tsx
b/web-console/src/views/workbench-view/result-table-pane/result-table-pane.tsx
index 8dc66584fa..c2b25b40d4 100644
---
a/web-console/src/views/workbench-view/result-table-pane/result-table-pane.tsx
+++
b/web-console/src/views/workbench-view/result-table-pane/result-table-pane.tsx
@@ -21,14 +21,15 @@ import { IconNames } from '@blueprintjs/icons';
import { Popover2 } from '@blueprintjs/popover2';
import classNames from 'classnames';
import {
+ C,
Column,
+ F,
QueryResult,
SqlAlias,
SqlExpression,
SqlFunction,
SqlLiteral,
SqlQuery,
- SqlRef,
SqlStar,
} from 'druid-query-toolkit';
import * as JSONBig from 'json-bigint-native';
@@ -65,10 +66,6 @@ import './result-table-pane.scss';
const CAST_TARGETS: string[] = ['VARCHAR', 'BIGINT', 'DOUBLE'];
-function jsonValue(ex: SqlExpression, path: string): SqlExpression {
- return SqlExpression.parse(`JSON_VALUE(${ex}, ${SqlLiteral.create(path)})`);
-}
-
function getJsonPaths(jsons: Record<string, any>[]): string[] {
return ['$.'].concat(computeFlattenExprsForData(jsons, 'include-arrays',
true));
}
@@ -118,15 +115,15 @@ export const ResultTablePane = React.memo(function
ResultTablePane(props: Result
if (!parsedQuery ||
!parsedQuery.isRealOutputColumnAtSelectIndex(headerIndex)) return false;
return (
- parsedQuery.getEffectiveWhereExpression().containsColumn(header) ||
- parsedQuery.getEffectiveHavingExpression().containsColumn(header)
+ parsedQuery.getEffectiveWhereExpression().containsColumnName(header) ||
+ parsedQuery.getEffectiveHavingExpression().containsColumnName(header)
);
}
function getHeaderMenu(column: Column, headerIndex: number) {
const header = column.name;
const type = column.sqlType || column.nativeType;
- const ref = SqlRef.column(header);
+ const ref = C(header);
const prettyRef = prettyPrintSql(ref);
const menuItems: JSX.Element[] = [];
@@ -136,7 +133,7 @@ export const ResultTablePane = React.memo(function
ResultTablePane(props: Result
const orderByExpression = parsedQuery.isValidSelectIndex(headerIndex)
? SqlLiteral.index(headerIndex)
- : SqlRef.column(header);
+ : ref;
const descOrderBy = orderByExpression.toOrderByExpression('DESC');
const ascOrderBy = orderByExpression.toOrderByExpression('ASC');
const orderBy = parsedQuery.getOrderByForSelectIndex(headerIndex);
@@ -254,7 +251,7 @@ export const ResultTablePane = React.memo(function
ResultTablePane(props: Result
if (!selectExpression) return;
onQueryAction(q =>
q.addSelect(
-
jsonValue(selectExpression.getUnderlyingExpression(), path).as(
+ F('JSON_VALUE',
selectExpression.getUnderlyingExpression(), path).as(
selectExpression.getOutputName() +
path.replace(/^\$/, ''),
),
{ insertIndex: headerIndex + 1 },
@@ -271,7 +268,7 @@ export const ResultTablePane = React.memo(function
ResultTablePane(props: Result
if (parsedQuery.isRealOutputColumnAtSelectIndex(headerIndex)) {
const whereExpression = parsedQuery.getWhereExpression();
- if (whereExpression && whereExpression.containsColumn(header)) {
+ if (whereExpression && whereExpression.containsColumnName(header)) {
menuItems.push(
<MenuItem
key="remove_where"
@@ -287,7 +284,7 @@ export const ResultTablePane = React.memo(function
ResultTablePane(props: Result
}
const havingExpression = parsedQuery.getHavingExpression();
- if (havingExpression && havingExpression.containsColumn(header)) {
+ if (havingExpression && havingExpression.containsColumnName(header)) {
menuItems.push(
<MenuItem
key="remove_having"
@@ -386,31 +383,19 @@ export const ResultTablePane = React.memo(function
ResultTablePane(props: Result
<MenuItem
text="Convert to SUM(...)"
onClick={() => {
- convertToAggregate(
- SqlFunction.simple('SUM',
[underlyingSelectExpression]).as(
- `sum_${header}`,
- ),
- );
+
convertToAggregate(F.sum(underlyingSelectExpression).as(`sum_${header}`));
}}
/>
<MenuItem
text="Convert to MIN(...)"
onClick={() => {
- convertToAggregate(
- SqlFunction.simple('MIN',
[underlyingSelectExpression]).as(
- `min_${header}`,
- ),
- );
+
convertToAggregate(F.min(underlyingSelectExpression).as(`min_${header}`));
}}
/>
<MenuItem
text="Convert to MAX(...)"
onClick={() => {
- convertToAggregate(
- SqlFunction.simple('MAX',
[underlyingSelectExpression]).as(
- `max_${header}`,
- ),
- );
+
convertToAggregate(F.max(underlyingSelectExpression).as(`max_${header}`));
}}
/>
</>
@@ -419,9 +404,7 @@ export const ResultTablePane = React.memo(function
ResultTablePane(props: Result
text="Convert to COUNT(DISTINCT ...)"
onClick={() => {
convertToAggregate(
- SqlFunction.decorated('COUNT', 'DISTINCT',
[underlyingSelectExpression]).as(
- `unique_${header}`,
- ),
+
F.countDistinct(underlyingSelectExpression).as(`unique_${header}`),
);
}}
/>
@@ -429,9 +412,9 @@ export const ResultTablePane = React.memo(function
ResultTablePane(props: Result
text="Convert to APPROX_COUNT_DISTINCT_DS_HLL(...)"
onClick={() => {
convertToAggregate(
- SqlFunction.simple('APPROX_COUNT_DISTINCT_DS_HLL', [
- underlyingSelectExpression,
- ]).as(`unique_${header}`),
+ F('APPROX_COUNT_DISTINCT_DS_HLL',
underlyingSelectExpression).as(
+ `unique_${header}`,
+ ),
);
}}
/>
@@ -439,9 +422,9 @@ export const ResultTablePane = React.memo(function
ResultTablePane(props: Result
text="Convert to APPROX_COUNT_DISTINCT_DS_THETA(...)"
onClick={() => {
convertToAggregate(
- SqlFunction.simple('APPROX_COUNT_DISTINCT_DS_THETA', [
- underlyingSelectExpression,
- ]).as(`unique_${header}`),
+ F('APPROX_COUNT_DISTINCT_DS_THETA',
underlyingSelectExpression).as(
+ `unique_${header}`,
+ ),
);
}}
/>
@@ -496,7 +479,7 @@ export const ResultTablePane = React.memo(function
ResultTablePane(props: Result
);
if (!runeMode) {
- const orderByExpression = SqlRef.column(header);
+ const orderByExpression = ref;
const descOrderBy = orderByExpression.toOrderByExpression('DESC');
const ascOrderBy = orderByExpression.toOrderByExpression('ASC');
const descOrderByPretty = prettyPrintSql(descOrderBy);
diff --git
a/web-console/src/views/workbench-view/time-floor-menu-item/time-floor-menu-item.tsx
b/web-console/src/views/workbench-view/time-floor-menu-item/time-floor-menu-item.tsx
index 44948efbd9..6609889afc 100644
---
a/web-console/src/views/workbench-view/time-floor-menu-item/time-floor-menu-item.tsx
+++
b/web-console/src/views/workbench-view/time-floor-menu-item/time-floor-menu-item.tsx
@@ -18,10 +18,10 @@
import { MenuItem } from '@blueprintjs/core';
import { IconNames } from '@blueprintjs/icons';
-import { SqlExpression, SqlFunction, SqlLiteral } from 'druid-query-toolkit';
+import { F, SqlExpression, SqlFunction } from 'druid-query-toolkit';
import React from 'react';
-import { compact, oneOf, tickIcon } from '../../../utils';
+import { oneOf, tickIcon } from '../../../utils';
const OPTIONS: { label: string; value: string }[] = [
{ label: 'Second', value: 'PT1S' },
@@ -53,16 +53,16 @@ export const TimeFloorMenuItem = function
TimeFloorMenuItem(props: TimeFloorMenu
let innerExpression = expression.getUnderlyingExpression();
let currentDuration: string | undefined;
- let origin: SqlExpression | undefined;
- let timezone: SqlExpression | undefined;
+ let origin: string | undefined;
+ let timezone: string | undefined;
if (
innerExpression instanceof SqlFunction &&
oneOf(innerExpression.getEffectiveFunctionName(), 'TIME_FLOOR', 'FLOOR')
) {
const firstArg = innerExpression.getArg(0);
const secondArg = innerExpression.getArgAsString(1)?.toUpperCase();
- origin = innerExpression.getArg(2);
- timezone = innerExpression.getArg(3);
+ origin = innerExpression.getArgAsString(2);
+ timezone = innerExpression.getArgAsString(3);
if (firstArg && secondArg) {
innerExpression = firstArg;
currentDuration = UNIT_TO_DURATION[secondArg] || secondArg;
@@ -71,13 +71,9 @@ export const TimeFloorMenuItem = function
TimeFloorMenuItem(props: TimeFloorMenu
const changeTimeFloor = (duration: string | undefined) => {
onChange(
- (duration
- ? SqlFunction.simple(
- 'TIME_FLOOR',
- compact([innerExpression, SqlLiteral.create(duration), origin,
timezone]),
- )
- : innerExpression
- ).as(expression.getOutputName()),
+ (duration ? F.timeFloor(innerExpression, duration, origin, timezone) :
innerExpression).as(
+ expression.getOutputName(),
+ ),
);
};
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
