Edit on GitHub

sqlglot.dialects.sqlite

  1from __future__ import annotations
  2
  3from sqlglot import exp, generator, parser, tokens, transforms
  4from sqlglot.dialects.dialect import (
  5    Dialect,
  6    arrow_json_extract_scalar_sql,
  7    arrow_json_extract_sql,
  8    concat_to_dpipe_sql,
  9    count_if_to_sum,
 10    no_ilike_sql,
 11    no_pivot_sql,
 12    no_tablesample_sql,
 13    no_trycast_sql,
 14    rename_func,
 15)
 16from sqlglot.tokens import TokenType
 17
 18
 19def _date_add_sql(self: generator.Generator, expression: exp.DateAdd) -> str:
 20    modifier = expression.expression
 21    modifier = modifier.name if modifier.is_string else self.sql(modifier)
 22    unit = expression.args.get("unit")
 23    modifier = f"'{modifier} {unit.name}'" if unit else f"'{modifier}'"
 24    return self.func("DATE", expression.this, modifier)
 25
 26
 27def _transform_create(expression: exp.Expression) -> exp.Expression:
 28    """Move primary key to a column and enforce auto_increment on primary keys."""
 29    schema = expression.this
 30
 31    if isinstance(expression, exp.Create) and isinstance(schema, exp.Schema):
 32        defs = {}
 33        primary_key = None
 34
 35        for e in schema.expressions:
 36            if isinstance(e, exp.ColumnDef):
 37                defs[e.name] = e
 38            elif isinstance(e, exp.PrimaryKey):
 39                primary_key = e
 40
 41        if primary_key and len(primary_key.expressions) == 1:
 42            column = defs[primary_key.expressions[0].name]
 43            column.append(
 44                "constraints", exp.ColumnConstraint(kind=exp.PrimaryKeyColumnConstraint())
 45            )
 46            schema.expressions.remove(primary_key)
 47        else:
 48            for column in defs.values():
 49                auto_increment = None
 50                for constraint in column.constraints.copy():
 51                    if isinstance(constraint.kind, exp.PrimaryKeyColumnConstraint):
 52                        break
 53                    if isinstance(constraint.kind, exp.AutoIncrementColumnConstraint):
 54                        auto_increment = constraint
 55                if auto_increment:
 56                    column.constraints.remove(auto_increment)
 57
 58    return expression
 59
 60
 61class SQLite(Dialect):
 62    class Tokenizer(tokens.Tokenizer):
 63        IDENTIFIERS = ['"', ("[", "]"), "`"]
 64        HEX_STRINGS = [("x'", "'"), ("X'", "'"), ("0x", ""), ("0X", "")]
 65
 66    class Parser(parser.Parser):
 67        FUNCTIONS = {
 68            **parser.Parser.FUNCTIONS,
 69            "EDITDIST3": exp.Levenshtein.from_arg_list,
 70        }
 71
 72    class Generator(generator.Generator):
 73        JOIN_HINTS = False
 74        TABLE_HINTS = False
 75
 76        TYPE_MAPPING = {
 77            **generator.Generator.TYPE_MAPPING,
 78            exp.DataType.Type.BOOLEAN: "INTEGER",
 79            exp.DataType.Type.TINYINT: "INTEGER",
 80            exp.DataType.Type.SMALLINT: "INTEGER",
 81            exp.DataType.Type.INT: "INTEGER",
 82            exp.DataType.Type.BIGINT: "INTEGER",
 83            exp.DataType.Type.FLOAT: "REAL",
 84            exp.DataType.Type.DOUBLE: "REAL",
 85            exp.DataType.Type.DECIMAL: "REAL",
 86            exp.DataType.Type.CHAR: "TEXT",
 87            exp.DataType.Type.NCHAR: "TEXT",
 88            exp.DataType.Type.VARCHAR: "TEXT",
 89            exp.DataType.Type.NVARCHAR: "TEXT",
 90            exp.DataType.Type.BINARY: "BLOB",
 91            exp.DataType.Type.VARBINARY: "BLOB",
 92        }
 93
 94        TOKEN_MAPPING = {
 95            TokenType.AUTO_INCREMENT: "AUTOINCREMENT",
 96        }
 97
 98        TRANSFORMS = {
 99            **generator.Generator.TRANSFORMS,
100            exp.Concat: concat_to_dpipe_sql,
101            exp.CountIf: count_if_to_sum,
102            exp.Create: transforms.preprocess([_transform_create]),
103            exp.CurrentDate: lambda *_: "CURRENT_DATE",
104            exp.CurrentTime: lambda *_: "CURRENT_TIME",
105            exp.CurrentTimestamp: lambda *_: "CURRENT_TIMESTAMP",
106            exp.DateAdd: _date_add_sql,
107            exp.DateStrToDate: lambda self, e: self.sql(e, "this"),
108            exp.ILike: no_ilike_sql,
109            exp.JSONExtract: arrow_json_extract_sql,
110            exp.JSONExtractScalar: arrow_json_extract_scalar_sql,
111            exp.JSONBExtract: arrow_json_extract_sql,
112            exp.JSONBExtractScalar: arrow_json_extract_scalar_sql,
113            exp.Levenshtein: rename_func("EDITDIST3"),
114            exp.LogicalOr: rename_func("MAX"),
115            exp.LogicalAnd: rename_func("MIN"),
116            exp.Pivot: no_pivot_sql,
117            exp.SafeConcat: concat_to_dpipe_sql,
118            exp.Select: transforms.preprocess(
119                [transforms.eliminate_distinct_on, transforms.eliminate_qualify]
120            ),
121            exp.TableSample: no_tablesample_sql,
122            exp.TimeStrToTime: lambda self, e: self.sql(e, "this"),
123            exp.TryCast: no_trycast_sql,
124        }
125
126        PROPERTIES_LOCATION = {
127            k: exp.Properties.Location.UNSUPPORTED
128            for k, v in generator.Generator.PROPERTIES_LOCATION.items()
129        }
130
131        LIMIT_FETCH = "LIMIT"
132
133        def cast_sql(self, expression: exp.Cast) -> str:
134            if expression.is_type("date"):
135                return self.func("DATE", expression.this)
136
137            return super().cast_sql(expression)
138
139        def datediff_sql(self, expression: exp.DateDiff) -> str:
140            unit = expression.args.get("unit")
141            unit = unit.name.upper() if unit else "DAY"
142
143            sql = f"(JULIANDAY({self.sql(expression, 'this')}) - JULIANDAY({self.sql(expression, 'expression')}))"
144
145            if unit == "MONTH":
146                sql = f"{sql} / 30.0"
147            elif unit == "YEAR":
148                sql = f"{sql} / 365.0"
149            elif unit == "HOUR":
150                sql = f"{sql} * 24.0"
151            elif unit == "MINUTE":
152                sql = f"{sql} * 1440.0"
153            elif unit == "SECOND":
154                sql = f"{sql} * 86400.0"
155            elif unit == "MILLISECOND":
156                sql = f"{sql} * 86400000.0"
157            elif unit == "MICROSECOND":
158                sql = f"{sql} * 86400000000.0"
159            elif unit == "NANOSECOND":
160                sql = f"{sql} * 8640000000000.0"
161            else:
162                self.unsupported("DATEDIFF unsupported for '{unit}'.")
163
164            return f"CAST({sql} AS INTEGER)"
165
166        # https://www.sqlite.org/lang_aggfunc.html#group_concat
167        def groupconcat_sql(self, expression: exp.GroupConcat) -> str:
168            this = expression.this
169            distinct = expression.find(exp.Distinct)
170
171            if distinct:
172                this = distinct.expressions[0]
173                distinct_sql = "DISTINCT "
174            else:
175                distinct_sql = ""
176
177            if isinstance(expression.this, exp.Order):
178                self.unsupported("SQLite GROUP_CONCAT doesn't support ORDER BY.")
179                if expression.this.this and not distinct:
180                    this = expression.this.this
181
182            separator = expression.args.get("separator")
183            return f"GROUP_CONCAT({distinct_sql}{self.format_args(this, separator)})"
184
185        def least_sql(self, expression: exp.Least) -> str:
186            if len(expression.expressions) > 1:
187                return rename_func("MIN")(self, expression)
188
189            return self.expressions(expression)
190
191        def transaction_sql(self, expression: exp.Transaction) -> str:
192            this = expression.this
193            this = f" {this}" if this else ""
194            return f"BEGIN{this} TRANSACTION"
class SQLite(sqlglot.dialects.dialect.Dialect):
 62class SQLite(Dialect):
 63    class Tokenizer(tokens.Tokenizer):
 64        IDENTIFIERS = ['"', ("[", "]"), "`"]
 65        HEX_STRINGS = [("x'", "'"), ("X'", "'"), ("0x", ""), ("0X", "")]
 66
 67    class Parser(parser.Parser):
 68        FUNCTIONS = {
 69            **parser.Parser.FUNCTIONS,
 70            "EDITDIST3": exp.Levenshtein.from_arg_list,
 71        }
 72
 73    class Generator(generator.Generator):
 74        JOIN_HINTS = False
 75        TABLE_HINTS = False
 76
 77        TYPE_MAPPING = {
 78            **generator.Generator.TYPE_MAPPING,
 79            exp.DataType.Type.BOOLEAN: "INTEGER",
 80            exp.DataType.Type.TINYINT: "INTEGER",
 81            exp.DataType.Type.SMALLINT: "INTEGER",
 82            exp.DataType.Type.INT: "INTEGER",
 83            exp.DataType.Type.BIGINT: "INTEGER",
 84            exp.DataType.Type.FLOAT: "REAL",
 85            exp.DataType.Type.DOUBLE: "REAL",
 86            exp.DataType.Type.DECIMAL: "REAL",
 87            exp.DataType.Type.CHAR: "TEXT",
 88            exp.DataType.Type.NCHAR: "TEXT",
 89            exp.DataType.Type.VARCHAR: "TEXT",
 90            exp.DataType.Type.NVARCHAR: "TEXT",
 91            exp.DataType.Type.BINARY: "BLOB",
 92            exp.DataType.Type.VARBINARY: "BLOB",
 93        }
 94
 95        TOKEN_MAPPING = {
 96            TokenType.AUTO_INCREMENT: "AUTOINCREMENT",
 97        }
 98
 99        TRANSFORMS = {
100            **generator.Generator.TRANSFORMS,
101            exp.Concat: concat_to_dpipe_sql,
102            exp.CountIf: count_if_to_sum,
103            exp.Create: transforms.preprocess([_transform_create]),
104            exp.CurrentDate: lambda *_: "CURRENT_DATE",
105            exp.CurrentTime: lambda *_: "CURRENT_TIME",
106            exp.CurrentTimestamp: lambda *_: "CURRENT_TIMESTAMP",
107            exp.DateAdd: _date_add_sql,
108            exp.DateStrToDate: lambda self, e: self.sql(e, "this"),
109            exp.ILike: no_ilike_sql,
110            exp.JSONExtract: arrow_json_extract_sql,
111            exp.JSONExtractScalar: arrow_json_extract_scalar_sql,
112            exp.JSONBExtract: arrow_json_extract_sql,
113            exp.JSONBExtractScalar: arrow_json_extract_scalar_sql,
114            exp.Levenshtein: rename_func("EDITDIST3"),
115            exp.LogicalOr: rename_func("MAX"),
116            exp.LogicalAnd: rename_func("MIN"),
117            exp.Pivot: no_pivot_sql,
118            exp.SafeConcat: concat_to_dpipe_sql,
119            exp.Select: transforms.preprocess(
120                [transforms.eliminate_distinct_on, transforms.eliminate_qualify]
121            ),
122            exp.TableSample: no_tablesample_sql,
123            exp.TimeStrToTime: lambda self, e: self.sql(e, "this"),
124            exp.TryCast: no_trycast_sql,
125        }
126
127        PROPERTIES_LOCATION = {
128            k: exp.Properties.Location.UNSUPPORTED
129            for k, v in generator.Generator.PROPERTIES_LOCATION.items()
130        }
131
132        LIMIT_FETCH = "LIMIT"
133
134        def cast_sql(self, expression: exp.Cast) -> str:
135            if expression.is_type("date"):
136                return self.func("DATE", expression.this)
137
138            return super().cast_sql(expression)
139
140        def datediff_sql(self, expression: exp.DateDiff) -> str:
141            unit = expression.args.get("unit")
142            unit = unit.name.upper() if unit else "DAY"
143
144            sql = f"(JULIANDAY({self.sql(expression, 'this')}) - JULIANDAY({self.sql(expression, 'expression')}))"
145
146            if unit == "MONTH":
147                sql = f"{sql} / 30.0"
148            elif unit == "YEAR":
149                sql = f"{sql} / 365.0"
150            elif unit == "HOUR":
151                sql = f"{sql} * 24.0"
152            elif unit == "MINUTE":
153                sql = f"{sql} * 1440.0"
154            elif unit == "SECOND":
155                sql = f"{sql} * 86400.0"
156            elif unit == "MILLISECOND":
157                sql = f"{sql} * 86400000.0"
158            elif unit == "MICROSECOND":
159                sql = f"{sql} * 86400000000.0"
160            elif unit == "NANOSECOND":
161                sql = f"{sql} * 8640000000000.0"
162            else:
163                self.unsupported("DATEDIFF unsupported for '{unit}'.")
164
165            return f"CAST({sql} AS INTEGER)"
166
167        # https://www.sqlite.org/lang_aggfunc.html#group_concat
168        def groupconcat_sql(self, expression: exp.GroupConcat) -> str:
169            this = expression.this
170            distinct = expression.find(exp.Distinct)
171
172            if distinct:
173                this = distinct.expressions[0]
174                distinct_sql = "DISTINCT "
175            else:
176                distinct_sql = ""
177
178            if isinstance(expression.this, exp.Order):
179                self.unsupported("SQLite GROUP_CONCAT doesn't support ORDER BY.")
180                if expression.this.this and not distinct:
181                    this = expression.this.this
182
183            separator = expression.args.get("separator")
184            return f"GROUP_CONCAT({distinct_sql}{self.format_args(this, separator)})"
185
186        def least_sql(self, expression: exp.Least) -> str:
187            if len(expression.expressions) > 1:
188                return rename_func("MIN")(self, expression)
189
190            return self.expressions(expression)
191
192        def transaction_sql(self, expression: exp.Transaction) -> str:
193            this = expression.this
194            this = f" {this}" if this else ""
195            return f"BEGIN{this} TRANSACTION"
class SQLite.Tokenizer(sqlglot.tokens.Tokenizer):
63    class Tokenizer(tokens.Tokenizer):
64        IDENTIFIERS = ['"', ("[", "]"), "`"]
65        HEX_STRINGS = [("x'", "'"), ("X'", "'"), ("0x", ""), ("0X", "")]
class SQLite.Parser(sqlglot.parser.Parser):
67    class Parser(parser.Parser):
68        FUNCTIONS = {
69            **parser.Parser.FUNCTIONS,
70            "EDITDIST3": exp.Levenshtein.from_arg_list,
71        }

Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.

Arguments:
  • error_level: The desired error level. Default: ErrorLevel.IMMEDIATE
  • error_message_context: Determines the amount of context to capture from a query string when displaying the error message (in number of characters). Default: 100
  • max_errors: Maximum number of error messages to include in a raised ParseError. This is only relevant if error_level is ErrorLevel.RAISE. Default: 3
class SQLite.Generator(sqlglot.generator.Generator):
 73    class Generator(generator.Generator):
 74        JOIN_HINTS = False
 75        TABLE_HINTS = False
 76
 77        TYPE_MAPPING = {
 78            **generator.Generator.TYPE_MAPPING,
 79            exp.DataType.Type.BOOLEAN: "INTEGER",
 80            exp.DataType.Type.TINYINT: "INTEGER",
 81            exp.DataType.Type.SMALLINT: "INTEGER",
 82            exp.DataType.Type.INT: "INTEGER",
 83            exp.DataType.Type.BIGINT: "INTEGER",
 84            exp.DataType.Type.FLOAT: "REAL",
 85            exp.DataType.Type.DOUBLE: "REAL",
 86            exp.DataType.Type.DECIMAL: "REAL",
 87            exp.DataType.Type.CHAR: "TEXT",
 88            exp.DataType.Type.NCHAR: "TEXT",
 89            exp.DataType.Type.VARCHAR: "TEXT",
 90            exp.DataType.Type.NVARCHAR: "TEXT",
 91            exp.DataType.Type.BINARY: "BLOB",
 92            exp.DataType.Type.VARBINARY: "BLOB",
 93        }
 94
 95        TOKEN_MAPPING = {
 96            TokenType.AUTO_INCREMENT: "AUTOINCREMENT",
 97        }
 98
 99        TRANSFORMS = {
100            **generator.Generator.TRANSFORMS,
101            exp.Concat: concat_to_dpipe_sql,
102            exp.CountIf: count_if_to_sum,
103            exp.Create: transforms.preprocess([_transform_create]),
104            exp.CurrentDate: lambda *_: "CURRENT_DATE",
105            exp.CurrentTime: lambda *_: "CURRENT_TIME",
106            exp.CurrentTimestamp: lambda *_: "CURRENT_TIMESTAMP",
107            exp.DateAdd: _date_add_sql,
108            exp.DateStrToDate: lambda self, e: self.sql(e, "this"),
109            exp.ILike: no_ilike_sql,
110            exp.JSONExtract: arrow_json_extract_sql,
111            exp.JSONExtractScalar: arrow_json_extract_scalar_sql,
112            exp.JSONBExtract: arrow_json_extract_sql,
113            exp.JSONBExtractScalar: arrow_json_extract_scalar_sql,
114            exp.Levenshtein: rename_func("EDITDIST3"),
115            exp.LogicalOr: rename_func("MAX"),
116            exp.LogicalAnd: rename_func("MIN"),
117            exp.Pivot: no_pivot_sql,
118            exp.SafeConcat: concat_to_dpipe_sql,
119            exp.Select: transforms.preprocess(
120                [transforms.eliminate_distinct_on, transforms.eliminate_qualify]
121            ),
122            exp.TableSample: no_tablesample_sql,
123            exp.TimeStrToTime: lambda self, e: self.sql(e, "this"),
124            exp.TryCast: no_trycast_sql,
125        }
126
127        PROPERTIES_LOCATION = {
128            k: exp.Properties.Location.UNSUPPORTED
129            for k, v in generator.Generator.PROPERTIES_LOCATION.items()
130        }
131
132        LIMIT_FETCH = "LIMIT"
133
134        def cast_sql(self, expression: exp.Cast) -> str:
135            if expression.is_type("date"):
136                return self.func("DATE", expression.this)
137
138            return super().cast_sql(expression)
139
140        def datediff_sql(self, expression: exp.DateDiff) -> str:
141            unit = expression.args.get("unit")
142            unit = unit.name.upper() if unit else "DAY"
143
144            sql = f"(JULIANDAY({self.sql(expression, 'this')}) - JULIANDAY({self.sql(expression, 'expression')}))"
145
146            if unit == "MONTH":
147                sql = f"{sql} / 30.0"
148            elif unit == "YEAR":
149                sql = f"{sql} / 365.0"
150            elif unit == "HOUR":
151                sql = f"{sql} * 24.0"
152            elif unit == "MINUTE":
153                sql = f"{sql} * 1440.0"
154            elif unit == "SECOND":
155                sql = f"{sql} * 86400.0"
156            elif unit == "MILLISECOND":
157                sql = f"{sql} * 86400000.0"
158            elif unit == "MICROSECOND":
159                sql = f"{sql} * 86400000000.0"
160            elif unit == "NANOSECOND":
161                sql = f"{sql} * 8640000000000.0"
162            else:
163                self.unsupported("DATEDIFF unsupported for '{unit}'.")
164
165            return f"CAST({sql} AS INTEGER)"
166
167        # https://www.sqlite.org/lang_aggfunc.html#group_concat
168        def groupconcat_sql(self, expression: exp.GroupConcat) -> str:
169            this = expression.this
170            distinct = expression.find(exp.Distinct)
171
172            if distinct:
173                this = distinct.expressions[0]
174                distinct_sql = "DISTINCT "
175            else:
176                distinct_sql = ""
177
178            if isinstance(expression.this, exp.Order):
179                self.unsupported("SQLite GROUP_CONCAT doesn't support ORDER BY.")
180                if expression.this.this and not distinct:
181                    this = expression.this.this
182
183            separator = expression.args.get("separator")
184            return f"GROUP_CONCAT({distinct_sql}{self.format_args(this, separator)})"
185
186        def least_sql(self, expression: exp.Least) -> str:
187            if len(expression.expressions) > 1:
188                return rename_func("MIN")(self, expression)
189
190            return self.expressions(expression)
191
192        def transaction_sql(self, expression: exp.Transaction) -> str:
193            this = expression.this
194            this = f" {this}" if this else ""
195            return f"BEGIN{this} TRANSACTION"

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

Arguments:
  • pretty: Whether or not 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 or 'always': Always quote. 'safe': Only quote identifiers that are case insensitive.
  • normalize: Whether or not to normalize identifiers to lowercase. Default: False.
  • pad: Determines the pad size in a formatted string. Default: 2.
  • indent: Determines the indentation size in a formatted string. Default: 2.
  • normalize_functions: Whether or not to normalize all 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: Determines whether or not 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 or not to preserve comments in the output SQL code. Default: True
def cast_sql(self, expression: sqlglot.expressions.Cast) -> str:
134        def cast_sql(self, expression: exp.Cast) -> str:
135            if expression.is_type("date"):
136                return self.func("DATE", expression.this)
137
138            return super().cast_sql(expression)
def datediff_sql(self, expression: sqlglot.expressions.DateDiff) -> str:
140        def datediff_sql(self, expression: exp.DateDiff) -> str:
141            unit = expression.args.get("unit")
142            unit = unit.name.upper() if unit else "DAY"
143
144            sql = f"(JULIANDAY({self.sql(expression, 'this')}) - JULIANDAY({self.sql(expression, 'expression')}))"
145
146            if unit == "MONTH":
147                sql = f"{sql} / 30.0"
148            elif unit == "YEAR":
149                sql = f"{sql} / 365.0"
150            elif unit == "HOUR":
151                sql = f"{sql} * 24.0"
152            elif unit == "MINUTE":
153                sql = f"{sql} * 1440.0"
154            elif unit == "SECOND":
155                sql = f"{sql} * 86400.0"
156            elif unit == "MILLISECOND":
157                sql = f"{sql} * 86400000.0"
158            elif unit == "MICROSECOND":
159                sql = f"{sql} * 86400000000.0"
160            elif unit == "NANOSECOND":
161                sql = f"{sql} * 8640000000000.0"
162            else:
163                self.unsupported("DATEDIFF unsupported for '{unit}'.")
164
165            return f"CAST({sql} AS INTEGER)"
def groupconcat_sql(self, expression: sqlglot.expressions.GroupConcat) -> str:
168        def groupconcat_sql(self, expression: exp.GroupConcat) -> str:
169            this = expression.this
170            distinct = expression.find(exp.Distinct)
171
172            if distinct:
173                this = distinct.expressions[0]
174                distinct_sql = "DISTINCT "
175            else:
176                distinct_sql = ""
177
178            if isinstance(expression.this, exp.Order):
179                self.unsupported("SQLite GROUP_CONCAT doesn't support ORDER BY.")
180                if expression.this.this and not distinct:
181                    this = expression.this.this
182
183            separator = expression.args.get("separator")
184            return f"GROUP_CONCAT({distinct_sql}{self.format_args(this, separator)})"
def least_sql(self, expression: sqlglot.expressions.Least) -> str:
186        def least_sql(self, expression: exp.Least) -> str:
187            if len(expression.expressions) > 1:
188                return rename_func("MIN")(self, expression)
189
190            return self.expressions(expression)
def transaction_sql(self, expression: sqlglot.expressions.Transaction) -> str:
192        def transaction_sql(self, expression: exp.Transaction) -> str:
193            this = expression.this
194            this = f" {this}" if this else ""
195            return f"BEGIN{this} TRANSACTION"
Inherited Members
sqlglot.generator.Generator
Generator
generate
unsupported
sep
seg
pad_comment
maybe_comment
wrap
no_identify
normalize_func
indent
sql
uncache_sql
cache_sql
characterset_sql
column_sql
columnposition_sql
columndef_sql
columnconstraint_sql
autoincrementcolumnconstraint_sql
compresscolumnconstraint_sql
generatedasidentitycolumnconstraint_sql
notnullcolumnconstraint_sql
primarykeycolumnconstraint_sql
uniquecolumnconstraint_sql
createable_sql
create_sql
clone_sql
describe_sql
prepend_ctes
with_sql
cte_sql
tablealias_sql
bitstring_sql
hexstring_sql
bytestring_sql
rawstring_sql
datatypesize_sql
datatype_sql
directory_sql
delete_sql
drop_sql
except_sql
except_op
fetch_sql
filter_sql
hint_sql
index_sql
identifier_sql
inputoutputformat_sql
national_sql
partition_sql
properties_sql
root_properties
properties
with_properties
locate_properties
property_sql
likeproperty_sql
fallbackproperty_sql
journalproperty_sql
freespaceproperty_sql
checksumproperty_sql
mergeblockratioproperty_sql
datablocksizeproperty_sql
blockcompressionproperty_sql
isolatedloadingproperty_sql
lockingproperty_sql
withdataproperty_sql
insert_sql
intersect_sql
intersect_op
introducer_sql
pseudotype_sql
onconflict_sql
returning_sql
rowformatdelimitedproperty_sql
table_sql
tablesample_sql
pivot_sql
tuple_sql
update_sql
values_sql
var_sql
into_sql
from_sql
group_sql
having_sql
join_sql
lambda_sql
lateral_sql
limit_sql
offset_sql
setitem_sql
set_sql
pragma_sql
lock_sql
literal_sql
loaddata_sql
null_sql
boolean_sql
order_sql
cluster_sql
distribute_sql
sort_sql
ordered_sql
matchrecognize_sql
query_modifiers
offset_limit_modifiers
after_having_modifiers
after_limit_modifiers
select_sql
schema_sql
schema_columns_sql
star_sql
parameter_sql
sessionparameter_sql
placeholder_sql
subquery_sql
qualify_sql
union_sql
union_op
unnest_sql
where_sql
window_sql
partition_by_sql
windowspec_sql
withingroup_sql
between_sql
bracket_sql
all_sql
any_sql
exists_sql
case_sql
constraint_sql
nextvaluefor_sql
extract_sql
trim_sql
safeconcat_sql
check_sql
foreignkey_sql
primarykey_sql
if_sql
matchagainst_sql
jsonkeyvalue_sql
jsonobject_sql
openjsoncolumndef_sql
openjson_sql
in_sql
in_unnest_op
interval_sql
return_sql
reference_sql
anonymous_sql
paren_sql
neg_sql
not_sql
alias_sql
aliases_sql
attimezone_sql
add_sql
and_sql
connector_sql
bitwiseand_sql
bitwiseleftshift_sql
bitwisenot_sql
bitwiseor_sql
bitwiserightshift_sql
bitwisexor_sql
currentdate_sql
collate_sql
command_sql
comment_sql
mergetreettlaction_sql
mergetreettl_sql
commit_sql
rollback_sql
altercolumn_sql
renametable_sql
altertable_sql
droppartition_sql
addconstraint_sql
distinct_sql
ignorenulls_sql
respectnulls_sql
intdiv_sql
dpipe_sql
safedpipe_sql
div_sql
overlaps_sql
distance_sql
dot_sql
eq_sql
escape_sql
glob_sql
gt_sql
gte_sql
ilike_sql
ilikeany_sql
is_sql
like_sql
likeany_sql
similarto_sql
lt_sql
lte_sql
mod_sql
mul_sql
neq_sql
nullsafeeq_sql
nullsafeneq_sql
or_sql
slice_sql
sub_sql
trycast_sql
use_sql
binary
function_fallback_sql
func
format_args
text_width
format_time
expressions
op_expressions
naked_property
set_operation
tag_sql
token_sql
userdefinedfunction_sql
joinhint_sql
kwarg_sql
when_sql
merge_sql
tochar_sql
dictproperty_sql
dictrange_sql
dictsubproperty_sql
oncluster_sql