Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

generate different sql code based on dialect (#6915)

Shahmir Varqha21c2a7093483
diff --git a/frontend/src/components/datasources/__tests__/utils.test.ts b/frontend/src/components/datasources/__tests__/utils.test.ts
index 151be1b188..cd96804999 100644
--- a/frontend/src/components/datasources/__tests__/utils.test.ts
+++ b/frontend/src/components/datasources/__tests__/utils.test.ts
@@ -24,154 +24,335 @@ describe("sqlCode", () => {
name: "email" as const,
} as DataTableColumn;
- it("should generate basic SQL without sqlTableContext", () => {
- const result = sqlCode({ table: mockTable, columnName: mockColumn.name });
- expect(result).toBe(
- "_df = mo.sql(f'SELECT \"email\" FROM users LIMIT 100')",
- );
- });
+ describe("basic SQL generation", () => {
+ it("should generate basic SQL without sqlTableContext", () => {
+ const result = sqlCode({ table: mockTable, columnName: mockColumn.name });
+ expect(result).toBe(
+ "_df = mo.sql(f'SELECT \"email\" FROM users LIMIT 100')",
+ );
+ });
- it("should generate SQL with default schema", () => {
- const sqlTableContext: SQLTableContext = {
- engine: DUCKDB_ENGINE,
- schema: "public",
- defaultSchema: "public",
- defaultDatabase: "mydb",
- database: "mydb",
- };
-
- const result = sqlCode({
- table: mockTable,
- columnName: mockColumn.name,
- sqlTableContext,
- });
- expect(result).toBe('_df = mo.sql(f"SELECT email FROM users LIMIT 100")');
- });
+ it("should generate SQL with default schema", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: DUCKDB_ENGINE,
+ schema: "public",
+ defaultSchema: "public",
+ defaultDatabase: "mydb",
+ database: "mydb",
+ dialect: "duckdb",
+ };
- it("should generate SQL with non-default schema", () => {
- const sqlTableContext: SQLTableContext = {
- engine: DUCKDB_ENGINE,
- schema: "analytics",
- defaultSchema: "public",
- defaultDatabase: "mydb",
- database: "mydb",
- };
-
- const result = sqlCode({
- table: mockTable,
- columnName: mockColumn.name,
- sqlTableContext,
- });
- expect(result).toBe(
- '_df = mo.sql(f"SELECT email FROM analytics.users LIMIT 100")',
- );
- });
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM users LIMIT 100\n""")',
+ );
+ });
+
+ it("should generate SQL with non-default schema", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: DUCKDB_ENGINE,
+ schema: "analytics",
+ defaultSchema: "public",
+ defaultDatabase: "mydb",
+ database: "mydb",
+ dialect: "duckdb",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM analytics.users LIMIT 100\n""")',
+ );
+ });
+
+ it("should generate SQL with non-default engine", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: "snowflake",
+ schema: "public",
+ defaultSchema: "public",
+ defaultDatabase: "mydb",
+ database: "mydb",
+ dialect: "snowflake",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM users LIMIT 100\n""", engine=snowflake)',
+ );
+ });
- it("should generate SQL with non-default engine", () => {
- const sqlTableContext: SQLTableContext = {
- engine: "snowflake",
- schema: "public",
- defaultSchema: "public",
- defaultDatabase: "mydb",
- database: "mydb",
- };
-
- const result = sqlCode({
- table: mockTable,
- columnName: mockColumn.name,
- sqlTableContext,
- });
- expect(result).toBe(
- '_df = mo.sql(f"SELECT email FROM users LIMIT 100", engine=snowflake)',
- );
+ it("should generate SQL with non-default database", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: DUCKDB_ENGINE,
+ schema: "public",
+ defaultSchema: "public",
+ defaultDatabase: "memory",
+ database: "remote",
+ dialect: "duckdb",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM remote.users LIMIT 100\n""")',
+ );
+ });
+
+ it("should generate SQL for schemaless tables", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: DUCKDB_ENGINE,
+ schema: "",
+ defaultDatabase: "mydb",
+ database: "mydb",
+ dialect: "duckdb",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM users LIMIT 100\n""")',
+ );
+
+ const sqlTableContext2: SQLTableContext = {
+ engine: DUCKDB_ENGINE,
+ schema: "",
+ defaultDatabase: "remote",
+ database: "another_db",
+ dialect: "duckdb",
+ };
+
+ const result2 = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext: sqlTableContext2,
+ });
+ expect(result2).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM another_db.users LIMIT 100\n""")',
+ );
+ });
});
- it("should generate SQL with non-default schema and non-default engine", () => {
- const sqlTableContext: SQLTableContext = {
- engine: "bigquery",
- schema: "sales",
- defaultSchema: "public",
- defaultDatabase: "mydb",
- database: "mydb",
- };
-
- const result = sqlCode({
- table: mockTable,
- columnName: mockColumn.name,
- sqlTableContext,
- });
- expect(result).toBe(
- '_df = mo.sql(f"SELECT email FROM sales.users LIMIT 100", engine=bigquery)',
- );
+ describe("BigQuery dialect", () => {
+ it("should use backticks for table names", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: "bigquery",
+ schema: "public",
+ defaultSchema: "public",
+ defaultDatabase: "mydb",
+ database: "mydb",
+ dialect: "bigquery",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM `users` LIMIT 100\n""", engine=bigquery)',
+ );
+ });
+
+ it("should use backticks for database.schema.table", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: "bigquery",
+ schema: "sales",
+ defaultSchema: "public",
+ defaultDatabase: "mydb",
+ database: "remote",
+ dialect: "bigquery",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM `remote.sales.users` LIMIT 100\n""", engine=bigquery)',
+ );
+ });
+
+ it("should handle case-insensitive dialect name", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: "bigquery",
+ schema: "public",
+ defaultSchema: "public",
+ defaultDatabase: "mydb",
+ database: "mydb",
+ dialect: "BigQuery",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM `users` LIMIT 100\n""", engine=bigquery)',
+ );
+ });
});
- it("should generate SQL with non-default database", () => {
- const sqlTableContext: SQLTableContext = {
- engine: DUCKDB_ENGINE,
- schema: "public",
- defaultSchema: "public",
- defaultDatabase: "memory",
- database: "remote",
- };
-
- const result = sqlCode({
- table: mockTable,
- columnName: mockColumn.name,
- sqlTableContext,
- });
- expect(result).toBe(
- '_df = mo.sql(f"SELECT email FROM remote.users LIMIT 100")',
- );
+ describe("MSSQL dialect", () => {
+ it("should use TOP 100 instead of LIMIT", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: "mssql",
+ schema: "dbo",
+ defaultSchema: "dbo",
+ defaultDatabase: "master",
+ database: "master",
+ dialect: "mssql",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT TOP 100 email FROM users\n""", engine=mssql)',
+ );
+ });
+
+ it("should use TOP 100 with database and schema prefix", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: "mssql",
+ schema: "sales",
+ defaultSchema: "dbo",
+ defaultDatabase: "master",
+ database: "analytics",
+ dialect: "mssql",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT TOP 100 email FROM analytics.sales.users\n""", engine=mssql)',
+ );
+ });
});
- it("should generate SQL with non-default database and non-default schema", () => {
- const sqlTableContext: SQLTableContext = {
- engine: "bigquery",
- schema: "sales",
- defaultSchema: "public",
- defaultDatabase: "mydb",
- database: "remote",
- };
-
- const result = sqlCode({
- table: mockTable,
- columnName: mockColumn.name,
- sqlTableContext,
- });
- expect(result).toBe(
- '_df = mo.sql(f"SELECT email FROM remote.sales.users LIMIT 100", engine=bigquery)',
- );
+ describe("TimescaleDB dialect", () => {
+ it("should wrap table name with double quotes", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: "timescaledb",
+ schema: "public",
+ defaultSchema: "public",
+ defaultDatabase: "mydb",
+ database: "mydb",
+ dialect: "timescaledb",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM "users" LIMIT 100\n""", engine=timescaledb)',
+ );
+ });
+
+ it("should wrap database, schema, and table name with double quotes", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: "timescaledb",
+ schema: "sales",
+ defaultSchema: "public",
+ defaultDatabase: "mydb",
+ database: "remote",
+ dialect: "timescaledb",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM "remote"."sales"."users" LIMIT 100\n""", engine=timescaledb)',
+ );
+ });
+
+ it("should handle schemaless database with double quotes", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: "timescaledb",
+ schema: "",
+ defaultDatabase: "mydb",
+ database: "remote",
+ dialect: "timescaledb",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM "remote"."users" LIMIT 100\n""", engine=timescaledb)',
+ );
+ });
});
- it("should generate SQL for schemaless tables", () => {
- const sqlTableContext: SQLTableContext = {
- engine: DUCKDB_ENGINE,
- schema: "",
- defaultDatabase: "mydb",
- database: "mydb",
- };
-
- const result = sqlCode({
- table: mockTable,
- columnName: mockColumn.name,
- sqlTableContext,
- });
- expect(result).toBe('_df = mo.sql(f"SELECT email FROM users LIMIT 100")');
-
- const sqlTableContext2: SQLTableContext = {
- engine: DUCKDB_ENGINE,
- schema: "",
- defaultDatabase: "remote",
- database: "another_db",
- };
-
- const result2 = sqlCode({
- table: mockTable,
- columnName: mockColumn.name,
- sqlTableContext: sqlTableContext2,
- });
- expect(result2).toBe(
- '_df = mo.sql(f"SELECT email FROM another_db.users LIMIT 100")',
- );
+ describe("fallback behavior", () => {
+ it("should use default formatter for unknown dialect", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: "postgres",
+ schema: "public",
+ defaultSchema: "public",
+ defaultDatabase: "mydb",
+ database: "mydb",
+ dialect: "unknown_dialect",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM users LIMIT 100\n""", engine=postgres)',
+ );
+ });
+
+ it("should use default formatter when dialect is not provided", () => {
+ const sqlTableContext: SQLTableContext = {
+ engine: "postgres",
+ schema: "public",
+ defaultSchema: "public",
+ defaultDatabase: "mydb",
+ database: "mydb",
+ dialect: "",
+ };
+
+ const result = sqlCode({
+ table: mockTable,
+ columnName: mockColumn.name,
+ sqlTableContext,
+ });
+ expect(result).toBe(
+ '_df = mo.sql(f"""\nSELECT email FROM users LIMIT 100\n""", engine=postgres)',
+ );
+ });
});
});
diff --git a/frontend/src/components/datasources/datasources.tsx b/frontend/src/components/datasources/datasources.tsx
index f0a8dd6afc..2e3ea2ac89 100644
--- a/frontend/src/components/datasources/datasources.tsx
+++ b/frontend/src/components/datasources/datasources.tsx
@@ -214,6 +214,7 @@ export const DataSources: React.FC = () => {
databaseName={database.name}
hasSearch={hasSearch}
searchValue={searchValue}
+ dialect={connection.dialect}
/>
</DatabaseItem>
))}
@@ -340,6 +341,7 @@ const SchemaList: React.FC<{
schemas: DatabaseSchema[];
defaultSchema?: string | null;
defaultDatabase?: string | null;
+ dialect: string;
engineName: string;
databaseName: string;
hasSearch: boolean;
@@ -348,6 +350,7 @@ const SchemaList: React.FC<{
schemas,
defaultSchema,
defaultDatabase,
+ dialect,
engineName,
databaseName,
hasSearch,
@@ -384,6 +387,7 @@ const SchemaList: React.FC<{
schema: schema.name,
defaultSchema: defaultSchema,
defaultDatabase: defaultDatabase,
+ dialect: dialect,
}}
/>
</SchemaItem>
diff --git a/frontend/src/components/datasources/utils.ts b/frontend/src/components/datasources/utils.ts
index 0be4cdfd56..8667868594 100644
--- a/frontend/src/components/datasources/utils.ts
+++ b/frontend/src/components/datasources/utils.ts
@@ -1,7 +1,11 @@
/* Copyright 2024 Marimo. All rights reserved. */
+
+import { BigQueryDialect } from "@marimo-team/codemirror-sql/dialects";
+import { isKnownDialect } from "@/core/codemirror/language/languages/sql/utils";
import type { SQLTableContext } from "@/core/datasets/data-source-connections";
import { DUCKDB_ENGINE } from "@/core/datasets/engines";
import type { DataTable, DataType } from "@/core/kernel/messages";
+import { logNever } from "@/utils/assertNever";
import type { ColumnHeaderStatsKey } from "../data-table/types";
// Some databases have no schemas, so we don't show it (eg. Clickhouse)
@@ -9,6 +13,78 @@ export function isSchemaless(schemaName: string) {
return schemaName === "";
}
+interface SqlCodeFormatter {
+ /**
+ * Format the table name based on dialect-specific rules
+ */
+ formatTableName: (tableName: string) => string;
+ /**
+ * Format the SELECT clause
+ */
+ formatSelectClause: (columnName: string, tableName: string) => string;
+}
+
+const defaultFormatter: SqlCodeFormatter = {
+ formatTableName: (tableName: string) => tableName,
+ formatSelectClause: (columnName: string, tableName: string) =>
+ `SELECT ${columnName} FROM ${tableName} LIMIT 100`,
+};
+
+function getFormatter(dialect: string): SqlCodeFormatter {
+ dialect = dialect.toLowerCase();
+ if (!isKnownDialect(dialect)) {
+ return defaultFormatter;
+ }
+
+ switch (dialect) {
+ case "bigquery": {
+ const quote = BigQueryDialect.spec.identifierQuotes;
+ return {
+ // BigQuery uses backticks for identifiers
+ formatTableName: (tableName: string) => `${quote}${tableName}${quote}`,
+ formatSelectClause: defaultFormatter.formatSelectClause,
+ };
+ }
+ case "mssql":
+ case "sqlserver":
+ return {
+ formatTableName: defaultFormatter.formatTableName,
+ formatSelectClause: (columnName: string, tableName: string) =>
+ `SELECT TOP 100 ${columnName} FROM ${tableName}`,
+ };
+ case "timescaledb":
+ return {
+ // TimescaleDB uses double quotes for identifiers
+ formatTableName: (tableName: string) => {
+ const parts = tableName.split(".");
+ return parts.map((part) => `"${part}"`).join(".");
+ },
+ formatSelectClause: defaultFormatter.formatSelectClause,
+ };
+ case "postgresql":
+ case "postgres":
+ case "db2":
+ case "mysql":
+ case "sqlite":
+ case "duckdb":
+ case "mariadb":
+ case "cassandra":
+ case "noql":
+ case "athena":
+ case "hive":
+ case "redshift":
+ case "snowflake":
+ case "flink":
+ case "mongodb":
+ case "oracle":
+ case "oracledb":
+ return defaultFormatter;
+ default:
+ logNever(dialect);
+ return defaultFormatter;
+ }
+}
+
export function sqlCode({
table,
columnName,
@@ -19,8 +95,14 @@ export function sqlCode({
sqlTableContext?: SQLTableContext;
}) {
if (sqlTableContext) {
- const { engine, schema, defaultSchema, defaultDatabase, database } =
- sqlTableContext;
+ const {
+ engine,
+ schema,
+ defaultSchema,
+ defaultDatabase,
+ database,
+ dialect,
+ } = sqlTableContext;
let tableName = table.name;
// Set the fully qualified table name based on schema and database
@@ -39,11 +121,18 @@ export function sqlCode({
}
}
+ const formatter = getFormatter(dialect);
+ const formattedTableName = formatter.formatTableName(tableName);
+ const selectClause = formatter.formatSelectClause(
+ columnName,
+ formattedTableName,
+ );
+
if (engine === DUCKDB_ENGINE) {
- return `_df = mo.sql(f"SELECT ${columnName} FROM ${tableName} LIMIT 100")`;
+ return `_df = mo.sql(f"""\n${selectClause}\n""")`;
}
- return `_df = mo.sql(f"SELECT ${columnName} FROM ${tableName} LIMIT 100", engine=${engine})`;
+ return `_df = mo.sql(f"""\n${selectClause}\n""", engine=${engine})`;
}
return `_df = mo.sql(f'SELECT "${columnName}" FROM ${table.name} LIMIT 100')`;
diff --git a/frontend/src/core/codemirror/language/languages/sql/completion-store.ts b/frontend/src/core/codemirror/language/languages/sql/completion-store.ts
index 5aed29b6c4..b0a81122be 100644
--- a/frontend/src/core/codemirror/language/languages/sql/completion-store.ts
+++ b/frontend/src/core/codemirror/language/languages/sql/completion-store.ts
@@ -134,7 +134,7 @@ class SQLCompletionStore {
if (!connection) {
return ModifiedStandardSQL;
}
- return guessDialect(connection) ?? ModifiedStandardSQL;
+ return guessDialect(connection);
}
getCompletionSource(connectionName: ConnectionName): SQLConfig | null {
@@ -152,7 +152,7 @@ class SQLCompletionStore {
const schema = this.cache.getOrCreate(connection);
return {
- dialect: guessDialect(connection) ?? ModifiedStandardSQL,
+ dialect: guessDialect(connection),
schema: schema.shouldAddLocalTables
? { ...schema.schema, ...getTablesMap() }
: schema.schema,
diff --git a/frontend/src/core/codemirror/language/languages/sql/sql.ts b/frontend/src/core/codemirror/language/languages/sql/sql.ts
index 6ce36cdc86..a9b4e88e0e 100644
--- a/frontend/src/core/codemirror/language/languages/sql/sql.ts
+++ b/frontend/src/core/codemirror/language/languages/sql/sql.ts
@@ -38,6 +38,7 @@ import type { HotkeyProvider } from "@/core/hotkeys/hotkeys";
import type { ValidateSQLResult } from "@/core/kernel/messages";
import { store } from "@/core/state/jotai";
import { resolvedThemeAtom } from "@/theme/useTheme";
+import { logNever } from "@/utils/assertNever";
import { Logger } from "@/utils/Logger";
import { variableCompletionSource } from "../../embedded/embedded-python";
import { languageMetadataField } from "../../metadata";
@@ -52,6 +53,7 @@ import {
} from "./completion-sources";
import { SCHEMA_CACHE } from "./completion-store";
import { getSQLMode, type SQLMode } from "./sql-mode";
+import { isKnownDialect } from "./utils";
const DEFAULT_DIALECT = DuckDBDialect;
const DEFAULT_PARSER_DIALECT = "DuckDB";
@@ -353,6 +355,11 @@ function connectionNameToParserDialect(
): ParserDialects | null {
const dialect =
SCHEMA_CACHE.getInternalDialect(connectionName)?.toLowerCase();
+
+ if (!dialect || !isKnownDialect(dialect)) {
+ return null;
+ }
+
switch (dialect) {
case "postgresql":
case "postgres":
@@ -385,8 +392,15 @@ function connectionNameToParserDialect(
case "flink":
return "FlinkSQL";
case "mongodb":
+ case "noql":
return "Noql";
+ case "oracle":
+ case "oracledb":
+ case "timescaledb":
+ Logger.debug("Unsupported dialect", { dialect });
+ return null;
default:
+ logNever(dialect);
return null;
}
}
diff --git a/frontend/src/core/codemirror/language/languages/sql/utils.ts b/frontend/src/core/codemirror/language/languages/sql/utils.ts
index 80143e69f9..5ebf3ff40e 100644
--- a/frontend/src/core/codemirror/language/languages/sql/utils.ts
+++ b/frontend/src/core/codemirror/language/languages/sql/utils.ts
@@ -17,14 +17,52 @@ import {
DuckDBDialect,
} from "@marimo-team/codemirror-sql/dialects";
import type { DataSourceConnection } from "@/core/kernel/messages";
+import { logNever } from "@/utils/assertNever";
+import { Logger } from "@/utils/Logger";
+
+const KNOWN_DIALECTS_ARRAY = [
+ "postgresql",
+ "postgres",
+ "db2",
+ "mysql",
+ "sqlite",
+ "mssql",
+ "sqlserver",
+ "duckdb",
+ "mariadb",
+ "cassandra",
+ "noql",
+ "athena",
+ "bigquery",
+ "hive",
+ "redshift",
+ "snowflake",
+ "flink",
+ "mongodb",
+ "oracle",
+ "oracledb",
+ "timescaledb",
+] as const;
+const KNOWN_DIALECTS: ReadonlySet<string> = new Set(KNOWN_DIALECTS_ARRAY);
+type KnownDialect = (typeof KNOWN_DIALECTS_ARRAY)[number];
+
+export function isKnownDialect(dialect: string): dialect is KnownDialect {
+ return KNOWN_DIALECTS.has(dialect);
+}
/**
* Guess the CodeMirror SQL dialect from the backend connection dialect.
+ * If unknown, return the standard SQL dialect.
*/
export function guessDialect(
connection: Pick<DataSourceConnection, "dialect">,
-): SQLDialect | undefined {
- switch (connection.dialect) {
+): SQLDialect {
+ const dialect = connection.dialect;
+ if (!isKnownDialect(dialect)) {
+ return ModifiedStandardSQL;
+ }
+
+ switch (dialect) {
case "postgresql":
case "postgres":
return PostgreSQL;
@@ -46,8 +84,21 @@ export function guessDialect(
return PLSQL;
case "bigquery":
return BigQueryDialect;
+ case "timescaledb":
+ return PostgreSQL; // TimescaleDB is a PostgreSQL dialect
+ case "athena":
+ case "db2":
+ case "hive":
+ case "redshift":
+ case "snowflake":
+ case "flink":
+ case "mongodb":
+ case "noql":
+ Logger.debug("Unsupported dialect", { dialect });
+ return ModifiedStandardSQL;
default:
- return undefined;
+ logNever(dialect);
+ return ModifiedStandardSQL;
}
}
diff --git a/frontend/src/core/datasets/__tests__/data-source.test.ts b/frontend/src/core/datasets/__tests__/data-source.test.ts
index 9c2cfec2ef..419ce7d268 100644
--- a/frontend/src/core/datasets/__tests__/data-source.test.ts
+++ b/frontend/src/core/datasets/__tests__/data-source.test.ts
@@ -270,6 +270,7 @@ describe("add table list", () => {
engine: "conn1" as ConnectionName,
database: "db1",
schema: "public",
+ dialect: "sqlite",
});
const conn1 = newState.connectionsMap.get("conn1" as ConnectionName);
@@ -283,6 +284,7 @@ describe("add table list", () => {
engine: "conn1" as ConnectionName,
database: "db1",
schema: "public",
+ dialect: "sqlite",
};
const tableList: DataTable[] = [
@@ -344,6 +346,7 @@ describe("add table list", () => {
engine: "conn1" as ConnectionName,
database: "db1",
schema: "non_existent",
+ dialect: "sqlite",
});
const conn1 = newState.connectionsMap.get("conn1" as ConnectionName);
@@ -407,6 +410,7 @@ describe("add table", () => {
engine: "conn1" as ConnectionName,
database: "db1",
schema: "public",
+ dialect: "sqlite",
});
const conn1 = newState.connectionsMap.get("conn1" as ConnectionName);
@@ -420,6 +424,7 @@ describe("add table", () => {
engine: "conn1" as ConnectionName,
database: "db1",
schema: "public",
+ dialect: "sqlite",
};
const table: DataTable = {
@@ -476,6 +481,7 @@ describe("add table", () => {
engine: "conn1" as ConnectionName,
database: "db1",
schema: "non_existent",
+ dialect: "sqlite",
});
const conn1 = newState.connectionsMap.get("conn1" as ConnectionName);
diff --git a/frontend/src/core/datasets/data-source-connections.ts b/frontend/src/core/datasets/data-source-connections.ts
index 0c3837b3d9..6116b4639e 100644
--- a/frontend/src/core/datasets/data-source-connections.ts
+++ b/frontend/src/core/datasets/data-source-connections.ts
@@ -47,6 +47,7 @@ export interface SQLTableContext {
engine: string;
database: string;
schema: string;
+ dialect: string;
defaultSchema?: string | null;
defaultDatabase?: string | null;
}