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    groupconcat_sql,
  7    no_ilike_sql,
  8    rename_func,
  9    strposition_sql,
 10    to_number_with_nls_param,
 11    trim_sql,
 12)
 13
 14
 15def _trim_sql(self: OracleGenerator, expression: exp.Trim) -> str:
 16    position = expression.args.get("position")
 17
 18    if position and position.upper() in ("LEADING", "TRAILING"):
 19        return self.trim_sql(expression)
 20
 21    return trim_sql(self, expression)
 22
 23
 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.GroupConcat: lambda self, e: groupconcat_sql(self, e, on_overflow=True),
 69        exp.DateStrToDate: lambda self, e: self.func(
 70            "TO_DATE", e.this, exp.Literal.string("YYYY-MM-DD")
 71        ),
 72        exp.DateTrunc: lambda self, e: self.func("TRUNC", e.this, e.unit),
 73        exp.EuclideanDistance: rename_func("L2_DISTANCE"),
 74        exp.ILike: no_ilike_sql,
 75        exp.LogicalOr: rename_func("MAX"),
 76        exp.LogicalAnd: rename_func("MIN"),
 77        exp.Mod: rename_func("MOD"),
 78        exp.Rand: rename_func("DBMS_RANDOM.VALUE"),
 79        exp.Select: transforms.preprocess(
 80            [
 81                transforms.eliminate_distinct_on,
 82                transforms.eliminate_qualify,
 83            ]
 84        ),
 85        exp.StrPosition: lambda self, e: strposition_sql(
 86            self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
 87        ),
 88        exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
 89        exp.StrToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e)),
 90        exp.Subquery: lambda self, e: self.subquery_sql(e, sep=" "),
 91        exp.Substring: rename_func("SUBSTR"),
 92        exp.Table: lambda self, e: self.table_sql(e, sep=" "),
 93        exp.TableSample: lambda self, e: self.tablesample_sql(e),
 94        exp.TemporaryProperty: lambda _, e: f"{e.name or 'GLOBAL'} TEMPORARY",
 95        exp.TimeToStr: lambda self, e: self.func("TO_CHAR", e.this, self.format_time(e)),
 96        exp.ToChar: lambda self, e: self.function_fallback_sql(e),
 97        exp.ToNumber: to_number_with_nls_param,
 98        exp.Trim: _trim_sql,
 99        exp.Unicode: lambda self, e: f"ASCII(UNISTR({self.sql(e.this)}))",
100        exp.UnixToTime: lambda self, e: (
101            f"TO_DATE('1970-01-01', 'YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)"
102        ),
103        exp.UtcTimestamp: rename_func("UTC_TIMESTAMP"),
104        exp.UtcTime: rename_func("UTC_TIME"),
105        exp.Systimestamp: lambda self, e: "SYSTIMESTAMP",
106    }
107
108    PROPERTIES_LOCATION = {
109        **generator.Generator.PROPERTIES_LOCATION,
110        exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
111    }
112
113    def currenttimestamp_sql(self, expression: exp.CurrentTimestamp) -> str:
114        if expression.args.get("sysdate"):
115            return "SYSDATE"
116
117        this = expression.this
118        return self.func("CURRENT_TIMESTAMP", this) if this else "CURRENT_TIMESTAMP"
119
120    def offset_sql(self, expression: exp.Offset) -> str:
121        return f"{super().offset_sql(expression)} ROWS"
122
123    def add_column_sql(self, expression: exp.Expr) -> str:
124        return f"ADD {self.sql(expression)}"
125
126    def queryoption_sql(self, expression: exp.QueryOption) -> str:
127        option = self.sql(expression, "this")
128        value = self.sql(expression, "expression")
129        value = f" CONSTRAINT {value}" if value else ""
130
131        return f"{option}{value}"
132
133    def coalesce_sql(self, expression: exp.Coalesce) -> str:
134        func_name = "NVL" if expression.args.get("is_nvl") else "COALESCE"
135        return rename_func(func_name)(self, expression)
136
137    def into_sql(self, expression: exp.Into) -> str:
138        into = "INTO" if not expression.args.get("bulk_collect") else "BULK COLLECT INTO"
139        if expression.this:
140            return f"{self.seg(into)} {self.sql(expression, 'this')}"
141
142        return f"{self.seg(into)} {self.expressions(expression)}"
143
144    def hint_sql(self, expression: exp.Hint) -> str:
145        expressions = []
146
147        for hint in expression.expressions:
148            if isinstance(hint, exp.Anonymous):
149                formatted_args = self.format_args(*hint.expressions, sep=" ")
150                expressions.append(f"{self.sql(hint, 'this')}({formatted_args})")
151            else:
152                expressions.append(self.sql(hint))
153
154        return f" /*+ {self.expressions(sqls=expressions, sep=self.QUERY_HINT_SEP).strip()} */"
155
156    def isascii_sql(self, expression: exp.IsAscii) -> str:
157        return f"NVL(REGEXP_LIKE({self.sql(expression.this)}, '^[' || CHR(1) || '-' || CHR(127) || ']*$'), TRUE)"
158
159    def interval_sql(self, expression: exp.Interval) -> str:
160        return f"{'INTERVAL ' if isinstance(expression.this, exp.Literal) else ''}{self.sql(expression, 'this')} {self.sql(expression, 'unit')}"
161
162    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
163        param_constraint = expression.find(exp.InOutColumnConstraint)
164        if param_constraint:
165            sep = f" {self.sql(param_constraint)} "
166            param_constraint.pop()
167        return super().columndef_sql(expression, sep)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

160    def interval_sql(self, expression: exp.Interval) -> str:
161        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

163    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
164        param_constraint = expression.find(exp.InOutColumnConstraint)
165        if param_constraint:
166            sep = f" {self.sql(param_constraint)} "
167            param_constraint.pop()
168        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; SUPPORTS_NAMED_CTE_COLUMNS; UNPIVOT_ALIASES_ARE_IDENTIFIERS; JSON_KEY_VALUE_PAIR_SEP; INSERT_OVERWRITE; SUPPORTS_UNLOGGED_TABLES; SUPPORTS_CREATE_TABLE_LIKE; SUPPORTS_MODIFY_COLUMN; SUPPORTS_CHANGE_COLUMN; 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; 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; 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; 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; modifycolumn_sql; alterindex_sql; alterdiststyle_sql; altersortkey_sql; alterrename_sql; renamecolumn_sql; alterset_sql; alter_sql; altersession_sql; droppartition_sql; dropprimarykey_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