dbcli/sqlglot
1
0
Fork 0
Code Issues Activity

Merging upstream version 11.3.6.

Browse source 
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
Daniel Baumann 2025-02-13 15:44:58 +01:00
parent f5f7767f8d
commit e33f287a97
Signed by: daniel
GPG key ID: FBB4F0E80A80222F
46 changed files with 23416 additions and 22639 deletions
Download patch file Download diff file Expand all files Collapse all files

52
sqlglot/parser.py
View file

@ -31,15 +31,20 @@ def parse_var_map(args):
)
def binary_range_parser(
expr_type: t.Type[exp.Expression],
) -> t.Callable[[Parser, t.Optional[exp.Expression]], t.Optional[exp.Expression]]:
return lambda self, this: self._parse_escape(
self.expression(expr_type, this=this, expression=self._parse_bitwise())
)
class _Parser(type):
def __new__(cls, clsname, bases, attrs):
klass = super().__new__(cls, clsname, bases, attrs)
klass._show_trie = new_trie(key.split(" ") for key in klass.SHOW_PARSERS)
klass._set_trie = new_trie(key.split(" ") for key in klass.SET_PARSERS)
if not klass.INTEGER_DIVISION:
klass.FACTOR = {**klass.FACTOR, TokenType.SLASH: exp.FloatDiv}
return klass
@ -102,6 +107,7 @@ class Parser(metaclass=_Parser):
}
TYPE_TOKENS = {
TokenType.BIT,
TokenType.BOOLEAN,
TokenType.TINYINT,
TokenType.SMALLINT,
@ -503,29 +509,15 @@ class Parser(metaclass=_Parser):
RANGE_PARSERS = {
TokenType.BETWEEN: lambda self, this: self._parse_between(this),
TokenType.GLOB: lambda self, this: self._parse_escape(
self.expression(exp.Glob, this=this, expression=self._parse_bitwise())
),
TokenType.OVERLAPS: lambda self, this: self._parse_escape(
self.expression(exp.Overlaps, this=this, expression=self._parse_bitwise())
),
TokenType.GLOB: binary_range_parser(exp.Glob),
TokenType.OVERLAPS: binary_range_parser(exp.Overlaps),
TokenType.IN: lambda self, this: self._parse_in(this),
TokenType.IS: lambda self, this: self._parse_is(this),
TokenType.LIKE: lambda self, this: self._parse_escape(
self.expression(exp.Like, this=this, expression=self._parse_bitwise())
),
TokenType.ILIKE: lambda self, this: self._parse_escape(
self.expression(exp.ILike, this=this, expression=self._parse_bitwise())
),
TokenType.IRLIKE: lambda self, this: self.expression(
exp.RegexpILike, this=this, expression=self._parse_bitwise()
),
TokenType.RLIKE: lambda self, this: self.expression(
exp.RegexpLike, this=this, expression=self._parse_bitwise()
),
TokenType.SIMILAR_TO: lambda self, this: self.expression(
exp.SimilarTo, this=this, expression=self._parse_bitwise()
),
TokenType.LIKE: binary_range_parser(exp.Like),
TokenType.ILIKE: binary_range_parser(exp.ILike),
TokenType.IRLIKE: binary_range_parser(exp.RegexpILike),
TokenType.RLIKE: binary_range_parser(exp.RegexpLike),
TokenType.SIMILAR_TO: binary_range_parser(exp.SimilarTo),
}
PROPERTY_PARSERS = {
@ -707,7 +699,7 @@ class Parser(metaclass=_Parser):
STRICT_CAST = True
INTEGER_DIVISION = True
CONVERT_TYPE_FIRST = False
__slots__ = (
"error_level",
@ -2542,7 +2534,7 @@ class Parser(metaclass=_Parser):
def _parse_type(self) -> t.Optional[exp.Expression]:
if self._match(TokenType.INTERVAL):
return self.expression(exp.Interval, this=self._parse_term(), unit=self._parse_var())
return self.expression(exp.Interval, this=self._parse_term(), unit=self._parse_field())
index = self._index
type_token = self._parse_types(check_func=True)
@ -3285,15 +3277,19 @@ class Parser(metaclass=_Parser):
def _parse_convert(self, strict: bool) -> t.Optional[exp.Expression]:
to: t.Optional[exp.Expression]
this = self._parse_column()
this = self._parse_bitwise()
if self._match(TokenType.USING):
to = self.expression(exp.CharacterSet, this=self._parse_var())
elif self._match(TokenType.COMMA):
to = self._parse_types()
to = self._parse_bitwise()
else:
to = None
# Swap the argument order if needed to produce the correct AST
if self.CONVERT_TYPE_FIRST:
this, to = to, this
return self.expression(exp.Cast if strict else exp.TryCast, this=this, to=to)
def _parse_position(self, haystack_first: bool = False) -> exp.Expression: