Chore: bump sqlglot version (#968)

* Chore: bump sqlglot version

* Bump sqlglot to v15.3.0

* Bump sqlglot to v16.0.0

Author: georgesittas

setup.py

@@ -44,7 +44,7 @@
         "requests",
         "rich",
         "ruamel.yaml",
-        "sqlglot~=15.2.0",
+        "sqlglot~=16.0.0",
         "fsspec",
     ],
     extras_require={

sqlmesh/core/dialect.py

@@ -289,7 +289,7 @@ def parse(self: Parser) -> t.Optional[exp.Expression]:
 PARSERS = {"MODEL": _parse_model, "AUDIT": _parse_audit}
 
 
-def _model_sql(self: Generator, expression: exp.Expression) -> str:
+def _model_sql(self: Generator, expression: Model) -> str:
     props = ",\n".join(
         self.indent(f"{prop.name} {self.sql(prop, 'value')}") for prop in expression.expressions
     )
@@ -313,7 +313,7 @@ def _macro_keyword_func_sql(self: Generator, expression: exp.Expression) -> str:
     return self.sql(clause).replace(keyword, macro, 1)
 
 
-def _macro_func_sql(self: Generator, expression: exp.Expression) -> str:
+def _macro_func_sql(self: Generator, expression: MacroFunc) -> str:
     expression = expression.this
     name = expression.name
     if name in KEYWORD_MACROS:
@@ -335,8 +335,9 @@ def format_model_expressions(
     Args:
         expressions: The model's expressions, must be at least model def + query.
         dialect: The dialect to render the expressions as.
+
     Returns:
-        A string with the formatted model.
+        A string representing the formatted model.
     """
     if len(expressions) == 1:
         return expressions[0].sql(pretty=True, dialect=dialect)
@@ -446,7 +447,7 @@ def parse(sql: str, default_dialect: t.Optional[str] = None) -> t.List[exp.Expre
         default_dialect: The dialect to use if the model does not specify one.
 
     Returns:
-        A list of the expressions, [Model, *Statements, Query | Jinja]
+        A list of the parsed expressions: [Model, *Statements, Query, *Statements]
     """
     match = DIALECT_PATTERN.search(sql[:MAX_MODEL_DEFINITION_SIZE])
     dialect = Dialect.get_or_raise(match.group(2) if match else default_dialect)()
@@ -528,16 +529,8 @@ def extend_sqlglot() -> None:
             generator.WITH_SEPARATED_COMMENTS = (*generator.WITH_SEPARATED_COMMENTS, Model)  # type: ignore
 
     for parser in parsers:
-        parser.FUNCTIONS.update(
-            {
-                "JINJA": Jinja.from_arg_list,
-            }
-        )
-        parser.PLACEHOLDER_PARSERS.update(
-            {
-                TokenType.PARAMETER: _parse_macro,
-            }
-        )
+        parser.FUNCTIONS.update({"JINJA": Jinja.from_arg_list})
+        parser.PLACEHOLDER_PARSERS.update({TokenType.PARAMETER: _parse_macro})
 
     _override(Parser, _parse_statement)
     _override(Parser, _parse_join)

sqlmesh/core/model/definition.py

@@ -384,7 +384,7 @@ def set_time_format(self, default_time_format: str = c.DEFAULT_TIME_COLUMN_FORMA
             # Transpile the time column format into the generic dialect
             formatted_time = format_time(
                 self.time_column.format,
-                d.Dialect.get_or_raise(self.dialect).time_mapping,
+                d.Dialect.get_or_raise(self.dialect).TIME_MAPPING,
             )
             assert formatted_time is not None
             self.time_column.format = formatted_time

sqlmesh/core/model/kind.py

@@ -184,10 +184,7 @@ def to_expression(self, dialect: str) -> exp.Column | exp.Tuple:
             expressions=[
                 column,
                 exp.Literal.string(
-                    format_time(
-                        self.format,
-                        d.Dialect.get_or_raise(dialect).inverse_time_mapping,  # type: ignore
-                    )
+                    format_time(self.format, d.Dialect.get_or_raise(dialect).INVERSE_TIME_MAPPING)
                 ),
             ]
         )

web/client/src/workers/sqlglot/sqlglot.py

@@ -23,16 +23,13 @@ def parse_to_json(sql: str, read: DialectType = None) -> str:
 
 def get_dialect(name: str = "") -> str:
     dialect = Dialect.classes.get(name, Dialect)
-    tokenizer = dialect.tokenizer_class
-    output = {"keywords": "", "types": ""}
+    keywords = dialect.tokenizer_class.KEYWORDS
+    type_mapping = dialect.generator_class.TYPE_MAPPING
 
-    if tokenizer is not None and dialect.generator_class is not None:
-        type_mapping = dialect.generator_class.TYPE_MAPPING
-
-        output = {
-            "keywords": " ".join(tokenizer.KEYWORDS) + " ",
-            "types": " ".join(type_mapping.get(t, t.value) for t in exp.DataType.Type) + " ",
-        }
+    output = {
+        "keywords": " ".join(keywords) + " ",
+        "types": " ".join(type_mapping.get(t, t.value) for t in exp.DataType.Type) + " ",
+    }
 
     return json.dumps(output)