Edit on GitHub

sqlglot.generators.oracle

View Source

  1from __future__ import annotations
  2
  3
  4from sqlglot import exp, generator, transforms
  5from sqlglot.dialects.dialect import (
  6    no_ilike_sql,
  7    rename_func,
  8    strposition_sql,
  9    to_number_with_nls_param,
 10    trim_sql,
 11)
 12
 13
 14def _trim_sql(self: OracleGenerator, expression: exp.Trim) -> str:
 15    position = expression.args.get("position")
 16
 17    if position and position.upper() in ("LEADING", "TRAILING"):
 18        return self.trim_sql(expression)
 19
 20    return trim_sql(self, expression)
 21
 22
 23class OracleGenerator(generator.Generator):
 24    SELECT_KINDS: tuple[str, ...] = ()
 25    TRY_SUPPORTED = False
 26    SUPPORTS_UESCAPE = False
 27    LOCKING_READS_SUPPORTED = True
 28    SUPPORTS_MERGE_WHERE = True
 29    JOIN_HINTS = False
 30    TABLE_HINTS = False
 31    DATA_TYPE_SPECIFIERS_ALLOWED = True
 32    ALTER_TABLE_INCLUDE_COLUMN_KEYWORD = False
 33    LIMIT_FETCH = "FETCH"
 34    TABLESAMPLE_KEYWORDS = "SAMPLE"
 35    LAST_DAY_SUPPORTS_DATE_PART = False
 36    SUPPORTS_SELECT_INTO = True
 37    TZ_TO_WITH_TIME_ZONE = True
 38    SUPPORTS_WINDOW_EXCLUDE = True
 39    QUERY_HINT_SEP = " "
 40    SUPPORTS_DECODE_CASE = True
 41
 42    AFTER_HAVING_MODIFIER_TRANSFORMS = generator.AFTER_HAVING_MODIFIER_TRANSFORMS
 43
 44    TYPE_MAPPING = {
 45        **generator.Generator.TYPE_MAPPING,
 46        exp.DType.BLOB: "BLOB",
 47        exp.DType.TINYINT: "SMALLINT",
 48        exp.DType.SMALLINT: "SMALLINT",
 49        exp.DType.INT: "INT",
 50        exp.DType.BIGINT: "INT",
 51        exp.DType.DECIMAL: "NUMBER",
 52        exp.DType.DOUBLE: "DOUBLE PRECISION",
 53        exp.DType.VARCHAR: "VARCHAR2",
 54        exp.DType.NVARCHAR: "NVARCHAR2",
 55        exp.DType.NCHAR: "NCHAR",
 56        exp.DType.TEXT: "CLOB",
 57        exp.DType.TIMETZ: "TIME",
 58        exp.DType.TIMESTAMPNTZ: "TIMESTAMP",
 59        exp.DType.TIMESTAMPTZ: "TIMESTAMP",
 60        exp.DType.BINARY: "BLOB",
 61        exp.DType.VARBINARY: "BLOB",
 62        exp.DType.ROWVERSION: "BLOB",
 63    }
 64
 65    TRANSFORMS = {
 66        **generator.Generator.TRANSFORMS,
 67        exp.DateStrToDate: lambda self, e: self.func(
 68            "TO_DATE", e.this, exp.Literal.string("YYYY-MM-DD")
 69        ),
 70        exp.DateTrunc: lambda self, e: self.func("TRUNC", e.this, e.unit),
 71        exp.EuclideanDistance: rename_func("L2_DISTANCE"),
 72        exp.ILike: no_ilike_sql,
 73        exp.LogicalOr: rename_func("MAX"),
 74        exp.LogicalAnd: rename_func("MIN"),
 75        exp.Mod: rename_func("MOD"),
 76        exp.Rand: rename_func("DBMS_RANDOM.VALUE"),
 77        exp.Select: transforms.preprocess(
 78            [
 79                transforms.eliminate_distinct_on,
 80                transforms.eliminate_qualify,
 81            ]
 82        ),
 83        exp.StrPosition: lambda self, e: strposition_sql(
 84            self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
 85        ),
 86        exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
 87        exp.StrToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e)),
 88        exp.Subquery: lambda self, e: self.subquery_sql(e, sep=" "),
 89        exp.Substring: rename_func("SUBSTR"),
 90        exp.Table: lambda self, e: self.table_sql(e, sep=" "),
 91        exp.TableSample: lambda self, e: self.tablesample_sql(e),
 92        exp.TemporaryProperty: lambda _, e: f"{e.name or 'GLOBAL'} TEMPORARY",
 93        exp.TimeToStr: lambda self, e: self.func("TO_CHAR", e.this, self.format_time(e)),
 94        exp.ToChar: lambda self, e: self.function_fallback_sql(e),
 95        exp.ToNumber: to_number_with_nls_param,
 96        exp.Trim: _trim_sql,
 97        exp.Unicode: lambda self, e: f"ASCII(UNISTR({self.sql(e.this)}))",
 98        exp.UnixToTime: lambda self, e: (
 99            f"TO_DATE('1970-01-01', 'YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)"
100        ),
101        exp.UtcTimestamp: rename_func("UTC_TIMESTAMP"),
102        exp.UtcTime: rename_func("UTC_TIME"),
103        exp.Systimestamp: lambda self, e: "SYSTIMESTAMP",
104    }
105
106    PROPERTIES_LOCATION = {
107        **generator.Generator.PROPERTIES_LOCATION,
108        exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
109    }
110
111    def currenttimestamp_sql(self, expression: exp.CurrentTimestamp) -> str:
112        if expression.args.get("sysdate"):
113            return "SYSDATE"
114
115        this = expression.this
116        return self.func("CURRENT_TIMESTAMP", this) if this else "CURRENT_TIMESTAMP"
117
118    def offset_sql(self, expression: exp.Offset) -> str:
119        return f"{super().offset_sql(expression)} ROWS"
120
121    def add_column_sql(self, expression: exp.Expr) -> str:
122        return f"ADD {self.sql(expression)}"
123
124    def queryoption_sql(self, expression: exp.QueryOption) -> str:
125        option = self.sql(expression, "this")
126        value = self.sql(expression, "expression")
127        value = f" CONSTRAINT {value}" if value else ""
128
129        return f"{option}{value}"
130
131    def coalesce_sql(self, expression: exp.Coalesce) -> str:
132        func_name = "NVL" if expression.args.get("is_nvl") else "COALESCE"
133        return rename_func(func_name)(self, expression)
134
135    def into_sql(self, expression: exp.Into) -> str:
136        into = "INTO" if not expression.args.get("bulk_collect") else "BULK COLLECT INTO"
137        if expression.this:
138            return f"{self.seg(into)} {self.sql(expression, 'this')}"
139
140        return f"{self.seg(into)} {self.expressions(expression)}"
141
142    def hint_sql(self, expression: exp.Hint) -> str:
143        expressions = []
144
145        for hint in expression.expressions:
146            if isinstance(hint, exp.Anonymous):
147                formatted_args = self.format_args(*hint.expressions, sep=" ")
148                expressions.append(f"{self.sql(hint, 'this')}({formatted_args})")
149            else:
150                expressions.append(self.sql(hint))
151
152        return f" /*+ {self.expressions(sqls=expressions, sep=self.QUERY_HINT_SEP).strip()} */"
153
154    def isascii_sql(self, expression: exp.IsAscii) -> str:
155        return f"NVL(REGEXP_LIKE({self.sql(expression.this)}, '^[' || CHR(1) || '-' || CHR(127) || ']*$'), TRUE)"
156
157    def interval_sql(self, expression: exp.Interval) -> str:
158        return f"{'INTERVAL ' if isinstance(expression.this, exp.Literal) else ''}{self.sql(expression, 'this')} {self.sql(expression, 'unit')}"
159
160    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
161        param_constraint = expression.find(exp.InOutColumnConstraint)
162        if param_constraint:
163            sep = f" {self.sql(param_constraint)} "
164            param_constraint.pop()
165        return super().columndef_sql(expression, sep)

class OracleGenerator(sqlglot.generator.Generator): View Source

 24class OracleGenerator(generator.Generator):
 25    SELECT_KINDS: tuple[str, ...] = ()
 26    TRY_SUPPORTED = False
 27    SUPPORTS_UESCAPE = False
 28    LOCKING_READS_SUPPORTED = True
 29    SUPPORTS_MERGE_WHERE = True
 30    JOIN_HINTS = False
 31    TABLE_HINTS = False
 32    DATA_TYPE_SPECIFIERS_ALLOWED = True
 33    ALTER_TABLE_INCLUDE_COLUMN_KEYWORD = False
 34    LIMIT_FETCH = "FETCH"
 35    TABLESAMPLE_KEYWORDS = "SAMPLE"
 36    LAST_DAY_SUPPORTS_DATE_PART = False
 37    SUPPORTS_SELECT_INTO = True
 38    TZ_TO_WITH_TIME_ZONE = True
 39    SUPPORTS_WINDOW_EXCLUDE = True
 40    QUERY_HINT_SEP = " "
 41    SUPPORTS_DECODE_CASE = True
 42
 43    AFTER_HAVING_MODIFIER_TRANSFORMS = generator.AFTER_HAVING_MODIFIER_TRANSFORMS
 44
 45    TYPE_MAPPING = {
 46        **generator.Generator.TYPE_MAPPING,
 47        exp.DType.BLOB: "BLOB",
 48        exp.DType.TINYINT: "SMALLINT",
 49        exp.DType.SMALLINT: "SMALLINT",
 50        exp.DType.INT: "INT",
 51        exp.DType.BIGINT: "INT",
 52        exp.DType.DECIMAL: "NUMBER",
 53        exp.DType.DOUBLE: "DOUBLE PRECISION",
 54        exp.DType.VARCHAR: "VARCHAR2",
 55        exp.DType.NVARCHAR: "NVARCHAR2",
 56        exp.DType.NCHAR: "NCHAR",
 57        exp.DType.TEXT: "CLOB",
 58        exp.DType.TIMETZ: "TIME",
 59        exp.DType.TIMESTAMPNTZ: "TIMESTAMP",
 60        exp.DType.TIMESTAMPTZ: "TIMESTAMP",
 61        exp.DType.BINARY: "BLOB",
 62        exp.DType.VARBINARY: "BLOB",
 63        exp.DType.ROWVERSION: "BLOB",
 64    }
 65
 66    TRANSFORMS = {
 67        **generator.Generator.TRANSFORMS,
 68        exp.DateStrToDate: lambda self, e: self.func(
 69            "TO_DATE", e.this, exp.Literal.string("YYYY-MM-DD")
 70        ),
 71        exp.DateTrunc: lambda self, e: self.func("TRUNC", e.this, e.unit),
 72        exp.EuclideanDistance: rename_func("L2_DISTANCE"),
 73        exp.ILike: no_ilike_sql,
 74        exp.LogicalOr: rename_func("MAX"),
 75        exp.LogicalAnd: rename_func("MIN"),
 76        exp.Mod: rename_func("MOD"),
 77        exp.Rand: rename_func("DBMS_RANDOM.VALUE"),
 78        exp.Select: transforms.preprocess(
 79            [
 80                transforms.eliminate_distinct_on,
 81                transforms.eliminate_qualify,
 82            ]
 83        ),
 84        exp.StrPosition: lambda self, e: strposition_sql(
 85            self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
 86        ),
 87        exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
 88        exp.StrToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e)),
 89        exp.Subquery: lambda self, e: self.subquery_sql(e, sep=" "),
 90        exp.Substring: rename_func("SUBSTR"),
 91        exp.Table: lambda self, e: self.table_sql(e, sep=" "),
 92        exp.TableSample: lambda self, e: self.tablesample_sql(e),
 93        exp.TemporaryProperty: lambda _, e: f"{e.name or 'GLOBAL'} TEMPORARY",
 94        exp.TimeToStr: lambda self, e: self.func("TO_CHAR", e.this, self.format_time(e)),
 95        exp.ToChar: lambda self, e: self.function_fallback_sql(e),
 96        exp.ToNumber: to_number_with_nls_param,
 97        exp.Trim: _trim_sql,
 98        exp.Unicode: lambda self, e: f"ASCII(UNISTR({self.sql(e.this)}))",
 99        exp.UnixToTime: lambda self, e: (
100            f"TO_DATE('1970-01-01', 'YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)"
101        ),
102        exp.UtcTimestamp: rename_func("UTC_TIMESTAMP"),
103        exp.UtcTime: rename_func("UTC_TIME"),
104        exp.Systimestamp: lambda self, e: "SYSTIMESTAMP",
105    }
106
107    PROPERTIES_LOCATION = {
108        **generator.Generator.PROPERTIES_LOCATION,
109        exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
110    }
111
112    def currenttimestamp_sql(self, expression: exp.CurrentTimestamp) -> str:
113        if expression.args.get("sysdate"):
114            return "SYSDATE"
115
116        this = expression.this
117        return self.func("CURRENT_TIMESTAMP", this) if this else "CURRENT_TIMESTAMP"
118
119    def offset_sql(self, expression: exp.Offset) -> str:
120        return f"{super().offset_sql(expression)} ROWS"
121
122    def add_column_sql(self, expression: exp.Expr) -> str:
123        return f"ADD {self.sql(expression)}"
124
125    def queryoption_sql(self, expression: exp.QueryOption) -> str:
126        option = self.sql(expression, "this")
127        value = self.sql(expression, "expression")
128        value = f" CONSTRAINT {value}" if value else ""
129
130        return f"{option}{value}"
131
132    def coalesce_sql(self, expression: exp.Coalesce) -> str:
133        func_name = "NVL" if expression.args.get("is_nvl") else "COALESCE"
134        return rename_func(func_name)(self, expression)
135
136    def into_sql(self, expression: exp.Into) -> str:
137        into = "INTO" if not expression.args.get("bulk_collect") else "BULK COLLECT INTO"
138        if expression.this:
139            return f"{self.seg(into)} {self.sql(expression, 'this')}"
140
141        return f"{self.seg(into)} {self.expressions(expression)}"
142
143    def hint_sql(self, expression: exp.Hint) -> str:
144        expressions = []
145
146        for hint in expression.expressions:
147            if isinstance(hint, exp.Anonymous):
148                formatted_args = self.format_args(*hint.expressions, sep=" ")
149                expressions.append(f"{self.sql(hint, 'this')}({formatted_args})")
150            else:
151                expressions.append(self.sql(hint))
152
153        return f" /*+ {self.expressions(sqls=expressions, sep=self.QUERY_HINT_SEP).strip()} */"
154
155    def isascii_sql(self, expression: exp.IsAscii) -> str:
156        return f"NVL(REGEXP_LIKE({self.sql(expression.this)}, '^[' || CHR(1) || '-' || CHR(127) || ']*$'), TRUE)"
157
158    def interval_sql(self, expression: exp.Interval) -> str:
159        return f"{'INTERVAL ' if isinstance(expression.this, exp.Literal) else ''}{self.sql(expression, 'this')} {self.sql(expression, 'unit')}"
160
161    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
162        param_constraint = expression.find(exp.InOutColumnConstraint)
163        if param_constraint:
164            sep = f" {self.sql(param_constraint)} "
165            param_constraint.pop()
166        return super().columndef_sql(expression, sep)

Generator converts a given syntax tree to the corresponding SQL string.

Arguments:

pretty: Whether to format the produced SQL string. Default: False.
identify: Determines when an identifier should be quoted. Possible values are: False (default): Never quote, except in cases where it's mandatory by the dialect. True: Always quote except for specials cases. 'safe': Only quote identifiers that are case insensitive.
normalize: Whether to normalize identifiers to lowercase. Default: False.
pad: The pad size in a formatted string. For example, this affects the indentation of a projection in a query, relative to its nesting level. Default: 2.
indent: The indentation size in a formatted string. For example, this affects the indentation of subqueries and filters under a WHERE clause. Default: 2.
normalize_functions: How to normalize function names. Possible values are: "upper" or True (default): Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.
unsupported_level: Determines the generator's behavior when it encounters unsupported expressions. Default ErrorLevel.WARN.
max_unsupported: Maximum number of unsupported messages to include in a raised UnsupportedError. This is only relevant if unsupported_level is ErrorLevel.RAISE. Default: 3
leading_comma: Whether the comma is leading or trailing in select expressions. This is only relevant when generating in pretty mode. Default: False
max_text_width: The max number of characters in a segment before creating new lines in pretty mode. The default is on the smaller end because the length only represents a segment and not the true line length. Default: 80
comments: Whether to preserve comments in the output SQL code. Default: True

SELECT_KINDS: tuple[str, ...] = ()

TRY_SUPPORTED = False

SUPPORTS_UESCAPE = False

LOCKING_READS_SUPPORTED = True

SUPPORTS_MERGE_WHERE = True

JOIN_HINTS = False

TABLE_HINTS = False

DATA_TYPE_SPECIFIERS_ALLOWED = True

ALTER_TABLE_INCLUDE_COLUMN_KEYWORD = False

LIMIT_FETCH = 'FETCH'

TABLESAMPLE_KEYWORDS = 'SAMPLE'

LAST_DAY_SUPPORTS_DATE_PART = False

SUPPORTS_SELECT_INTO = True

TZ_TO_WITH_TIME_ZONE = True

SUPPORTS_WINDOW_EXCLUDE = True

QUERY_HINT_SEP = ' '

SUPPORTS_DECODE_CASE = True

AFTER_HAVING_MODIFIER_TRANSFORMS = {'windows': <function <lambda>>, 'qualify': <function <lambda>>}

TYPE_MAPPING = {<DType.DATETIME2: 'DATETIME2'>: 'TIMESTAMP', <DType.NCHAR: 'NCHAR'>: 'NCHAR', <DType.NVARCHAR: 'NVARCHAR'>: 'NVARCHAR2', <DType.MEDIUMTEXT: 'MEDIUMTEXT'>: 'TEXT', <DType.LONGTEXT: 'LONGTEXT'>: 'TEXT', <DType.TINYTEXT: 'TINYTEXT'>: 'TEXT', <DType.BLOB: 'BLOB'>: 'BLOB', <DType.MEDIUMBLOB: 'MEDIUMBLOB'>: 'BLOB', <DType.LONGBLOB: 'LONGBLOB'>: 'BLOB', <DType.TINYBLOB: 'TINYBLOB'>: 'BLOB', <DType.INET: 'INET'>: 'INET', <DType.ROWVERSION: 'ROWVERSION'>: 'BLOB', <DType.SMALLDATETIME: 'SMALLDATETIME'>: 'TIMESTAMP', <DType.TINYINT: 'TINYINT'>: 'SMALLINT', <DType.SMALLINT: 'SMALLINT'>: 'SMALLINT', <DType.INT: 'INT'>: 'INT', <DType.BIGINT: 'BIGINT'>: 'INT', <DType.DECIMAL: 'DECIMAL'>: 'NUMBER', <DType.DOUBLE: 'DOUBLE'>: 'DOUBLE PRECISION', <DType.VARCHAR: 'VARCHAR'>: 'VARCHAR2', <DType.TEXT: 'TEXT'>: 'CLOB', <DType.TIMETZ: 'TIMETZ'>: 'TIME', <DType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>: 'TIMESTAMP', <DType.TIMESTAMPTZ: 'TIMESTAMPTZ'>: 'TIMESTAMP', <DType.BINARY: 'BINARY'>: 'BLOB', <DType.VARBINARY: 'VARBINARY'>: 'BLOB'}

PROPERTIES_LOCATION = {<class 'sqlglot.expressions.properties.AllowedValuesProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.AlgorithmProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.ApiProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.ApplicationProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.AutoIncrementProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.AutoRefreshProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.BackupProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.BlockCompressionProperty'>: <PropertiesLocation.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.properties.CatalogProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.CharacterSetProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.ChecksumProperty'>: <PropertiesLocation.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.properties.CollateProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.ComputeProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.CopyGrantsProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.query.Cluster'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.ClusteredByProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.DistributedByProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.DuplicateKeyProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.DataBlocksizeProperty'>: <PropertiesLocation.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.properties.DatabaseProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.DataDeletionProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.DefinerProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.DictRange'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.DictProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.DynamicProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.DistKeyProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.DistStyleProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.EmptyProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.EncodeProperty'>: <PropertiesLocation.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.properties.EngineProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.EnviromentProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.HandlerProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.ParameterStyleProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.ExecuteAsProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.ExternalProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.FallbackProperty'>: <PropertiesLocation.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.properties.FileFormatProperty'>: <PropertiesLocation.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.properties.FreespaceProperty'>: <PropertiesLocation.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.properties.GlobalProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.HeapProperty'>: <PropertiesLocation.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.properties.HybridProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.InheritsProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.IcebergProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.IncludeProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.InputModelProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.IsolatedLoadingProperty'>: <PropertiesLocation.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.properties.JournalProperty'>: <PropertiesLocation.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.properties.LanguageProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.LikeProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.LocationProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.LockProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.LockingProperty'>: <PropertiesLocation.POST_ALIAS: 'POST_ALIAS'>, <class 'sqlglot.expressions.properties.LogProperty'>: <PropertiesLocation.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.properties.MaskingProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.MaterializedProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.MergeBlockRatioProperty'>: <PropertiesLocation.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.properties.ModuleProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.NetworkProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.NoPrimaryIndexProperty'>: <PropertiesLocation.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.properties.OnProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.OnCommitProperty'>: <PropertiesLocation.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.query.Order'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.OutputModelProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.PartitionedByProperty'>: <PropertiesLocation.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.properties.PartitionedOfProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.constraints.PrimaryKey'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.Property'>: <PropertiesLocation.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.properties.RefreshTriggerProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.RemoteWithConnectionModelProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.ReturnsProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.RollupProperty'>: <PropertiesLocation.UNSUPPORTED: 'UNSUPPORTED'>, <class 'sqlglot.expressions.properties.RowAccessProperty'>: <PropertiesLocation.UNSUPPORTED: 'UNSUPPORTED'>, <class 'sqlglot.expressions.properties.RowFormatProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.RowFormatDelimitedProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.RowFormatSerdeProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.SampleProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.SchemaCommentProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.SecureProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.SecurityIntegrationProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.SerdeProperties'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ddl.Set'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.SettingsProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.SetProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.SetConfigProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.SharingProperty'>: <PropertiesLocation.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.ddl.SequenceProperties'>: <PropertiesLocation.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.ddl.TriggerProperties'>: <PropertiesLocation.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.properties.SortKeyProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.SqlReadWriteProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.SqlSecurityProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.StabilityProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.StorageHandlerProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.StreamingTableProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.StrictProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.Tags'>: <PropertiesLocation.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.properties.TemporaryProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.ToTableProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.TransientProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.TransformModelProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ddl.MergeTreeTTL'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.UnloggedProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.UsingProperty'>: <PropertiesLocation.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.properties.UsingTemplateProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.ViewAttributeProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.VirtualProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.properties.VolatileProperty'>: <PropertiesLocation.UNSUPPORTED: 'UNSUPPORTED'>, <class 'sqlglot.expressions.properties.WithDataProperty'>: <PropertiesLocation.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.properties.WithJournalTableProperty'>: <PropertiesLocation.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.properties.WithProcedureOptions'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.WithSchemaBindingProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.WithSystemVersioningProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.properties.ForceProperty'>: <PropertiesLocation.POST_CREATE: 'POST_CREATE'>}

def currenttimestamp_sql(self, expression: sqlglot.expressions.temporal.CurrentTimestamp) -> str: View Source

112    def currenttimestamp_sql(self, expression: exp.CurrentTimestamp) -> str:
113        if expression.args.get("sysdate"):
114            return "SYSDATE"
115
116        this = expression.this
117        return self.func("CURRENT_TIMESTAMP", this) if this else "CURRENT_TIMESTAMP"

def offset_sql(self, expression: sqlglot.expressions.query.Offset) -> str: View Source

119    def offset_sql(self, expression: exp.Offset) -> str:
120        return f"{super().offset_sql(expression)} ROWS"

def add_column_sql(self, expression: sqlglot.expressions.core.Expr) -> str: View Source

122    def add_column_sql(self, expression: exp.Expr) -> str:
123        return f"ADD {self.sql(expression)}"

def queryoption_sql(self, expression: sqlglot.expressions.query.QueryOption) -> str: View Source

125    def queryoption_sql(self, expression: exp.QueryOption) -> str:
126        option = self.sql(expression, "this")
127        value = self.sql(expression, "expression")
128        value = f" CONSTRAINT {value}" if value else ""
129
130        return f"{option}{value}"

def coalesce_sql(self, expression: sqlglot.expressions.functions.Coalesce) -> str: View Source

132    def coalesce_sql(self, expression: exp.Coalesce) -> str:
133        func_name = "NVL" if expression.args.get("is_nvl") else "COALESCE"
134        return rename_func(func_name)(self, expression)

def into_sql(self, expression: sqlglot.expressions.query.Into) -> str: View Source

136    def into_sql(self, expression: exp.Into) -> str:
137        into = "INTO" if not expression.args.get("bulk_collect") else "BULK COLLECT INTO"
138        if expression.this:
139            return f"{self.seg(into)} {self.sql(expression, 'this')}"
140
141        return f"{self.seg(into)} {self.expressions(expression)}"

def hint_sql(self, expression: sqlglot.expressions.core.Hint) -> str: View Source

143    def hint_sql(self, expression: exp.Hint) -> str:
144        expressions = []
145
146        for hint in expression.expressions:
147            if isinstance(hint, exp.Anonymous):
148                formatted_args = self.format_args(*hint.expressions, sep=" ")
149                expressions.append(f"{self.sql(hint, 'this')}({formatted_args})")
150            else:
151                expressions.append(self.sql(hint))
152
153        return f" /*+ {self.expressions(sqls=expressions, sep=self.QUERY_HINT_SEP).strip()} */"

def isascii_sql(self, expression: sqlglot.expressions.string.IsAscii) -> str: View Source

155    def isascii_sql(self, expression: exp.IsAscii) -> str:
156        return f"NVL(REGEXP_LIKE({self.sql(expression.this)}, '^[' || CHR(1) || '-' || CHR(127) || ']*$'), TRUE)"

def interval_sql(self, expression: sqlglot.expressions.datatypes.Interval) -> str: View Source

158    def interval_sql(self, expression: exp.Interval) -> str:
159        return f"{'INTERVAL ' if isinstance(expression.this, exp.Literal) else ''}{self.sql(expression, 'this')} {self.sql(expression, 'unit')}"

def columndef_sql( self, expression: sqlglot.expressions.query.ColumnDef, sep: str = ' ') -> str: View Source

161    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
162        param_constraint = expression.find(exp.InOutColumnConstraint)
163        if param_constraint:
164            sep = f" {self.sql(param_constraint)} "
165            param_constraint.pop()
166        return super().columndef_sql(expression, sep)

Inherited Members

sqlglot.generator.Generator: Generator; NULL_ORDERING_SUPPORTED; WINDOW_FUNCS_WITH_NULL_ORDERING; IGNORE_NULLS_IN_FUNC; IGNORE_NULLS_BEFORE_ORDER; EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE; WRAP_DERIVED_VALUES; CREATE_FUNCTION_RETURN_AS; MATCHED_BY_SOURCE; SINGLE_STRING_INTERVAL; INTERVAL_ALLOWS_PLURAL_FORM; LIMIT_ONLY_LITERALS; RENAME_TABLE_WITH_DB; GROUPINGS_SEP; INDEX_ON; INOUT_SEPARATOR; DIRECTED_JOINS; QUERY_HINTS; IS_BOOL_ALLOWED; DUPLICATE_KEY_UPDATE_WITH_SET; LIMIT_IS_TOP; RETURNING_END; EXTRACT_ALLOWS_QUOTES; NVL2_SUPPORTED; VALUES_AS_TABLE; UNNEST_WITH_ORDINALITY; AGGREGATE_FILTER_SUPPORTED; SEMI_ANTI_JOIN_WITH_SIDE; COMPUTED_COLUMN_WITH_TYPE; SUPPORTS_TABLE_COPY; TABLESAMPLE_REQUIRES_PARENS; TABLESAMPLE_SIZE_IS_ROWS; TABLESAMPLE_WITH_METHOD; TABLESAMPLE_SEED_KEYWORD; COLLATE_IS_FUNC; ENSURE_BOOLS; CTE_RECURSIVE_KEYWORD_REQUIRED; SUPPORTS_SINGLE_ARG_CONCAT; SUPPORTS_TABLE_ALIAS_COLUMNS; UNPIVOT_ALIASES_ARE_IDENTIFIERS; JSON_KEY_VALUE_PAIR_SEP; INSERT_OVERWRITE; SUPPORTS_UNLOGGED_TABLES; SUPPORTS_CREATE_TABLE_LIKE; LIKE_PROPERTY_INSIDE_SCHEMA; MULTI_ARG_DISTINCT; JSON_TYPE_REQUIRED_FOR_EXTRACTION; JSON_PATH_BRACKETED_KEY_SUPPORTED; JSON_PATH_SINGLE_QUOTE_ESCAPE; SUPPORTED_JSON_PATH_PARTS; CAN_IMPLEMENT_ARRAY_ANY; SUPPORTS_TO_NUMBER; SET_OP_MODIFIERS; COPY_PARAMS_ARE_WRAPPED; COPY_PARAMS_EQ_REQUIRED; COPY_HAS_INTO_KEYWORD; UNICODE_SUBSTITUTE; STAR_EXCEPT; HEX_FUNC; WITH_PROPERTIES_PREFIX; QUOTE_JSON_PATH; PAD_FILL_PATTERN_IS_REQUIRED; SUPPORTS_EXPLODING_PROJECTIONS; ARRAY_CONCAT_IS_VAR_LEN; SUPPORTS_CONVERT_TIMEZONE; SUPPORTS_MEDIAN; SUPPORTS_UNIX_SECONDS; ALTER_SET_WRAPPED; NORMALIZE_EXTRACT_DATE_PARTS; PARSE_JSON_NAME; ARRAY_SIZE_NAME; ALTER_SET_TYPE; ARRAY_SIZE_DIM_REQUIRED; SUPPORTS_BETWEEN_FLAGS; SUPPORTS_LIKE_QUANTIFIERS; MATCH_AGAINST_TABLE_PREFIX; SET_ASSIGNMENT_REQUIRES_VARIABLE_KEYWORD; DECLARE_DEFAULT_ASSIGNMENT; UPDATE_STATEMENT_SUPPORTS_FROM; STAR_EXCLUDE_REQUIRES_DERIVED_TABLE; SUPPORTS_DROP_ALTER_ICEBERG_PROPERTY; UNSUPPORTED_TYPES; TIME_PART_SINGULARS; TOKEN_MAPPING; STRUCT_DELIMITER; PARAMETER_TOKEN; NAMED_PLACEHOLDER_TOKEN; EXPRESSION_PRECEDES_PROPERTIES_CREATABLES; RESERVED_KEYWORDS; WITH_SEPARATED_COMMENTS; EXCLUDE_COMMENTS; UNWRAPPED_INTERVAL_VALUES; PARAMETERIZABLE_TEXT_TYPES; EXPRESSIONS_WITHOUT_NESTED_CTES; RESPECT_IGNORE_NULLS_UNSUPPORTED_EXPRESSIONS; SAFE_JSON_PATH_KEY_RE; SENTINEL_LINE_BREAK; pretty; identify; normalize; pad; unsupported_level; max_unsupported; leading_comma; max_text_width; comments; dialect; normalize_functions; unsupported_messages; generate; preprocess; unsupported; sep; seg; sanitize_comment; maybe_comment; wrap; no_identify; normalize_func; indent; sql; uncache_sql; cache_sql; characterset_sql; column_parts; column_sql; pseudocolumn_sql; columnposition_sql; columnconstraint_sql; computedcolumnconstraint_sql; autoincrementcolumnconstraint_sql; compresscolumnconstraint_sql; generatedasidentitycolumnconstraint_sql; generatedasrowcolumnconstraint_sql; periodforsystemtimeconstraint_sql; notnullcolumnconstraint_sql; primarykeycolumnconstraint_sql; uniquecolumnconstraint_sql; inoutcolumnconstraint_sql; createable_sql; create_sql; sequenceproperties_sql; triggerproperties_sql; triggerreferencing_sql; triggerevent_sql; clone_sql; describe_sql; heredoc_sql; prepend_ctes; with_sql; cte_sql; tablealias_sql; bitstring_sql; hexstring_sql; bytestring_sql; unicodestring_sql; rawstring_sql; datatypeparam_sql; datatype_sql; directory_sql; delete_sql; drop_sql; set_operation; set_operations; fetch_sql; limitoptions_sql; filter_sql; indexparameters_sql; index_sql; identifier_sql; hex_sql; lowerhex_sql; inputoutputformat_sql; national_sql; partition_sql; properties_sql; root_properties; properties; with_properties; locate_properties; property_name; property_sql; uuidproperty_sql; likeproperty_sql; fallbackproperty_sql; journalproperty_sql; freespaceproperty_sql; checksumproperty_sql; mergeblockratioproperty_sql; moduleproperty_sql; datablocksizeproperty_sql; blockcompressionproperty_sql; isolatedloadingproperty_sql; partitionboundspec_sql; partitionedofproperty_sql; lockingproperty_sql; withdataproperty_sql; withsystemversioningproperty_sql; insert_sql; introducer_sql; kill_sql; pseudotype_sql; objectidentifier_sql; onconflict_sql; returning_sql; rowformatdelimitedproperty_sql; withtablehint_sql; indextablehint_sql; historicaldata_sql; table_parts; table_sql; tablefromrows_sql; tablesample_sql; pivot_sql; version_sql; tuple_sql; update_sql; values_sql; var_sql; from_sql; groupingsets_sql; rollup_sql; rollupindex_sql; rollupproperty_sql; cube_sql; group_sql; having_sql; connect_sql; prior_sql; join_sql; lambda_sql; lateral_op; lateral_sql; limit_sql; setitem_sql; set_sql; queryband_sql; pragma_sql; lock_sql; literal_sql; escape_str; loaddata_sql; null_sql; boolean_sql; booland_sql; boolor_sql; order_sql; withfill_sql; cluster_sql; distribute_sql; sort_sql; ordered_sql; matchrecognizemeasure_sql; matchrecognize_sql; query_modifiers; options_modifier; for_modifiers; offset_limit_modifiers; after_limit_modifiers; select_sql; schema_sql; schema_columns_sql; star_sql; parameter_sql; sessionparameter_sql; placeholder_sql; subquery_sql; qualify_sql; unnest_sql; prewhere_sql; where_sql; window_sql; partition_by_sql; windowspec_sql; withingroup_sql; between_sql; bracket_offset_expressions; bracket_sql; all_sql; any_sql; exists_sql; case_sql; constraint_sql; nextvaluefor_sql; extract_sql; trim_sql; convert_concat_args; concat_sql; concatws_sql; check_sql; foreignkey_sql; primarykey_sql; if_sql; matchagainst_sql; jsonkeyvalue_sql; jsonpath_sql; json_path_part; formatjson_sql; formatphrase_sql; jsonarray_sql; jsonarrayagg_sql; jsoncolumndef_sql; jsonschema_sql; jsontable_sql; openjsoncolumndef_sql; openjson_sql; in_sql; in_unnest_op; return_sql; reference_sql; anonymous_sql; paren_sql; neg_sql; not_sql; alias_sql; pivotalias_sql; aliases_sql; atindex_sql; attimezone_sql; fromtimezone_sql; add_sql; and_sql; or_sql; xor_sql; connector_sql; bitwiseand_sql; bitwiseleftshift_sql; bitwisenot_sql; bitwiseor_sql; bitwiserightshift_sql; bitwisexor_sql; cast_sql; strtotime_sql; currentdate_sql; collate_sql; command_sql; comment_sql; mergetreettlaction_sql; mergetreettl_sql; transaction_sql; commit_sql; rollback_sql; altercolumn_sql; alterindex_sql; alterdiststyle_sql; altersortkey_sql; alterrename_sql; renamecolumn_sql; alterset_sql; alter_sql; altersession_sql; droppartition_sql; addconstraint_sql; addpartition_sql; distinct_sql; ignorenulls_sql; respectnulls_sql; havingmax_sql; intdiv_sql; dpipe_sql; div_sql; safedivide_sql; overlaps_sql; distance_sql; dot_sql; eq_sql; propertyeq_sql; escape_sql; glob_sql; gt_sql; gte_sql; is_sql; like_sql; ilike_sql; match_sql; similarto_sql; lt_sql; lte_sql; mod_sql; mul_sql; neq_sql; nullsafeeq_sql; nullsafeneq_sql; sub_sql; trycast_sql; jsoncast_sql; try_sql; log_sql; use_sql; binary; ceil_floor; function_fallback_sql; func; format_args; too_wide; format_time; expressions; op_expressions; naked_property; tag_sql; token_sql; userdefinedfunction_sql; joinhint_sql; kwarg_sql; when_sql; whens_sql; merge_sql; tochar_sql; tonumber_sql; dictproperty_sql; dictrange_sql; dictsubproperty_sql; duplicatekeyproperty_sql; uniquekeyproperty_sql; distributedbyproperty_sql; oncluster_sql; clusteredbyproperty_sql; anyvalue_sql; querytransform_sql; indexconstraintoption_sql; checkcolumnconstraint_sql; indexcolumnconstraint_sql; nvl2_sql; comprehension_sql; columnprefix_sql; opclass_sql; predict_sql; generateembedding_sql; generatetext_sql; generatetable_sql; generatebool_sql; generateint_sql; generatedouble_sql; mltranslate_sql; mlforecast_sql; aiforecast_sql; featuresattime_sql; vectorsearch_sql; forin_sql; refresh_sql; toarray_sql; tsordstotime_sql; tsordstotimestamp_sql; tsordstodatetime_sql; tsordstodate_sql; unixdate_sql; lastday_sql; dateadd_sql; arrayany_sql; struct_sql; partitionrange_sql; truncatetable_sql; convert_sql; copyparameter_sql; credentials_sql; copy_sql; semicolon_sql; datadeletionproperty_sql; maskingpolicycolumnconstraint_sql; gapfill_sql; scope_resolution; scoperesolution_sql; parsejson_sql; rand_sql; changes_sql; pad_sql; summarize_sql; explodinggenerateseries_sql; converttimezone_sql; json_sql; jsonvalue_sql; skipjsoncolumn_sql; conditionalinsert_sql; multitableinserts_sql; oncondition_sql; jsonextractquote_sql; jsonexists_sql; arrayagg_sql; slice_sql; apply_sql; grant_sql; revoke_sql; grantprivilege_sql; grantprincipal_sql; columns_sql; overlay_sql; todouble_sql; string_sql; median_sql; overflowtruncatebehavior_sql; unixseconds_sql; arraysize_sql; attach_sql; detach_sql; attachoption_sql; watermarkcolumnconstraint_sql; encodeproperty_sql; includeproperty_sql; xmlelement_sql; xmlkeyvalueoption_sql; partitionbyrangeproperty_sql; partitionbyrangepropertydynamic_sql; unpivotcolumns_sql; analyzesample_sql; analyzestatistics_sql; analyzehistogram_sql; analyzedelete_sql; analyzelistchainedrows_sql; analyzevalidate_sql; analyze_sql; xmltable_sql; xmlnamespace_sql; export_sql; declare_sql; declareitem_sql; recursivewithsearch_sql; parameterizedagg_sql; anonymousaggfunc_sql; combinedaggfunc_sql; combinedparameterizedagg_sql; show_sql; install_sql; get_put_sql; translatecharacters_sql; decodecase_sql; semanticview_sql; getextract_sql; datefromunixdate_sql; space_sql; buildproperty_sql; refreshtriggerproperty_sql; modelattribute_sql; directorystage_sql; uuid_sql; initcap_sql; localtime_sql; localtimestamp_sql; weekstart_sql; chr_sql; block_sql; storedprocedure_sql; ifblock_sql; whileblock_sql; execute_sql; executesql_sql; altermodifysqlsecurity_sql; usingproperty_sql; renameindex_sql