dbcli/sqlglot
1
0
Fork 0
Code Issues Activity

Merging upstream version 11.1.3.

Browse source 
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
Daniel Baumann 2025-02-13 15:26:26 +01:00
parent 8c1c1864c5
commit fb546b57e5
Signed by: daniel
GPG key ID: FBB4F0E80A80222F
95 changed files with 32569 additions and 30081 deletions
Download patch file Download diff file Expand all files Collapse all files

233
sqlglot/expressions.py
View file

@ -128,7 +128,7 @@ class Expression(metaclass=_Expression):
"""
return self.args.get("expressions") or []
def text(self, key):
def text(self, key) -> str:
"""
Returns a textual representation of the argument corresponding to "key". This can only be used
for args that are strings or leaf Expression instances, such as identifiers and literals.
@ -143,21 +143,21 @@ class Expression(metaclass=_Expression):
return ""
@property
def is_string(self):
def is_string(self) -> bool:
"""
Checks whether a Literal expression is a string.
"""
return isinstance(self, Literal) and self.args["is_string"]
@property
def is_number(self):
def is_number(self) -> bool:
"""
Checks whether a Literal expression is a number.
"""
return isinstance(self, Literal) and not self.args["is_string"]
@property
def is_int(self):
def is_int(self) -> bool:
"""
Checks whether a Literal expression is an integer.
"""
@ -170,7 +170,12 @@ class Expression(metaclass=_Expression):
return False
@property
def alias(self):
def is_star(self) -> bool:
"""Checks whether an expression is a star."""
return isinstance(self, Star) or (isinstance(self, Column) and isinstance(self.this, Star))
@property
def alias(self) -> str:
"""
Returns the alias of the expression, or an empty string if it's not aliased.
"""
@ -825,10 +830,6 @@ class UserDefinedFunction(Expression):
arg_types = {"this": True, "expressions": False, "wrapped": False}
class UserDefinedFunctionKwarg(Expression):
arg_types = {"this": True, "kind": True, "default": False}
class CharacterSet(Expression):
arg_types = {"this": True, "default": False}
@ -870,14 +871,22 @@ class ByteString(Condition):
class Column(Condition):
arg_types = {"this": True, "table": False}
arg_types = {"this": True, "table": False, "db": False, "catalog": False}
@property
def table(self):
def table(self) -> str:
return self.text("table")
@property
def output_name(self):
def db(self) -> str:
return self.text("db")
@property
def catalog(self) -> str:
return self.text("catalog")
@property
def output_name(self) -> str:
return self.name
@ -917,6 +926,14 @@ class AutoIncrementColumnConstraint(ColumnConstraintKind):
pass
class CaseSpecificColumnConstraint(ColumnConstraintKind):
arg_types = {"not_": True}
class CharacterSetColumnConstraint(ColumnConstraintKind):
arg_types = {"this": True}
class CheckColumnConstraint(ColumnConstraintKind):
pass
@ -929,6 +946,10 @@ class CommentColumnConstraint(ColumnConstraintKind):
pass
class DateFormatColumnConstraint(ColumnConstraintKind):
arg_types = {"this": True}
class DefaultColumnConstraint(ColumnConstraintKind):
pass
@ -939,7 +960,14 @@ class EncodeColumnConstraint(ColumnConstraintKind):
class GeneratedAsIdentityColumnConstraint(ColumnConstraintKind):
# this: True -> ALWAYS, this: False -> BY DEFAULT
arg_types = {"this": False, "start": False, "increment": False}
arg_types = {
"this": False,
"start": False,
"increment": False,
"minvalue": False,
"maxvalue": False,
"cycle": False,
}
class NotNullColumnConstraint(ColumnConstraintKind):
@ -950,7 +978,19 @@ class PrimaryKeyColumnConstraint(ColumnConstraintKind):
arg_types = {"desc": False}
class TitleColumnConstraint(ColumnConstraintKind):
pass
class UniqueColumnConstraint(ColumnConstraintKind):
arg_types: t.Dict[str, t.Any] = {}
class UppercaseColumnConstraint(ColumnConstraintKind):
arg_types: t.Dict[str, t.Any] = {}
class PathColumnConstraint(ColumnConstraintKind):
pass
@ -1063,6 +1103,7 @@ class Insert(Expression):
"overwrite": False,
"exists": False,
"partition": False,
"alternative": False,
}
@ -1438,6 +1479,16 @@ class IsolatedLoadingProperty(Property):
}
class LockingProperty(Property):
arg_types = {
"this": False,
"kind": True,
"for_or_in": True,
"lock_type": True,
"override": False,
}
class Properties(Expression):
arg_types = {"expressions": True}
@ -1463,12 +1514,26 @@ class Properties(Expression):
PROPERTY_TO_NAME = {v: k for k, v in NAME_TO_PROPERTY.items()}
# CREATE property locations
# Form: schema specified
# create [POST_CREATE]
# table a [POST_NAME]
# (b int) [POST_SCHEMA]
# with ([POST_WITH])
# index (b) [POST_INDEX]
#
# Form: alias selection
# create [POST_CREATE]
# table a [POST_NAME]
# as [POST_ALIAS] (select * from b)
# index (c) [POST_INDEX]
class Location(AutoName):
POST_CREATE = auto()
PRE_SCHEMA = auto()
POST_NAME = auto()
POST_SCHEMA = auto()
POST_WITH = auto()
POST_ALIAS = auto()
POST_INDEX = auto()
POST_SCHEMA_ROOT = auto()
POST_SCHEMA_WITH = auto()
UNSUPPORTED = auto()
@classmethod
@ -1633,6 +1698,14 @@ class Table(Expression):
"system_time": False,
}
@property
def db(self) -> str:
return self.text("db")
@property
def catalog(self) -> str:
return self.text("catalog")
# See the TSQL "Querying data in a system-versioned temporal table" page
class SystemTime(Expression):
@ -1678,6 +1751,40 @@ class Union(Subqueryable):
.limit(expression, dialect=dialect, copy=False, **opts)
)
def select(
self,
*expressions: str | Expression,
append: bool = True,
dialect: DialectType = None,
copy: bool = True,
**opts,
) -> Union:
"""Append to or set the SELECT of the union recursively.
Example:
>>> from sqlglot import parse_one
>>> parse_one("select a from x union select a from y union select a from z").select("b").sql()
'SELECT a, b FROM x UNION SELECT a, b FROM y UNION SELECT a, b FROM z'
Args:
*expressions: the SQL code strings to parse.
If an `Expression` instance is passed, it will be used as-is.
append: if `True`, add to any existing expressions.
Otherwise, this resets the expressions.
dialect: the dialect used to parse the input expressions.
copy: if `False`, modify this expression instance in-place.
opts: other options to use to parse the input expressions.
Returns:
Union: the modified expression.
"""
this = self.copy() if copy else self
this.this.unnest().select(*expressions, append=append, dialect=dialect, copy=False, **opts)
this.expression.unnest().select(
*expressions, append=append, dialect=dialect, copy=False, **opts
)
return this
@property
def named_selects(self):
return self.this.unnest().named_selects
@ -1985,7 +2092,14 @@ class Select(Subqueryable):
**opts,
)
def select(self, *expressions, append=True, dialect=None, copy=True, **opts) -> Select:
def select(
self,
*expressions: str | Expression,
append: bool = True,
dialect: DialectType = None,
copy: bool = True,
**opts,
) -> Select:
"""
Append to or set the SELECT expressions.
@ -1994,13 +2108,13 @@ class Select(Subqueryable):
'SELECT x, y'
Args:
*expressions (str | Expression): the SQL code strings to parse.
*expressions: the SQL code strings to parse.
If an `Expression` instance is passed, it will be used as-is.
append (bool): if `True`, add to any existing expressions.
append: if `True`, add to any existing expressions.
Otherwise, this resets the expressions.
dialect (str): the dialect used to parse the input expressions.
copy (bool): if `False`, modify this expression instance in-place.
opts (kwargs): other options to use to parse the input expressions.
dialect: the dialect used to parse the input expressions.
copy: if `False`, modify this expression instance in-place.
opts: other options to use to parse the input expressions.
Returns:
Select: the modified expression.
@ -2399,7 +2513,7 @@ class Star(Expression):
class Parameter(Expression):
pass
arg_types = {"this": True, "wrapped": False}
class SessionParameter(Expression):
@ -2428,6 +2542,7 @@ class DataType(Expression):
"expressions": False,
"nested": False,
"values": False,
"prefix": False,
}
class Type(AutoName):
@ -2693,6 +2808,10 @@ class ILike(Binary, Predicate):
pass
class ILikeAny(Binary, Predicate):
pass
class IntDiv(Binary):
pass
@ -2709,6 +2828,10 @@ class Like(Binary, Predicate):
pass
class LikeAny(Binary, Predicate):
pass
class LT(Binary, Predicate):
pass
@ -3042,7 +3165,7 @@ class DateDiff(Func, TimeUnit):
class DateTrunc(Func):
arg_types = {"this": True, "expression": True, "zone": False}
arg_types = {"unit": True, "this": True, "zone": False}
class DatetimeAdd(Func, TimeUnit):
@ -3330,6 +3453,16 @@ class Reduce(Func):
arg_types = {"this": True, "initial": True, "merge": True, "finish": False}
class RegexpExtract(Func):
arg_types = {
"this": True,
"expression": True,
"position": False,
"occurrence": False,
"group": False,
}
class RegexpLike(Func):
arg_types = {"this": True, "expression": True, "flag": False}
@ -3519,6 +3652,10 @@ class Week(Func):
arg_types = {"this": True, "mode": False}
class XMLTable(Func):
arg_types = {"this": True, "passing": False, "columns": False, "by_ref": False}
class Year(Func):
pass
@ -3566,6 +3703,7 @@ def maybe_parse(
into: t.Optional[IntoType] = None,
dialect: DialectType = None,
prefix: t.Optional[str] = None,
copy: bool = False,
**opts,
) -> Expression:
"""Gracefully handle a possible string or expression.
@ -3583,6 +3721,7 @@ def maybe_parse(
input expression is a SQL string).
prefix: a string to prefix the sql with before it gets parsed
(automatically includes a space)
copy: whether or not to copy the expression.
**opts: other options to use to parse the input expressions (again, in the case
that an input expression is a SQL string).
@ -3590,6 +3729,8 @@ def maybe_parse(
Expression: the parsed or given expression.
"""
if isinstance(sql_or_expression, Expression):
if copy:
return sql_or_expression.copy()
return sql_or_expression
import sqlglot
@ -3818,7 +3959,7 @@ def except_(left, right, distinct=True, dialect=None, **opts):
return Except(this=left, expression=right, distinct=distinct)
def select(*expressions, dialect=None, **opts) -> Select:
def select(*expressions: str | Expression, dialect: DialectType = None, **opts) -> Select:
"""
Initializes a syntax tree from one or multiple SELECT expressions.
@ -3827,9 +3968,9 @@ def select(*expressions, dialect=None, **opts) -> Select:
'SELECT col1, col2 FROM tbl'
Args:
*expressions (str | Expression): the SQL code string to parse as the expressions of a
*expressions: the SQL code string to parse as the expressions of a
SELECT statement. If an Expression instance is passed, this is used as-is.
dialect (str): the dialect used to parse the input expressions (in the case that an
dialect: the dialect used to parse the input expressions (in the case that an
input expression is a SQL string).
**opts: other options to use to parse the input expressions (again, in the case
that an input expression is a SQL string).
@ -4219,19 +4360,27 @@ def subquery(expression, alias=None, dialect=None, **opts):
return Select().from_(expression, dialect=dialect, **opts)
def column(col, table=None, quoted=None) -> Column:
def column(
col: str | Identifier,
table: t.Optional[str | Identifier] = None,
schema: t.Optional[str | Identifier] = None,
quoted: t.Optional[bool] = None,
) -> Column:
"""
Build a Column.
Args:
col (str | Expression): column name
table (str | Expression): table name
col: column name
table: table name
schema: schema name
quoted: whether or not to force quote each part
Returns:
Column: column instance
"""
return Column(
this=to_identifier(col, quoted=quoted),
table=to_identifier(table, quoted=quoted),
schema=to_identifier(schema, quoted=quoted),
)
@ -4314,6 +4463,30 @@ def values(
)
def var(name: t.Optional[str | Expression]) -> Var:
"""Build a SQL variable.
Example:
>>> repr(var('x'))
'(VAR this: x)'
>>> repr(var(column('x', table='y')))
'(VAR this: x)'
Args:
name: The name of the var or an expression who's name will become the var.
Returns:
The new variable node.
"""
if not name:
raise ValueError(f"Cannot convert empty name into var.")
if isinstance(name, Expression):
name = name.name
return Var(this=name)
def rename_table(old_name: str | Table, new_name: str | Table) -> AlterTable:
"""Build ALTER TABLE... RENAME... expression