Edit on GitHub

sqlglot.generators.oracle

View Source

  1from __future__ import annotations
  2
  3from sqlglot import exp, generator, transforms
  4from sqlglot.dialects.dialect import (
  5    groupconcat_sql,
  6    no_ilike_sql,
  7    nth_value_from_sql,
  8    rename_func,
  9    strposition_sql,
 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    CAST_TO_INT_ROUNDS = 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    UNPIVOT_ALIASES_ARE_IDENTIFIERS = False
 43    PIVOT_ALIAS_WITH_AS = False
 44
 45    AFTER_HAVING_MODIFIER_TRANSFORMS = generator.AFTER_HAVING_MODIFIER_TRANSFORMS
 46
 47    TYPE_MAPPING = {
 48        **generator.Generator.TYPE_MAPPING,
 49        exp.DType.BLOB: "BLOB",
 50        exp.DType.TINYINT: "SMALLINT",
 51        exp.DType.SMALLINT: "SMALLINT",
 52        exp.DType.INT: "INT",
 53        exp.DType.BIGINT: "INT",
 54        exp.DType.DECIMAL: "NUMBER",
 55        exp.DType.DOUBLE: "DOUBLE PRECISION",
 56        exp.DType.VARCHAR: "VARCHAR2",
 57        exp.DType.NVARCHAR: "NVARCHAR2",
 58        exp.DType.NCHAR: "NCHAR",
 59        exp.DType.TEXT: "CLOB",
 60        exp.DType.TIMETZ: "TIME",
 61        exp.DType.TIMESTAMPNTZ: "TIMESTAMP",
 62        exp.DType.TIMESTAMPTZ: "TIMESTAMP",
 63        exp.DType.BINARY: "BLOB",
 64        exp.DType.VARBINARY: "BLOB",
 65        exp.DType.ROWVERSION: "BLOB",
 66    }
 67
 68    TRANSFORMS = {
 69        **generator.Generator.TRANSFORMS,
 70        exp.Pivot: transforms.preprocess([transforms.unqualify_pivot_fields]),
 71        exp.GroupConcat: lambda self, e: groupconcat_sql(self, e, on_overflow=True),
 72        exp.DateStrToDate: lambda self, e: self.func(
 73            "TO_DATE", e.this, exp.Literal.string("YYYY-MM-DD")
 74        ),
 75        exp.DateTrunc: lambda self, e: self.func("TRUNC", e.this, e.unit),
 76        exp.EuclideanDistance: rename_func("L2_DISTANCE"),
 77        exp.ILike: no_ilike_sql,
 78        exp.LogicalOr: rename_func("MAX"),
 79        exp.LogicalAnd: rename_func("MIN"),
 80        exp.Mod: rename_func("MOD"),
 81        exp.NthValue: nth_value_from_sql,
 82        exp.Rand: rename_func("DBMS_RANDOM.VALUE"),
 83        exp.Select: transforms.preprocess(
 84            [
 85                transforms.eliminate_distinct_on,
 86                transforms.eliminate_qualify,
 87            ]
 88        ),
 89        exp.StrPosition: lambda self, e: strposition_sql(
 90            self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
 91        ),
 92        exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
 93        exp.StrToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e)),
 94        exp.Subquery: lambda self, e: self.subquery_sql(e, sep=" "),
 95        exp.Substring: rename_func("SUBSTR"),
 96        exp.Table: lambda self, e: self.table_sql(e, sep=" "),
 97        exp.TableSample: lambda self, e: self.tablesample_sql(e),
 98        exp.TemporaryProperty: lambda _, e: f"{e.name or 'GLOBAL'} TEMPORARY",
 99        exp.TimeToStr: lambda self, e: self.func("TO_CHAR", e.this, self.format_time(e)),
100        exp.ToChar: lambda self, e: self.function_fallback_sql(e),
101        exp.Trim: _trim_sql,
102        exp.Unicode: lambda self, e: f"ASCII(UNISTR({self.sql(e.this)}))",
103        exp.UnixToTime: lambda self, e: (
104            f"TO_DATE('1970-01-01', 'YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)"
105        ),
106        exp.UtcTimestamp: rename_func("UTC_TIMESTAMP"),
107        exp.UtcTime: rename_func("UTC_TIME"),
108        exp.Systimestamp: lambda self, e: "SYSTIMESTAMP",
109        exp.TableSpaceProperty: lambda self, e: f"TABLESPACE {self.sql(e, 'this')}",
110    }
111
112    PROPERTIES_LOCATION = {
113        **generator.Generator.PROPERTIES_LOCATION,
114        exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
115        exp.TableSpaceProperty: exp.Properties.Location.POST_SCHEMA,
116        exp.PhysicalProperty: exp.Properties.Location.POST_SCHEMA,
117        exp.StorageProperty: exp.Properties.Location.POST_SCHEMA,
118    }
119
120    def physicalproperty_sql(self, expression: exp.PhysicalProperty) -> str:
121        value = self.sql(expression, "value")
122        return f"{expression.name}{f' {value}' if value else ''}"
123
124    def storageproperty_sql(self, expression: exp.StorageProperty) -> str:
125        return f"STORAGE ({self.expressions(expression, sep=' ', flat=True)})"
126
127    def currenttimestamp_sql(self, expression: exp.CurrentTimestamp) -> str:
128        if expression.args.get("sysdate"):
129            return "SYSDATE"
130
131        this = expression.this
132        return self.func("CURRENT_TIMESTAMP", this) if this else "CURRENT_TIMESTAMP"
133
134    def version_sql(self, expression: exp.Version) -> str:
135        if expression.text("kind") == "AS OF":
136            value = expression.expression
137            value_sql = (
138                self.func("TO_TIMESTAMP", value, exp.Literal.string("YYYY-MM-DD HH24:MI:SS.FF6"))
139                if expression.name == "TIMESTAMP" and value.is_string
140                else self.sql(value)
141            )
142            return f"AS OF {expression.name} {value_sql}"
143        return super().version_sql(expression)
144
145    def offset_sql(self, expression: exp.Offset) -> str:
146        return f"{super().offset_sql(expression)} ROWS"
147
148    def add_column_sql(self, expression: exp.Expr) -> str:
149        return f"ADD {self.sql(expression)}"
150
151    def queryoption_sql(self, expression: exp.QueryOption) -> str:
152        option = self.sql(expression, "this")
153        value = self.sql(expression, "expression")
154        value = f" CONSTRAINT {value}" if value else ""
155
156        return f"{option}{value}"
157
158    def coalesce_sql(self, expression: exp.Coalesce) -> str:
159        func_name = "NVL" if expression.args.get("is_nvl") else "COALESCE"
160        return rename_func(func_name)(self, expression)
161
162    def into_sql(self, expression: exp.Into) -> str:
163        into = "INTO" if not expression.args.get("bulk_collect") else "BULK COLLECT INTO"
164        if expression.this:
165            return f"{self.seg(into)} {self.sql(expression, 'this')}"
166
167        return f"{self.seg(into)} {self.expressions(expression)}"
168
169    def hint_sql(self, expression: exp.Hint) -> str:
170        expressions = []
171
172        for hint in expression.expressions:
173            if isinstance(hint, exp.Anonymous):
174                formatted_args = self.format_args(*hint.expressions, sep=" ")
175                expressions.append(f"{self.sql(hint, 'this')}({formatted_args})")
176            else:
177                expressions.append(self.sql(hint))
178
179        return f" /*+ {self.expressions(sqls=expressions, sep=self.QUERY_HINT_SEP).strip()} */"
180
181    def isascii_sql(self, expression: exp.IsAscii) -> str:
182        return f"NVL(REGEXP_LIKE({self.sql(expression.this)}, '^[' || CHR(1) || '-' || CHR(127) || ']*$'), TRUE)"
183
184    def interval_sql(self, expression: exp.Interval) -> str:
185        return f"{'INTERVAL ' if isinstance(expression.this, exp.Literal) else ''}{self.sql(expression, 'this')} {self.sql(expression, 'unit')}"
186
187    def tonumber_sql(self, expression: exp.ToNumber) -> str:
188        this = self.sql(expression, "this")
189        default = self.sql(expression, "default")
190        if default:
191            this = f"{this} DEFAULT {default} ON CONVERSION ERROR"
192
193        return self.func(
194            "TO_NUMBER", this, expression.args.get("format"), expression.args.get("nlsparam")
195        )
196
197    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
198        param_constraint = expression.find(exp.InOutColumnConstraint)
199        if param_constraint:
200            sep = f" {self.sql(param_constraint)} "
201            param_constraint.pop()
202        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    CAST_TO_INT_ROUNDS = True
 31    JOIN_HINTS = False
 32    TABLE_HINTS = False
 33    DATA_TYPE_SPECIFIERS_ALLOWED = True
 34    ALTER_TABLE_INCLUDE_COLUMN_KEYWORD = False
 35    LIMIT_FETCH = "FETCH"
 36    TABLESAMPLE_KEYWORDS = "SAMPLE"
 37    LAST_DAY_SUPPORTS_DATE_PART = False
 38    SUPPORTS_SELECT_INTO = True
 39    TZ_TO_WITH_TIME_ZONE = True
 40    SUPPORTS_WINDOW_EXCLUDE = True
 41    QUERY_HINT_SEP = " "
 42    SUPPORTS_DECODE_CASE = True
 43    UNPIVOT_ALIASES_ARE_IDENTIFIERS = False
 44    PIVOT_ALIAS_WITH_AS = False
 45
 46    AFTER_HAVING_MODIFIER_TRANSFORMS = generator.AFTER_HAVING_MODIFIER_TRANSFORMS
 47
 48    TYPE_MAPPING = {
 49        **generator.Generator.TYPE_MAPPING,
 50        exp.DType.BLOB: "BLOB",
 51        exp.DType.TINYINT: "SMALLINT",
 52        exp.DType.SMALLINT: "SMALLINT",
 53        exp.DType.INT: "INT",
 54        exp.DType.BIGINT: "INT",
 55        exp.DType.DECIMAL: "NUMBER",
 56        exp.DType.DOUBLE: "DOUBLE PRECISION",
 57        exp.DType.VARCHAR: "VARCHAR2",
 58        exp.DType.NVARCHAR: "NVARCHAR2",
 59        exp.DType.NCHAR: "NCHAR",
 60        exp.DType.TEXT: "CLOB",
 61        exp.DType.TIMETZ: "TIME",
 62        exp.DType.TIMESTAMPNTZ: "TIMESTAMP",
 63        exp.DType.TIMESTAMPTZ: "TIMESTAMP",
 64        exp.DType.BINARY: "BLOB",
 65        exp.DType.VARBINARY: "BLOB",
 66        exp.DType.ROWVERSION: "BLOB",
 67    }
 68
 69    TRANSFORMS = {
 70        **generator.Generator.TRANSFORMS,
 71        exp.Pivot: transforms.preprocess([transforms.unqualify_pivot_fields]),
 72        exp.GroupConcat: lambda self, e: groupconcat_sql(self, e, on_overflow=True),
 73        exp.DateStrToDate: lambda self, e: self.func(
 74            "TO_DATE", e.this, exp.Literal.string("YYYY-MM-DD")
 75        ),
 76        exp.DateTrunc: lambda self, e: self.func("TRUNC", e.this, e.unit),
 77        exp.EuclideanDistance: rename_func("L2_DISTANCE"),
 78        exp.ILike: no_ilike_sql,
 79        exp.LogicalOr: rename_func("MAX"),
 80        exp.LogicalAnd: rename_func("MIN"),
 81        exp.Mod: rename_func("MOD"),
 82        exp.NthValue: nth_value_from_sql,
 83        exp.Rand: rename_func("DBMS_RANDOM.VALUE"),
 84        exp.Select: transforms.preprocess(
 85            [
 86                transforms.eliminate_distinct_on,
 87                transforms.eliminate_qualify,
 88            ]
 89        ),
 90        exp.StrPosition: lambda self, e: strposition_sql(
 91            self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
 92        ),
 93        exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
 94        exp.StrToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e)),
 95        exp.Subquery: lambda self, e: self.subquery_sql(e, sep=" "),
 96        exp.Substring: rename_func("SUBSTR"),
 97        exp.Table: lambda self, e: self.table_sql(e, sep=" "),
 98        exp.TableSample: lambda self, e: self.tablesample_sql(e),
 99        exp.TemporaryProperty: lambda _, e: f"{e.name or 'GLOBAL'} TEMPORARY",
100        exp.TimeToStr: lambda self, e: self.func("TO_CHAR", e.this, self.format_time(e)),
101        exp.ToChar: lambda self, e: self.function_fallback_sql(e),
102        exp.Trim: _trim_sql,
103        exp.Unicode: lambda self, e: f"ASCII(UNISTR({self.sql(e.this)}))",
104        exp.UnixToTime: lambda self, e: (
105            f"TO_DATE('1970-01-01', 'YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)"
106        ),
107        exp.UtcTimestamp: rename_func("UTC_TIMESTAMP"),
108        exp.UtcTime: rename_func("UTC_TIME"),
109        exp.Systimestamp: lambda self, e: "SYSTIMESTAMP",
110        exp.TableSpaceProperty: lambda self, e: f"TABLESPACE {self.sql(e, 'this')}",
111    }
112
113    PROPERTIES_LOCATION = {
114        **generator.Generator.PROPERTIES_LOCATION,
115        exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
116        exp.TableSpaceProperty: exp.Properties.Location.POST_SCHEMA,
117        exp.PhysicalProperty: exp.Properties.Location.POST_SCHEMA,
118        exp.StorageProperty: exp.Properties.Location.POST_SCHEMA,
119    }
120
121    def physicalproperty_sql(self, expression: exp.PhysicalProperty) -> str:
122        value = self.sql(expression, "value")
123        return f"{expression.name}{f' {value}' if value else ''}"
124
125    def storageproperty_sql(self, expression: exp.StorageProperty) -> str:
126        return f"STORAGE ({self.expressions(expression, sep=' ', flat=True)})"
127
128    def currenttimestamp_sql(self, expression: exp.CurrentTimestamp) -> str:
129        if expression.args.get("sysdate"):
130            return "SYSDATE"
131
132        this = expression.this
133        return self.func("CURRENT_TIMESTAMP", this) if this else "CURRENT_TIMESTAMP"
134
135    def version_sql(self, expression: exp.Version) -> str:
136        if expression.text("kind") == "AS OF":
137            value = expression.expression
138            value_sql = (
139                self.func("TO_TIMESTAMP", value, exp.Literal.string("YYYY-MM-DD HH24:MI:SS.FF6"))
140                if expression.name == "TIMESTAMP" and value.is_string
141                else self.sql(value)
142            )
143            return f"AS OF {expression.name} {value_sql}"
144        return super().version_sql(expression)
145
146    def offset_sql(self, expression: exp.Offset) -> str:
147        return f"{super().offset_sql(expression)} ROWS"
148
149    def add_column_sql(self, expression: exp.Expr) -> str:
150        return f"ADD {self.sql(expression)}"
151
152    def queryoption_sql(self, expression: exp.QueryOption) -> str:
153        option = self.sql(expression, "this")
154        value = self.sql(expression, "expression")
155        value = f" CONSTRAINT {value}" if value else ""
156
157        return f"{option}{value}"
158
159    def coalesce_sql(self, expression: exp.Coalesce) -> str:
160        func_name = "NVL" if expression.args.get("is_nvl") else "COALESCE"
161        return rename_func(func_name)(self, expression)
162
163    def into_sql(self, expression: exp.Into) -> str:
164        into = "INTO" if not expression.args.get("bulk_collect") else "BULK COLLECT INTO"
165        if expression.this:
166            return f"{self.seg(into)} {self.sql(expression, 'this')}"
167
168        return f"{self.seg(into)} {self.expressions(expression)}"
169
170    def hint_sql(self, expression: exp.Hint) -> str:
171        expressions = []
172
173        for hint in expression.expressions:
174            if isinstance(hint, exp.Anonymous):
175                formatted_args = self.format_args(*hint.expressions, sep=" ")
176                expressions.append(f"{self.sql(hint, 'this')}({formatted_args})")
177            else:
178                expressions.append(self.sql(hint))
179
180        return f" /*+ {self.expressions(sqls=expressions, sep=self.QUERY_HINT_SEP).strip()} */"
181
182    def isascii_sql(self, expression: exp.IsAscii) -> str:
183        return f"NVL(REGEXP_LIKE({self.sql(expression.this)}, '^[' || CHR(1) || '-' || CHR(127) || ']*$'), TRUE)"
184
185    def interval_sql(self, expression: exp.Interval) -> str:
186        return f"{'INTERVAL ' if isinstance(expression.this, exp.Literal) else ''}{self.sql(expression, 'this')} {self.sql(expression, 'unit')}"
187
188    def tonumber_sql(self, expression: exp.ToNumber) -> str:
189        this = self.sql(expression, "this")
190        default = self.sql(expression, "default")
191        if default:
192            this = f"{this} DEFAULT {default} ON CONVERSION ERROR"
193
194        return self.func(
195            "TO_NUMBER", this, expression.args.get("format"), expression.args.get("nlsparam")
196        )
197
198    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
199        param_constraint = expression.find(exp.InOutColumnConstraint)
200        if param_constraint:
201            sep = f" {self.sql(param_constraint)} "
202            param_constraint.pop()
203        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

CAST_TO_INT_ROUNDS = 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

UNPIVOT_ALIASES_ARE_IDENTIFIERS = False

PIVOT_ALIAS_WITH_AS = False

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.AggregateKeyProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <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.CalledOnNullInputProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <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.ClusterProperty'>: <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.properties.PhysicalProperty'>: <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.StorageProperty'>: <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.TableSpaceProperty'>: <PropertiesLocation.POST_SCHEMA: 'POST_SCHEMA'>, <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 physicalproperty_sql(self, expression: sqlglot.expressions.properties.PhysicalProperty) -> str: View Source

121    def physicalproperty_sql(self, expression: exp.PhysicalProperty) -> str:
122        value = self.sql(expression, "value")
123        return f"{expression.name}{f' {value}' if value else ''}"

def storageproperty_sql(self, expression: sqlglot.expressions.properties.StorageProperty) -> str: View Source

125    def storageproperty_sql(self, expression: exp.StorageProperty) -> str:
126        return f"STORAGE ({self.expressions(expression, sep=' ', flat=True)})"

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

128    def currenttimestamp_sql(self, expression: exp.CurrentTimestamp) -> str:
129        if expression.args.get("sysdate"):
130            return "SYSDATE"
131
132        this = expression.this
133        return self.func("CURRENT_TIMESTAMP", this) if this else "CURRENT_TIMESTAMP"

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

135    def version_sql(self, expression: exp.Version) -> str:
136        if expression.text("kind") == "AS OF":
137            value = expression.expression
138            value_sql = (
139                self.func("TO_TIMESTAMP", value, exp.Literal.string("YYYY-MM-DD HH24:MI:SS.FF6"))
140                if expression.name == "TIMESTAMP" and value.is_string
141                else self.sql(value)
142            )
143            return f"AS OF {expression.name} {value_sql}"
144        return super().version_sql(expression)

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

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

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

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

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

152    def queryoption_sql(self, expression: exp.QueryOption) -> str:
153        option = self.sql(expression, "this")
154        value = self.sql(expression, "expression")
155        value = f" CONSTRAINT {value}" if value else ""
156
157        return f"{option}{value}"

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

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

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

163    def into_sql(self, expression: exp.Into) -> str:
164        into = "INTO" if not expression.args.get("bulk_collect") else "BULK COLLECT INTO"
165        if expression.this:
166            return f"{self.seg(into)} {self.sql(expression, 'this')}"
167
168        return f"{self.seg(into)} {self.expressions(expression)}"

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

170    def hint_sql(self, expression: exp.Hint) -> str:
171        expressions = []
172
173        for hint in expression.expressions:
174            if isinstance(hint, exp.Anonymous):
175                formatted_args = self.format_args(*hint.expressions, sep=" ")
176                expressions.append(f"{self.sql(hint, 'this')}({formatted_args})")
177            else:
178                expressions.append(self.sql(hint))
179
180        return f" /*+ {self.expressions(sqls=expressions, sep=self.QUERY_HINT_SEP).strip()} */"

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

182    def isascii_sql(self, expression: exp.IsAscii) -> str:
183        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

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

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

188    def tonumber_sql(self, expression: exp.ToNumber) -> str:
189        this = self.sql(expression, "this")
190        default = self.sql(expression, "default")
191        if default:
192            this = f"{this} DEFAULT {default} ON CONVERSION ERROR"
193
194        return self.func(
195            "TO_NUMBER", this, expression.args.get("format"), expression.args.get("nlsparam")
196        )

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

198    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
199        param_constraint = expression.find(exp.InOutColumnConstraint)
200        if param_constraint:
201            sep = f" {self.sql(param_constraint)} "
202            param_constraint.pop()
203        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; AUTO_REFRESH_BARE_INTERVALS; LIMIT_ONLY_LITERALS; RENAME_TABLE_WITH_DB; GROUPINGS_SEP; SUPPORTS_GROUPING_SETS_AS_SUFFIX; INDEX_ON; INOUT_SEPARATOR; DIRECTED_JOINS; QUERY_HINTS; IS_BOOL_ALLOWED; SAFE_INT_DIVISION; DUPLICATE_KEY_UPDATE_WITH_SET; LIMIT_IS_TOP; RETURNING_END; EXTRACT_ALLOWS_QUOTES; NVL2_SUPPORTED; VALUES_AS_TABLE; UNNEST_WITH_ORDINALITY; 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; HISTORICAL_DATA_POST_ALIAS; COLLATE_IS_FUNC; ENSURE_BOOLS; CTE_RECURSIVE_KEYWORD_REQUIRED; SUPPORTS_SINGLE_ARG_CONCAT; SUPPORTS_TABLE_ALIAS_COLUMNS; SUPPORTS_NAMED_CTE_COLUMNS; JSON_KEY_VALUE_PAIR_SEP; INSERT_OVERWRITE; SUPPORTS_UNLOGGED_TABLES; SUPPORTS_CREATE_TABLE_LIKE; SUPPORTS_MODIFY_COLUMN; SUPPORTS_CHANGE_COLUMN; SUPPORTS_ALTER_COLUMN_NULLABILITY; SUPPORTS_ALTER_COLUMN_IF_EXISTS; LIKE_PROPERTY_INSIDE_SCHEMA; MULTI_ARG_DISTINCT; JSON_TYPE_REQUIRED_FOR_EXTRACTION; JSON_PATH_BRACKETED_KEY_SUPPORTED; JSON_PATH_SINGLE_QUOTE_ESCAPE; JSON_PATH_KEY_QUOTED_FORCES_BRACKETS; SUPPORTED_JSON_PATH_PARTS; CAN_IMPLEMENT_ARRAY_ANY; SUPPORTS_TO_NUMBER; SET_OP_MODIFIERS; SET_OP_LIMITS; SET_OP_PARENTHESIZED_OPERANDS; COPY_PARAMS_ARE_WRAPPED; COPY_PARAMS_EQ_REQUIRED; COPY_HAS_INTO_KEYWORD; UNICODE_SUBSTITUTE; STAR_EXCEPT; HEX_FUNC; BYTE_STRING_FUNCTION; 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; TYPE_PARAM_SETTINGS; 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; MOD_OPERATOR; MOD_PAREN_PARENT_TYPES; ALTER_PARTITION_OPTIONS; 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_param_bound_limiter; datatype_sql; directory_sql; delete_sql; drop_sql; set_operation; set_operations; fetch_sql; limitoptions_sql; filter_sql; indexparameters_sql; index_sql; dynamicidentifier_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; lockingstatement_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; 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; clusterproperty_sql; distribute_sql; sort_sql; ordered_sql; matchrecognizemeasure_sql; matchrecognize_sql; query_modifiers; options_modifier; forclause_sql; 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; partitionbyexcluding_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; timeserieskey_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; fromiso8601date_sql; fromiso8601timestamp_sql; fromiso8601timestampnanos_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; strtodate_sql; parsedatetime_sql; currentdate_sql; collate_sql; command_sql; comment_sql; mergetreettlaction_sql; mergetreettl_sql; transaction_sql; commit_sql; rollback_sql; altercolumn_sql; modifycolumn_sql; alterindex_sql; alterdiststyle_sql; altersortkey_sql; alterrename_sql; renamecolumn_sql; alterset_sql; alter_sql; altersession_sql; droppartition_sql; dropprimarykey_sql; addconstraint_sql; replacecolumns_sql; addpartition_sql; distinct_sql; ignorenulls_sql; respectnulls_sql; havingmax_sql; intdiv_sql; dpipe_sql; div_sql; safedivide_sql; overlaps_sql; distance_sql; distancend_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; function_name; func; format_args; too_wide; format_time; expressions; op_expressions; naked_property; tag_sql; token_sql; userdefinedfunction_sql; macrooverloads_sql; macrooverload_sql; joinhint_sql; kwarg_sql; when_sql; whens_sql; merge_sql; tochar_sql; dictproperty_sql; dictrange_sql; dictsubproperty_sql; aggregatekeyproperty_sql; duplicatekeyproperty_sql; uniquekeyproperty_sql; distributedbyproperty_sql; oncluster_sql; clusteredbyproperty_sql; anyvalue_sql; querytransform_sql; indexconstraintoption_sql; checkcolumnconstraint_sql; indexcolumnconstraint_sql; nvl2_sql; nthvalue_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; arrayinsert_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; arraysort_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; liststage_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_name; weekstart_sql; chr_sql; weightstring_sql; block_sql; functionspecification_sql; storedprocedure_sql; ifblock_sql; casestatement_sql; whileblock_sql; loopblock_sql; repeatblock_sql; leave_sql; iterate_sql; execute_sql; executesql_sql; altermodifysqlsecurity_sql; usingproperty_sql; renameindex_sql