@marimo-team/frontend 0.14.18-dev23 → 0.14.18-dev25

package/src/core/codemirror/language/languages/markdown.ts

@@ -0,0 +1,261 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+
+import { autocompletion } from "@codemirror/autocomplete";
+import { markdown, markdownLanguage } from "@codemirror/lang-markdown";
+import { python, pythonLanguage } from "@codemirror/lang-python";
+import { StreamLanguage } from "@codemirror/language";
+import { languages } from "@codemirror/language-data";
+import { stexMath } from "@codemirror/legacy-modes/mode/stex";
+import type { Extension } from "@codemirror/state";
+import { type EditorView, ViewPlugin } from "@codemirror/view";
+import dedent from "string-dedent";
+import type { CellId } from "@/core/cells/ids";
+import type { CompletionConfig } from "@/core/config/config-schema";
+import type { HotkeyProvider } from "@/core/hotkeys/hotkeys";
+import { markdownAutoRunExtension } from "../../cells/extensions";
+import { pythonCompletionSource } from "../../completion/completer";
+import { conditionalCompletion } from "../../completion/utils";
+import type { PlaceholderType } from "../../config/types";
+import { markdownCompletionSources } from "../../markdown/completions";
+import { enhancedMarkdownExtension } from "../../markdown/extension";
+import { parsePython } from "../embedded/embedded-python";
+import { parseLatex } from "../embedded/latex";
+import { languageMetadataField } from "../metadata";
+import type { LanguageAdapter } from "../types";
+import {
+  QUOTE_PREFIX_KINDS,
+  type QuotePrefixKind,
+  splitQuotePrefix,
+} from "../utils/quotes";
+
+export interface MarkdownLanguageAdapterMetadata {
+  quotePrefix: QuotePrefixKind;
+}
+
+const quoteKinds = [
+  ['"""', '"""'],
+  ["'''", "'''"],
+  ['"', '"'],
+  ["'", "'"],
+];
+
+// explode into all combinations
+const pairs = QUOTE_PREFIX_KINDS.flatMap((prefix) =>
+  quoteKinds.map(([start, end]) => [prefix + start, end]),
+);
+
+const regexes = pairs.map(
+  ([start, end]) =>
+    // mo.md( + any number of spaces + start + capture + any number of spaces + end)
+    [
+      start,
+      new RegExp(`^mo\\.md\\(\\s*${start}(.*)${end}\\s*\\)$`, "s"),
+    ] as const,
+);
+
+/**
+ * Language adapter for Markdown.
+ */
+export class MarkdownLanguageAdapter
+  implements LanguageAdapter<MarkdownLanguageAdapterMetadata>
+{
+  readonly type = "markdown";
+  readonly defaultCode = 'mo.md(r"""\n""")';
+  readonly defaultMetadata: MarkdownLanguageAdapterMetadata = {
+    quotePrefix: "r",
+  };
+
+  static fromMarkdown(markdown: string) {
+    return `mo.md(r"""\n${markdown}\n""")`;
+  }
+
+  transformIn(
+    pythonCode: string,
+  ): [string, number, MarkdownLanguageAdapterMetadata] {
+    pythonCode = pythonCode.trim();
+
+    const metadata = { ...this.defaultMetadata };
+
+    // empty string
+    if (pythonCode === "") {
+      return ["", 0, metadata];
+    }
+
+    for (const [start, regex] of regexes) {
+      const match = pythonCode.match(regex);
+      if (match) {
+        const innerCode = match[1];
+        const [quotePrefix, quoteType] = splitQuotePrefix(start);
+        metadata.quotePrefix = quotePrefix;
+        const unescapedCode = innerCode.replaceAll(`\\${quoteType}`, quoteType);
+
+        const offset = pythonCode.indexOf(innerCode);
+        // string-dedent expects the first and last line to be empty / contain only whitespace, so we pad with \n
+        return [dedent(`\n${unescapedCode}\n`).trim(), offset, metadata];
+      }
+    }
+
+    // no match
+    return [pythonCode, 0, metadata];
+  }
+
+  transformOut(
+    code: string,
+    metadata: MarkdownLanguageAdapterMetadata,
+  ): [string, number] {
+    // Empty string
+    if (code === "") {
+      // Need at least a space, otherwise the output will be 6 quotes
+      code = " ";
+    }
+
+    const { quotePrefix } = metadata;
+
+    // We always transform back with triple quotes, as to avoid needing to
+    // escape single quotes.
+    const escapedCode = code.replaceAll('"""', String.raw`\"""`);
+
+    // If its one line and not bounded by quotes, write it as single line
+    const isOneLine = !code.includes("\n");
+    const boundedByQuote = code.startsWith('"') || code.endsWith('"');
+    if (isOneLine && !boundedByQuote) {
+      const start = `mo.md(${quotePrefix}"""`;
+      const end = `""")`;
+      return [start + escapedCode + end, start.length];
+    }
+
+    // Multiline code
+    const start = `mo.md(\n    ${quotePrefix}"""\n`;
+    const end = `\n"""\n)`;
+    return [start + escapedCode + end, start.length + 1];
+  }
+
+  isSupported(pythonCode: string): boolean {
+    pythonCode = pythonCode.trim();
+
+    // Empty strings are supported
+    if (pythonCode === "") {
+      return true;
+    }
+
+    // Must start with mo.md(
+    if (!pythonCode.startsWith("mo.md(")) {
+      return false;
+    }
+
+    // Empty function calls are supported
+    if (pythonCode === "mo.md()") {
+      return true;
+    }
+
+    // Parse the code using Lezer and check for the exact match of mo.md() signature
+    const tree = pythonLanguage.parser.parse(pythonCode);
+
+    // This is the exact match of mo.md() signature
+    const enterOrder: Array<{ match: string | RegExp; stop?: boolean }> = [
+      { match: "Script" },
+      { match: "ExpressionStatement" },
+      { match: "CallExpression" },
+      { match: "MemberExpression" },
+      { match: "VariableName" },
+      { match: "." },
+      { match: "PropertyName" },
+      { match: "ArgList" },
+      { match: "(" },
+      { match: /String|FormatString/, stop: true },
+      { match: ")" },
+    ];
+
+    let isValid = true;
+
+    // Parse the code using Lezer to check for multiple function calls and string content
+    tree.iterate({
+      enter: (node) => {
+        const current = enterOrder.shift();
+        if (current === undefined) {
+          // If our list is empty, but we are still going
+          // then this is not a valid call
+          isValid = false;
+          return false;
+        }
+
+        const match = current.match;
+
+        if (typeof match === "string") {
+          isValid = isValid && match === node.name;
+          return isValid && !current.stop;
+        }
+
+        if (!match.test(node.name)) {
+          isValid = false;
+          return isValid && !current.stop;
+        }
+
+        return isValid && !current.stop;
+      },
+    });
+
+    return isValid;
+  }
+
+  getExtension(
+    _cellId: CellId,
+    _completionConfig: CompletionConfig,
+    hotkeys: HotkeyProvider,
+    _: PlaceholderType,
+  ): Extension[] {
+    const markdownLanguageData = markdown().language.data;
+    let view: EditorView | undefined;
+
+    // Only activate completions for f-strings
+    const isFStringActive = () => {
+      if (!view) {
+        return true;
+      }
+
+      const metadata = view?.state.field(languageMetadataField);
+      if (metadata === undefined) {
+        return false;
+      }
+      return metadata.quotePrefix?.includes("f") ?? false;
+    };
+
+    return [
+      ViewPlugin.define((_view) => {
+        view = _view;
+        return {};
+      }),
+      markdown({
+        base: markdownLanguage,
+        codeLanguages: languages,
+        extensions: [
+          // Embedded LateX in Markdown
+          parseLatex(StreamLanguage.define(stexMath).parser),
+          // Embedded Python in Markdown
+          parsePython(pythonLanguage.parser, isFStringActive),
+        ],
+      }),
+      enhancedMarkdownExtension(hotkeys),
+      // Completions for markdown
+      markdownCompletionSources.map((source) =>
+        markdownLanguageData.of({ autocomplete: source }),
+      ),
+      // Completions for embedded Python
+      python().language.data.of({
+        autocomplete: conditionalCompletion({
+          completion: pythonCompletionSource,
+          predicate: isFStringActive,
+        }),
+      }),
+
+      autocompletion({
+        // We remove the default keymap because we use our own which
+        // handles the Escape key correctly in Vim
+        defaultKeymap: false,
+        activateOnTyping: true,
+      }),
+      // Markdown autorun
+      markdownAutoRunExtension({ predicate: () => !isFStringActive() }),
+    ];
+  }
+}

package/src/core/codemirror/language/languages/python.ts

@@ -0,0 +1,329 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+
+import { autocompletion } from "@codemirror/autocomplete";
+import {
+  globalCompletion,
+  localCompletionSource,
+  pythonLanguage,
+} from "@codemirror/lang-python";
+import {
+  foldInside,
+  foldNodeProp,
+  LanguageSupport,
+} from "@codemirror/language";
+import { type Extension, Prec } from "@codemirror/state";
+import {
+  documentUri,
+  LanguageServerClient,
+  languageServerWithClient,
+} from "@marimo-team/codemirror-languageserver";
+import type { CellId } from "@/core/cells/ids";
+import { hasCapability } from "@/core/config/capabilities";
+import type {
+  CompletionConfig,
+  DiagnosticsConfig,
+  LSPConfig,
+} from "@/core/config/config-schema";
+import type { HotkeyProvider } from "@/core/hotkeys/hotkeys";
+import { getRequestClient } from "@/core/network/requests";
+import { Logger } from "@/utils/Logger";
+import { once } from "@/utils/once";
+import { cellActionsState } from "../../cells/state";
+import { pythonCompletionSource } from "../../completion/completer";
+import type { PlaceholderType } from "../../config/types";
+import { FederatedLanguageServerClient } from "../../lsp/federated-lsp";
+import { NotebookLanguageServerClient } from "../../lsp/notebook-lsp";
+import { createTransport } from "../../lsp/transports";
+import { CellDocumentUri, type ILanguageServerClient } from "../../lsp/types";
+import { getLSPDocumentRootUri } from "../../lsp/utils";
+import {
+  clickablePlaceholderExtension,
+  smartPlaceholderExtension,
+} from "../../placeholder/extensions";
+import type { LanguageAdapter } from "../types";
+
+const pylspClient = once((lspConfig: LSPConfig) => {
+  const lspClientOpts = {
+    transport: createTransport("pylsp"),
+    rootUri: getLSPDocumentRootUri(),
+    workspaceFolders: [],
+  };
+  const config = lspConfig?.pylsp;
+
+  const ignoredStyleRules = [
+    // Notebooks are not really public modules and are better documented
+    // by having a markdown cell with explanations instead
+    "D100", // Missing docstring in public module
+    "D103", // Missing docstring in public function
+  ];
+  const ignoredFlakeRules = [
+    // The final cell in the notebook is not required to have a new line
+    "W292", // No newline at end of file
+    // Modules can be imported in any cell
+    "E402", // Module level import not at top of file
+  ];
+  const ignoredRuffRules = [
+    // Even ruff documentation of this rule explains it is not useful in notebooks
+    "B018", // Useless expression
+    // isort
+    "I001", // Import block is un-sorted or un-formatted
+  ];
+  const settings = {
+    pylsp: {
+      plugins: {
+        marimo_plugin: {
+          enabled: true,
+        },
+        jedi: {
+          // Modules which should be imported and use compile-time, rather
+          // than static analysis; this is a trade-off between being able
+          // to access more information set on runtime (e.g. via setattr)
+          // vs being able to read the information from the source code
+          // (e.g. comments with documentation for attributes).
+          auto_import_modules: ["numpy"],
+        },
+        jedi_completion: {
+          // Ensure that parameters are included for completion snippets.
+          include_params: true,
+          // Include snippets and signatures it at most 50 suggestions.
+          resolve_at_most: 50,
+        },
+        flake8: {
+          enabled: config?.enable_flake8,
+          extendIgnore: ignoredFlakeRules,
+        },
+        pydocstyle: {
+          enabled: config?.enable_pydocstyle,
+          // not `addIgnore`, see https://github.com/python-lsp/python-lsp-server/issues/626
+          ignore: ignoredStyleRules,
+        },
+        pylint: {
+          enabled: config?.enable_pylint,
+        },
+        pyflakes: {
+          enabled: config?.enable_pyflakes,
+        },
+        pylsp_mypy: {
+          enabled: config?.enable_mypy,
+          live_mode: true,
+        },
+        ruff: {
+          enabled: config?.enable_ruff,
+          extendIgnore: [
+            ...ignoredFlakeRules,
+            ...ignoredStyleRules,
+            ...ignoredRuffRules,
+          ],
+        },
+        signature: {
+          formatter: config?.enable_ruff ? "ruff" : "black",
+          line_length: 88,
+        },
+      },
+    },
+  };
+
+  // We wrap the client in a NotebookLanguageServerClient to add some
+  // additional functionality to handle multiple cells
+  return new NotebookLanguageServerClient(
+    new LanguageServerClient({
+      ...lspClientOpts,
+      autoClose: false,
+    }),
+    settings,
+  );
+});
+
+const tyLspClient = once((_: LSPConfig) => {
+  const lspClientOpts = {
+    transport: createTransport("ty"),
+    rootUri: getLSPDocumentRootUri(),
+    workspaceFolders: [],
+  };
+
+  // We wrap the client in a NotebookLanguageServerClient to add some
+  // additional functionality to handle multiple cells
+  return new NotebookLanguageServerClient(
+    new LanguageServerClient({
+      ...lspClientOpts,
+      autoClose: false,
+      getWorkspaceConfiguration: (_) => [{ disableLanguageServices: true }],
+    }),
+    {},
+  );
+});
+
+const pyrightClient = once((_: LSPConfig) => {
+  const lspClientOpts = {
+    transport: createTransport("basedpyright"),
+    rootUri: getLSPDocumentRootUri(),
+    workspaceFolders: [],
+  };
+
+  // We wrap the client in a NotebookLanguageServerClient to add some
+  // additional functionality to handle multiple cells
+  return new NotebookLanguageServerClient(
+    new LanguageServerClient({
+      ...lspClientOpts,
+      autoClose: false,
+    }),
+    {},
+  );
+});
+
+/**
+ * Language adapter for Python.
+ */
+export class PythonLanguageAdapter implements LanguageAdapter<{}> {
+  readonly type = "python";
+  readonly defaultCode = "";
+  readonly defaultMetadata = {};
+
+  transformIn(code: string): [string, number, {}] {
+    return [code, 0, {}];
+  }
+
+  transformOut(code: string, _metadata: {}): [string, number] {
+    return [code, 0];
+  }
+
+  isSupported(_code: string): boolean {
+    return true;
+  }
+
+  getExtension(
+    cellId: CellId,
+    completionConfig: CompletionConfig,
+    hotkeys: HotkeyProvider,
+    placeholderType: PlaceholderType,
+    lspConfig: LSPConfig & { diagnostics: DiagnosticsConfig },
+  ): Extension[] {
+    const getCompletionsExtension = () => {
+      const autocompleteOptions = {
+        // We remove the default keymap because we use our own which
+        // handles the Escape key correctly in Vim
+        defaultKeymap: false,
+        // Whether or not to require keypress to activate autocompletion (default
+        // keymap is Ctrl+Space)
+        activateOnTyping: completionConfig.activate_on_typing,
+        // The Cell component handles the blur event. `closeOnBlur` is too
+        // aggressive and doesn't let the user click into the completion info
+        // element (which contains the docstring/type --- users might want to
+        // copy paste from the docstring). The main issue is that the completion
+        // tooltip is not part of the editable DOM tree:
+        // https://discuss.codemirror.net/t/adding-click-event-listener-to-autocomplete-tooltip-info-panel-is-not-working/4741
+        closeOnBlur: false,
+      };
+
+      const hoverOptions = {
+        hideOnChange: true,
+      };
+
+      const clients: ILanguageServerClient[] = [];
+
+      if (lspConfig?.pylsp?.enabled && hasCapability("pylsp")) {
+        clients.push(pylspClient(lspConfig));
+      }
+      if (lspConfig?.ty?.enabled && hasCapability("ty")) {
+        clients.push(tyLspClient(lspConfig));
+      }
+      if (lspConfig?.basedpyright?.enabled && hasCapability("basedpyright")) {
+        clients.push(pyrightClient(lspConfig));
+      }
+
+      if (clients.length > 0) {
+        const client =
+          clients.length === 1
+            ? (clients[0] as NotebookLanguageServerClient)
+            : new FederatedLanguageServerClient(clients);
+
+        return [
+          languageServerWithClient({
+            client: client as unknown as LanguageServerClient,
+            languageId: "python",
+            allowHTMLContent: true,
+            hoverConfig: hoverOptions,
+            completionConfig: autocompleteOptions,
+            // Default to false
+            diagnosticsEnabled: lspConfig.diagnostics?.enabled ?? false,
+            sendIncrementalChanges: false,
+            signatureHelpEnabled: true,
+            signatureActivateOnTyping: false,
+            keyboardShortcuts: {
+              signatureHelp: hotkeys.getHotkey("cell.signatureHelp").key,
+              goToDefinition: hotkeys.getHotkey("cell.goToDefinition").key,
+              rename: hotkeys.getHotkey("cell.renameSymbol").key,
+            },
+            // Match completions before the cursor is at the end of a word,
+            // after a dot, after a slash, after a comma.
+            completionMatchBefore: /(\w+|\w+\.|\(|\/|,)$/,
+            onGoToDefinition: (result) => {
+              Logger.debug("onGoToDefinition", result);
+              if (client.documentUri === result.uri) {
+                // Local definition
+                return;
+              }
+              getRequestClient().openFile({
+                path: result.uri.replace("file://", ""),
+              });
+            },
+          }),
+          documentUri.of(CellDocumentUri.of(cellId)),
+        ];
+      }
+
+      return autocompletion({
+        ...autocompleteOptions,
+        override: [pythonCompletionSource],
+      });
+    };
+
+    return [
+      getCompletionsExtension(),
+      customPythonLanguageSupport(),
+      getPlaceholderExtension(placeholderType),
+    ];
+  }
+}
+
+function getPlaceholderExtension(placeholderType: PlaceholderType): Extension {
+  if (placeholderType === "marimo-import") {
+    return Prec.highest(smartPlaceholderExtension("import marimo as mo"));
+  }
+
+  if (placeholderType === "ai") {
+    return clickablePlaceholderExtension({
+      beforeText: "Start coding or ",
+      linkText: "generate",
+      afterText: " with AI.",
+      onClick: (ev) => {
+        const cellActions = ev.state.facet(cellActionsState);
+        cellActions.aiCellCompletion();
+      },
+    });
+  }
+
+  return [];
+}
+
+// Customize python to support folding some additional syntax nodes
+const customizedPython = pythonLanguage.configure({
+  props: [
+    foldNodeProp.add({
+      ParenthesizedExpression: foldInside,
+      // Fold function calls whose arguments are split over multiple lines
+      ArgList: foldInside,
+    }),
+  ],
+});
+
+/**
+ * This provide LanguageSupport for Python, but with a custom LRLanguage
+ * that supports folding additional syntax nodes at the top-level.
+ */
+export function customPythonLanguageSupport(): LanguageSupport {
+  return new LanguageSupport(customizedPython, [
+    customizedPython.data.of({ autocomplete: localCompletionSource }),
+    customizedPython.data.of({ autocomplete: globalCompletion }),
+  ]);
+}

package/src/core/codemirror/language/languages/sql-dialects/README.md

@@ -0,0 +1,5 @@
+# Generating SQL Dialects
+
+SQL Dialects are used for CodeMirror to support SQL syntax highlighting.
+
+For DuckDB, you can run the python script `spec_duckdb.py` to generate the terms used for `duckdb.ts` file.

package/src/core/codemirror/language/languages/sql-dialects/duckdb.ts

@@ -0,0 +1,22 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+// Credit to https://github.com/sekuel/codemirror-sql-duckdb/blob/main/DuckDBDialect.js for the dialect spec
+
+import { SQLDialect, type SQLDialectSpec } from "@codemirror/lang-sql";
+
+const otherFunctions =
+  "percentile_cont row_number rank dense_rank rank_dense percent_rank cume_dist ntile lag lead first_value last_value nth_value";
+
+const DuckDBDialectSpec: SQLDialectSpec = {
+  charSetCasts: true,
+  doubleQuotedStrings: false,
+  unquotedBitLiterals: true,
+  hashComments: false,
+  spaceAfterDashes: false,
+  specialVar: "@?",
+  identifierQuotes: "`",
+  keywords: `${otherFunctions} !__postfix !~~ !~~* % & && * ** + - ->> / // <-> << <=> <@ >> @ @> Calendar JSON TimeZone ^ ^@ abort abs absolute access access_mode acos acosh action add add_parquet_key admin after age aggregate alias all all_profiling_output allow_community_extensions allow_extensions_metadata_mismatch allow_persistent_secrets allow_unredacted_secrets allow_unsigned_extensions allowed_directories allowed_paths also alter always analyse analyze and anti any any_value apply approx_count_distinct approx_quantile approx_top_k arbitrary arg_max arg_max_null arg_min arg_min_null argmax argmin array array_agg array_aggr array_aggregate array_append array_apply array_cat array_concat array_contains array_cosine_distance array_cosine_similarity array_cross_product array_distance array_distinct array_dot_product array_extract array_filter array_grade_up array_has array_has_all array_has_any array_indexof array_inner_product array_intersect array_length array_negative_dot_product array_negative_inner_product array_pop_back array_pop_front array_position array_prepend array_push_back array_push_front array_reduce array_resize array_reverse array_reverse_sort array_select array_slice array_sort array_to_json array_to_string array_to_string_comma_default array_transform array_unique array_value array_where array_zip arrow_large_buffer_size arrow_lossless_conversion arrow_output_list_view arrow_output_version arrow_scan arrow_scan_dumb as asc ascii asin asinh asof asof_loop_join_threshold assertion assignment asymmetric at atan atan2 atanh attach attribute authorization autoinstall_extension_repository autoinstall_known_extensions autoload_known_extensions avg backward bar base64 before begin between bigint bin binary binary_as_string bit bit_and bit_count bit_length bit_or bit_position bit_xor bitstring bitstring_agg blob bool bool_and bool_or boolean both bpchar by bytea cache call called can_cast_implicitly cardinality cascade cascaded case cast cast_to_type catalog catalog_error_max_schemas cbrt ceil ceiling centuries century chain char char_length character character_length characteristics check checkpoint checkpoint_threshold chr class close cluster coalesce col_description collate collation collations column columns combine comment comments commit committed compression concat concat_ws concurrently configuration conflict connection constant_or_null constraint constraints contains content continue conversion copy copy_database corr cos cosh cost cot count count_if count_star countif covar_pop covar_samp create create_sort_key cross csv cube current current_catalog current_connection_id current_database current_date current_localtime current_localtimestamp current_query current_query_id current_role current_schema current_schemas current_setting current_transaction_id current_user currval cursor custom_extension_repository custom_profiling_settings custom_user_agent cycle damerau_levenshtein data database database_list database_size date date_add date_diff date_part date_sub date_trunc datediff datepart datesub datetime datetrunc day dayname dayofmonth dayofweek dayofyear days deallocate debug_asof_iejoin debug_checkpoint_abort debug_force_external debug_force_no_cross_product debug_skip_checkpoint_on_commit debug_verify_vector debug_window_mode dec decade decades decimal declare decode default default_block_size default_collation default_null_order default_order default_secret_storage defaults deferrable deferred definer degrees delete delimiter delimiters depends desc describe detach dictionary disable disable_checkpoint_on_shutdown disable_logging disable_object_cache disable_optimizer disable_parquet_prefetching disable_print_progress_bar disable_profile disable_profiling disable_progress_bar disable_timestamptz_casts disable_verification disable_verify_external disable_verify_fetch_row disable_verify_parallelism disable_verify_serializer disabled_compression_methods disabled_filesystems disabled_log_types disabled_optimizers discard distinct divide do document domain double drop duckdb_api duckdb_columns duckdb_constraints duckdb_databases duckdb_dependencies duckdb_extensions duckdb_external_file_cache duckdb_functions duckdb_indexes duckdb_keywords duckdb_log_contexts duckdb_logs duckdb_logs_parsed duckdb_memory duckdb_optimizers duckdb_prepared_statements duckdb_schemas duckdb_secret_types duckdb_secrets duckdb_sequences duckdb_settings duckdb_table_sample duckdb_tables duckdb_temporary_files duckdb_types duckdb_variables duckdb_views dynamic_or_filter_threshold each editdist3 element_at else enable enable_checkpoint_on_shutdown enable_external_access enable_external_file_cache enable_fsst_vectors enable_geoparquet_conversion enable_http_logging enable_http_metadata_cache enable_logging enable_macro_dependencies enable_object_cache enable_optimizer enable_print_progress_bar enable_profile enable_profiling enable_progress_bar enable_progress_bar_print enable_verification enable_view_dependencies enabled_log_types encode encoding encrypted end ends_with entropy enum enum_code enum_first enum_last enum_range enum_range_boundary epoch epoch_ms epoch_ns epoch_us equi_width_bins era error errors_as_json escape even event except exclude excluding exclusive execute exists exp explain explain_output export export_state extension extension_directory extension_versions extensions external external_threads extract factorial false family favg fdiv fetch file_search_path filter finalize first flatten float float4 float8 floor fmod following for force force_bitpacking_mode force_checkpoint force_compression foreign format formatReadableDecimalSize formatReadableSize format_bytes format_pg_type format_type forward freeze from from_base64 from_binary from_hex from_json from_json_strict fsum full function functions gamma gcd gen_random_uuid generate_series generate_subscripts generated geomean geometric_mean get_bit get_block_size get_current_time get_current_timestamp getvariable glob global grade_up grant granted greatest greatest_common_divisor group group_concat grouping grouping_id groups guid hamming handler having header hex histogram histogram_exact histogram_values hold home_directory hour hours http_logging_output http_proxy http_proxy_password http_proxy_username hugeint identity ieee_floating_point_ops if ignore ilike ilike_escape immediate immediate_transaction_mode immutable implicit import import_database in in_search_path include including increment index index_scan_max_count index_scan_percentage indexes inet_client_addr inet_client_port inet_server_addr inet_server_port inherit inherits initially inline inner inout input insensitive insert install instead instr int int1 int128 int16 int2 int32 int4 int64 int8 integer integer_division integral intersect interval into invoker is is_histogram_other_bin isfinite isinf isnan isnull isodow isolation isoyear jaccard jaro_similarity jaro_winkler_similarity join json json_array json_array_length json_contains json_deserialize_sql json_each json_execute_serialized_sql json_exists json_extract json_extract_path json_extract_path_text json_extract_string json_group_array json_group_object json_group_structure json_keys json_merge_patch json_object json_pretty json_quote json_serialize_plan json_serialize_sql json_structure json_transform json_transform_strict json_tree json_type json_valid json_value julian kahan_sum key kurtosis kurtosis_pop label lambda lambda_syntax language large last last_day late_materialization_max_rows lateral lcase lcm leading leakproof least least_common_multiple left left_grapheme len length length_grapheme level levenshtein lgamma like like_escape limit list list_aggr list_aggregate list_any_value list_append list_apply list_approx_count_distinct list_avg list_bit_and list_bit_or list_bit_xor list_bool_and list_bool_or list_cat list_concat list_contains list_cosine_distance list_cosine_similarity list_count list_distance list_distinct list_dot_product list_element list_entropy list_extract list_filter list_first list_grade_up list_has list_has_all list_has_any list_histogram list_indexof list_inner_product list_intersect list_kurtosis list_kurtosis_pop list_last list_mad list_max list_median list_min list_mode list_negative_dot_product list_negative_inner_product list_pack list_position list_prepend list_product list_reduce list_resize list_reverse list_reverse_sort list_select list_sem list_skewness list_slice list_sort list_stddev_pop list_stddev_samp list_string_agg list_sum list_transform list_unique list_value list_var_pop list_var_samp list_where list_zip listagg listen ln load local location lock lock_configuration locked log log10 log2 log_query_path logged logging_level logging_mode logging_storage logical long lower lpad ltrim macro mad make_date make_time make_timestamp make_timestamp_ns make_timestamptz map map_concat map_contains map_contains_entry map_contains_value map_entries map_extract map_extract_value map_from_entries map_keys map_to_pg_oid map_values mapping match materialized max max_by max_expression_depth max_memory max_temp_directory_size max_vacuum_tasks maxvalue md5 md5_number md5_number_lower md5_number_upper mean median memory_limit merge_join_threshold metadata_info method microsecond microseconds millennia millennium millisecond milliseconds min min_by minute minutes minvalue mismatches mod mode month monthname months move multiply name names nanosecond national natural nchar nested_loop_join_threshold new next nextafter nextval nfc_normalize no none normalized_interval not not_ilike_escape not_like_escape nothing notify notnull now nowait null null_order nullif nulls numeric nvarchar obj_description object octet_length of off offset oid oids old old_implicit_casting on only operator option options or ord order order_by_non_integer_literal ordered_aggregate_threshold ordinality others out outer over overlaps overlay overriding owned owner pandas_analyze_sample pandas_scan parallel parquet_bloom_probe parquet_file_metadata parquet_kv_metadata parquet_metadata parquet_metadata_cache parquet_scan parquet_schema parse_dirname parse_dirpath parse_duckdb_log_message parse_filename parse_path parser partial partition partitioned partitioned_write_flush_threshold partitioned_write_max_open_files passing password percent perfect_ht_threshold persistent pi pivot pivot_filter_threshold pivot_limit pivot_longer pivot_wider placing plans platform policy position positional pow power pragma pragma_collations pragma_database_size pragma_metadata_info pragma_platform pragma_show pragma_storage_info pragma_table_info pragma_user_agent pragma_version preceding precision prefer_range_joins prefetch_all_parquet_files prefix prepare prepared preserve preserve_identifier_case preserve_insertion_order primary printf prior privileges procedural procedure produce_arrow_string_view product profile_output profiling_mode profiling_output program progress_bar_time publication python_enable_replacements python_map_function python_scan_all_frames qualify quantile quantile_cont quantile_disc quarter quarters query query_table quote radians random range read read_blob read_csv read_csv_auto read_json read_json_auto read_json_objects read_json_objects_auto read_ndjson read_ndjson_auto read_ndjson_objects read_parquet read_text real reassign recheck recursive reduce ref references referencing refresh regexp_escape regexp_extract regexp_extract_all regexp_full_match regexp_matches regexp_replace regexp_split_to_array regexp_split_to_table regr_avgx regr_avgy regr_count regr_intercept regr_r2 regr_slope regr_sxx regr_sxy regr_syy reindex relative release remap_struct rename repeat repeat_row repeatable replace replica reservoir_quantile reset respect restart restrict returning returns reverse revoke right right_grapheme role rollback rollup round round_even roundbankers row row_to_json rows rpad rtrim rule sample savepoint scalar_subquery_error_on_multiple_rows scheduler_process_partial schema schemas scope scroll search search_path second seconds secret secret_directory security select sem semi seq_scan sequence sequences serializable server session session_user set set_bit setof sets setseed sha1 sha256 share shobj_description short show show_databases show_tables show_tables_expanded sign signbit signed similar simple sin sinh skewness skip smallint snapshot sniff_csv some sorted split split_part sql sqrt stable standalone start starts_with statement statistics stats stddev stddev_pop stddev_samp stdin stdout storage storage_compatibility_version storage_info stored str_split str_split_regex streaming_buffer_size strftime strict string string_agg string_split string_split_regex string_to_array strip strip_accents strlen strpos strptime struct struct_concat struct_extract struct_extract_at struct_insert struct_pack subscription substr substring substring_grapheme subtract suffix sum sum_no_overflow sumkahan summarize summary symmetric sysid system table table_info tables tablesample tablespace tan tanh temp temp_directory template temporary test_all_types test_vector_types text then threads ties time time_bucket timestamp timestamp_ms timestamp_ns timestamp_s timestamp_us timestamptz timetz timetz_byte_comparable timezone timezone_hour timezone_minute tinyint to to_base to_base64 to_binary to_centuries to_days to_decades to_hex to_hours to_json to_microseconds to_millennia to_milliseconds to_minutes to_months to_quarters to_seconds to_timestamp to_weeks to_years today trailing transaction transaction_timestamp transform translate treat trigger trim true trunc truncate truncate_duckdb_logs trusted try_cast try_strptime txid_current type typeof types ubigint ucase uhugeint uint128 uint16 uint32 uint64 uint8 uinteger unbin unbounded uncommitted unencrypted unhex unicode union union_extract union_tag union_value unique unknown unlisten unlogged unnest unpack unpivot unpivot_list until update upper url_decode url_encode use user user_agent username using usmallint utinyint uuid uuid_extract_timestamp uuid_extract_version uuidv4 uuidv7 vacuum valid validate validator value values var_pop var_samp varbinary varchar variable variadic variance varint varying vector_type verbose verify_external verify_fetch_row verify_parallelism verify_serializer version view views virtual volatile wal_autocheckpoint wavg week weekday weekofyear weeks weighted_avg when where which_secret whitespace window with within without work worker_threads wrapper write write_log xml xmlattributes xmlconcat xmlelement xmlexists xmlforest xmlnamespaces xmlparse xmlpi xmlroot xmlserialize xmltable xor year years yearweek yes zone zstd_min_string_length | || ~ ~~ ~~* ~~~`,
+  types:
+    "JSON bigint binary bit bitstring blob bool boolean bpchar bytea char date datetime dec decimal double enum float float4 float8 guid hugeint int int1 int128 int16 int2 int32 int4 int64 int8 integer integral interval list logical long map null numeric nvarchar oid real row short signed smallint string struct text time timestamp timestamp_ms timestamp_ns timestamp_s timestamp_us timestamptz timetz tinyint ubigint uhugeint uint128 uint16 uint32 uint64 uint8 uinteger union usmallint utinyint uuid varbinary varchar varint",
+};
+
+export const DuckDBDialect = SQLDialect.define(DuckDBDialectSpec);