sqlglot 28.4.1__tar.gz → 28.6.0__tar.gz

{sqlglot-28.4.1 → sqlglot-28.6.0}/CHANGELOG.md

@@ -1,6 +1,52 @@
 Changelog
 =========
 
+## [v28.5.0] - 2025-12-17
+### :boom: BREAKING CHANGES
+- due to [`4dfc810`](https://github.com/tobymao/sqlglot/commit/4dfc810f45d5a617ada2ba4ed57002549c8d1853) - support transpilation of BOOLNOT from snowflake to duckdb *(PR [#6577](https://github.com/tobymao/sqlglot/pull/6577) by [@fivetran-felixhuang](https://github.com/fivetran-felixhuang))*:
+
+  support transpilation of BOOLNOT from snowflake to duckdb (#6577)
+
+- due to [`b857185`](https://github.com/tobymao/sqlglot/commit/b8571850ca55802671484d118560a7b90e893c39) - remove Sysdate in favor of CurrentTimestamp with sysdate arg *(PR [#6584](https://github.com/tobymao/sqlglot/pull/6584) by [@georgesittas](https://github.com/georgesittas))*:
+
+  remove Sysdate in favor of CurrentTimestamp with sysdate arg (#6584)
+
+- due to [`bf217d6`](https://github.com/tobymao/sqlglot/commit/bf217d69f92efcbce5b69d637976e915ca63998d) - make `JSONArrayAgg` an `AggFunc` *(PR [#6585](https://github.com/tobymao/sqlglot/pull/6585) by [@AbhishekASLK](https://github.com/AbhishekASLK))*:
+
+  make `JSONArrayAgg` an `AggFunc` (#6585)
+
+- due to [`604efe5`](https://github.com/tobymao/sqlglot/commit/604efe5cf5812d0b1dd9d625ed278907d0d7fb8f) - Type annotation fixes for TO_TIMESTAMP* *(PR [#6557](https://github.com/tobymao/sqlglot/pull/6557) by [@fivetran-kwoodbeck](https://github.com/fivetran-kwoodbeck))*:
+
+  Type annotation fixes for TO_TIMESTAMP* (#6557)
+
+
+### :sparkles: New Features
+- [`4dfc810`](https://github.com/tobymao/sqlglot/commit/4dfc810f45d5a617ada2ba4ed57002549c8d1853) - **snowflake**: support transpilation of BOOLNOT from snowflake to duckdb *(PR [#6577](https://github.com/tobymao/sqlglot/pull/6577) by [@fivetran-felixhuang](https://github.com/fivetran-felixhuang))*
+- [`7077981`](https://github.com/tobymao/sqlglot/commit/707798166c1b45e633bd0e8d02d1c0146598b03a) - **snowflake**: Transpilation of Snowflake MONTHS_BETWEEN to DuckDB *(PR [#6561](https://github.com/tobymao/sqlglot/pull/6561) by [@fivetran-kwoodbeck](https://github.com/fivetran-kwoodbeck))*
+- [`604efe5`](https://github.com/tobymao/sqlglot/commit/604efe5cf5812d0b1dd9d625ed278907d0d7fb8f) - **snowflake**: Type annotation fixes for TO_TIMESTAMP* *(PR [#6557](https://github.com/tobymao/sqlglot/pull/6557) by [@fivetran-kwoodbeck](https://github.com/fivetran-kwoodbeck))*
+- [`3567880`](https://github.com/tobymao/sqlglot/commit/35678808dafb37c5d37c806682e6af9b6351bced) - add tokens to functions *(commit by [@tobymao](https://github.com/tobymao))*
+
+### :bug: Bug Fixes
+- [`b857185`](https://github.com/tobymao/sqlglot/commit/b8571850ca55802671484d118560a7b90e893c39) - **snowflake**: remove Sysdate in favor of CurrentTimestamp with sysdate arg *(PR [#6584](https://github.com/tobymao/sqlglot/pull/6584) by [@georgesittas](https://github.com/georgesittas))*
+- [`bf217d6`](https://github.com/tobymao/sqlglot/commit/bf217d69f92efcbce5b69d637976e915ca63998d) - make `JSONArrayAgg` an `AggFunc` *(PR [#6585](https://github.com/tobymao/sqlglot/pull/6585) by [@AbhishekASLK](https://github.com/AbhishekASLK))*
+- [`48f5e99`](https://github.com/tobymao/sqlglot/commit/48f5e999d3d3f6ad51c30e7a33a3a574d0e50d2b) - **duckdb**: preserve l/r-trim syntax *(PR [#6588](https://github.com/tobymao/sqlglot/pull/6588) by [@georgesittas](https://github.com/georgesittas))*
+  - :arrow_lower_right: *fixes issue [#6587](https://github.com/tobymao/sqlglot/issues/6587) opened by [@baruchoxman](https://github.com/baruchoxman)*
+
+### :wrench: Chores
+- [`ea0263a`](https://github.com/tobymao/sqlglot/commit/ea0263aa555591b03b06a4b6dee093fe42b545f9) - Skip integration tests GA for external contributors & fix `git diff` *(PR [#6582](https://github.com/tobymao/sqlglot/pull/6582) by [@VaggelisD](https://github.com/VaggelisD))*
+
+
+## [v28.4.1] - 2025-12-16
+### :boom: BREAKING CHANGES
+- due to [`cfc9346`](https://github.com/tobymao/sqlglot/commit/cfc9346ba0477523d3de8f923d83fd09814b22ac) - bump sqlglotrs to 0.10.0 *(commit by [@tobymao](https://github.com/tobymao))*:
+
+  bump sqlglotrs to 0.10.0
+
+
+### :wrench: Chores
+- [`cfc9346`](https://github.com/tobymao/sqlglot/commit/cfc9346ba0477523d3de8f923d83fd09814b22ac) - bump sqlglotrs to 0.10.0 *(commit by [@tobymao](https://github.com/tobymao))*
+
+
 ## [v28.4.0] - 2025-12-16
 ### :boom: BREAKING CHANGES
 - due to [`938f4b6`](https://github.com/tobymao/sqlglot/commit/938f4b6ebc1c0d26bd3c1400883978c79a435189) - annotate type for LAST_DAY *(PR [#5528](https://github.com/tobymao/sqlglot/pull/5528) by [@geooo109](https://github.com/geooo109))*:
@@ -11504,3 +11550,5 @@ Changelog
 [v28.2.0]: https://github.com/tobymao/sqlglot/compare/v28.1.0...v28.2.0
 [v28.3.0]: https://github.com/tobymao/sqlglot/compare/v28.2.0...v28.3.0
 [v28.4.0]: https://github.com/tobymao/sqlglot/compare/v27.6.1...v28.4.0
+[v28.4.1]: https://github.com/tobymao/sqlglot/compare/v28.4.0...v28.4.1
+[v28.5.0]: https://github.com/tobymao/sqlglot/compare/v28.4.1...v28.5.0

{sqlglot-28.4.1 → sqlglot-28.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 28.4.1
+Version: 28.6.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT
@@ -33,7 +33,7 @@ Requires-Dist: typing_extensions; extra == "dev"
 Requires-Dist: maturin<2.0,>=1.4; extra == "dev"
 Requires-Dist: pyperf; extra == "dev"
 Provides-Extra: rs
-Requires-Dist: sqlglotrs==0.10.0; extra == "rs"
+Requires-Dist: sqlglotrs==0.11.0; extra == "rs"
 Dynamic: license-file
 Dynamic: provides-extra
 
@@ -71,6 +71,7 @@ Contributions are very welcome in SQLGlot; read the [contribution guide](https:/
 * [Used By](#used-by)
 * [Documentation](#documentation)
 * [Run Tests and Lint](#run-tests-and-lint)
+* [Deployment](#deployment)
 * [Benchmarks](#benchmarks)
 * [Optional Dependencies](#optional-dependencies)
 * [Supported Dialects](#supported-dialects)
@@ -565,6 +566,21 @@ make test   # Unit and integration tests (or test-rs, to use the Rust tokenizer)
 make check  # Full test suite & linter checks
 ```
 
+## Deployment
+
+To deploy a new SQLGlot version, follow these steps:
+
+1. Run `git pull` to make sure the local git repo is at the head of the main branch
+2. If the Rust tokenizer code changed since the last version release:
+   1. Bump the `version` attribute under the `package` header in `sqlglotrs/Cargo.toml`
+   2. Run `make install-dev`. This will update the `Cargo.lock` file
+   3. Commit the changes made to `Cargo.toml` and `Cargo.lock`
+3. Do a `git tag` operation to bump the SQLGlot version, e.g. `git tag v28.5.0`
+4. Run `git push && git push --tags` to deploy the new version
+
+> [!IMPORTANT]
+> If there are any breaking changes since the last version release, make sure to deploy either a minor or major version for both sqlglot and sqlglotrs. Refer to SQLGlot's [versioning scheme](#versioning) for more information.
+
 ## Benchmarks
 
 [Benchmarks](https://github.com/tobymao/sqlglot/blob/main/benchmarks/bench.py) run on Python 3.10.12 in seconds.
@@ -627,3 +643,29 @@ x + interval '1' month
 **Official Dialects** are maintained by the core SQLGlot team with higher priority for bug fixes and feature additions.
 
 **Community Dialects** are developed and maintained primarily through community contributions. These are fully functional but may receive lower priority for issue resolution compared to officially supported dialects. We welcome and encourage community contributions to improve these dialects.
+
+### Creating a Dialect Plugin
+
+If your database isn't supported, you can create a plugin that registers a custom dialect via entry points. Create a package with your dialect class and register it in `setup.py`:
+
+```python
+from setuptools import setup
+
+setup(
+    name="mydb-sqlglot-dialect",
+    entry_points={
+        "sqlglot.dialects": [
+            "mydb = my_package.dialect:MyDB",
+        ],
+    },
+)
+```
+
+The dialect will be automatically discovered and can be used like any built-in dialect:
+
+```python
+from sqlglot import transpile
+transpile("SELECT * FROM t", read="mydb", write="postgres")
+```
+
+See the [Custom Dialects](#custom-dialects) section for implementation details.

{sqlglot-28.4.1 → sqlglot-28.6.0}/README.md

@@ -32,6 +32,7 @@ Contributions are very welcome in SQLGlot; read the [contribution guide](https:/
 * [Used By](#used-by)
 * [Documentation](#documentation)
 * [Run Tests and Lint](#run-tests-and-lint)
+* [Deployment](#deployment)
 * [Benchmarks](#benchmarks)
 * [Optional Dependencies](#optional-dependencies)
 * [Supported Dialects](#supported-dialects)
@@ -526,6 +527,21 @@ make test   # Unit and integration tests (or test-rs, to use the Rust tokenizer)
 make check  # Full test suite & linter checks
 ```
 
+## Deployment
+
+To deploy a new SQLGlot version, follow these steps:
+
+1. Run `git pull` to make sure the local git repo is at the head of the main branch
+2. If the Rust tokenizer code changed since the last version release:
+   1. Bump the `version` attribute under the `package` header in `sqlglotrs/Cargo.toml`
+   2. Run `make install-dev`. This will update the `Cargo.lock` file
+   3. Commit the changes made to `Cargo.toml` and `Cargo.lock`
+3. Do a `git tag` operation to bump the SQLGlot version, e.g. `git tag v28.5.0`
+4. Run `git push && git push --tags` to deploy the new version
+
+> [!IMPORTANT]
+> If there are any breaking changes since the last version release, make sure to deploy either a minor or major version for both sqlglot and sqlglotrs. Refer to SQLGlot's [versioning scheme](#versioning) for more information.
+
 ## Benchmarks
 
 [Benchmarks](https://github.com/tobymao/sqlglot/blob/main/benchmarks/bench.py) run on Python 3.10.12 in seconds.
@@ -588,3 +604,29 @@ x + interval '1' month
 **Official Dialects** are maintained by the core SQLGlot team with higher priority for bug fixes and feature additions.
 
 **Community Dialects** are developed and maintained primarily through community contributions. These are fully functional but may receive lower priority for issue resolution compared to officially supported dialects. We welcome and encourage community contributions to improve these dialects.
+
+### Creating a Dialect Plugin
+
+If your database isn't supported, you can create a plugin that registers a custom dialect via entry points. Create a package with your dialect class and register it in `setup.py`:
+
+```python
+from setuptools import setup
+
+setup(
+    name="mydb-sqlglot-dialect",
+    entry_points={
+        "sqlglot.dialects": [
+            "mydb = my_package.dialect:MyDB",
+        ],
+    },
+)
+```
+
+The dialect will be automatically discovered and can be used like any built-in dialect:
+
+```python
+from sqlglot import transpile
+transpile("SELECT * FROM t", read="mydb", write="postgres")
+```
+
+See the [Custom Dialects](#custom-dialects) section for implementation details.

{sqlglot-28.4.1 → sqlglot-28.6.0}/sqlglot/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '28.4.1'
-__version_tuple__ = version_tuple = (28, 4, 1)
+__version__ = version = '28.6.0'
+__version_tuple__ = version_tuple = (28, 6, 0)
 
-__commit_id__ = commit_id = 'gcfc9346ba'
+__commit_id__ = commit_id = 'g33b8a5d25'

{sqlglot-28.4.1 → sqlglot-28.6.0}/sqlglot/dialects/bigquery.py

@@ -51,6 +51,8 @@ JSON_EXTRACT_TYPE = t.Union[exp.JSONExtract, exp.JSONExtractScalar, exp.JSONExtr
 
 DQUOTES_ESCAPING_JSON_FUNCTIONS = ("JSON_QUERY", "JSON_VALUE", "JSON_QUERY_ARRAY")
 
+MAKE_INTERVAL_KWARGS = ["year", "month", "day", "hour", "minute", "second"]
+
 
 def _derived_table_values_to_unnest(self: BigQuery.Generator, expression: exp.Values) -> str:
     if not expression.find_ancestor(exp.From, exp.Join):
@@ -389,7 +391,9 @@ class BigQuery(Dialect):
     EXCLUDES_PSEUDOCOLUMNS_FROM_STAR = True
     QUERY_RESULTS_ARE_STRUCTS = True
     JSON_EXTRACT_SCALAR_SCALAR_ONLY = True
+    LEAST_GREATEST_IGNORES_NULLS = False
     DEFAULT_NULL_TYPE = exp.DataType.Type.BIGINT
+    PRIORITIZE_NON_LITERAL_TYPES = True
 
     # https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/string_functions#initcap
     INITCAP_DEFAULT_DELIMITER_CHARS = ' \t\n\r\f\v\\[\\](){}/|<>!?@"^#$&~_,.:;*%+\\-'
@@ -602,12 +606,6 @@ class BigQuery(Dialect):
             "EDIT_DISTANCE": _build_levenshtein,
             "FORMAT_DATE": _build_format_time(exp.TsOrDsToDate),
             "GENERATE_ARRAY": exp.GenerateSeries.from_arg_list,
-            "GREATEST": lambda args: exp.Greatest(
-                this=seq_get(args, 0), expressions=args[1:], null_if_any_null=True
-            ),
-            "LEAST": lambda args: exp.Least(
-                this=seq_get(args, 0), expressions=args[1:], null_if_any_null=True
-            ),
             "JSON_EXTRACT_SCALAR": _build_extract_json_with_default_path(exp.JSONExtractScalar),
             "JSON_EXTRACT_ARRAY": _build_extract_json_with_default_path(exp.JSONExtractArray),
             "JSON_EXTRACT_STRING_ARRAY": _build_extract_json_with_default_path(exp.JSONValueArray),
@@ -964,7 +962,7 @@ class BigQuery(Dialect):
         def _parse_make_interval(self) -> exp.MakeInterval:
             expr = exp.MakeInterval()
 
-            for arg_key in expr.arg_types:
+            for arg_key in MAKE_INTERVAL_KWARGS:
                 value = self._parse_lambda()
 
                 if not value:

{sqlglot-28.4.1 → sqlglot-28.6.0}/sqlglot/dialects/clickhouse.py

@@ -565,6 +565,8 @@ class ClickHouse(Dialect):
             "MEDIAN": lambda self: self._parse_quantile(),
             "COLUMNS": lambda self: self._parse_columns(),
             "TUPLE": lambda self: exp.Struct.from_arg_list(self._parse_function_args(alias=True)),
+            "AND": lambda self: exp.and_(*self._parse_function_args(alias=False)),
+            "OR": lambda self: exp.or_(*self._parse_function_args(alias=False)),
         }
 
         FUNCTION_PARSERS.pop("MATCH")

{sqlglot-28.4.1 → sqlglot-28.6.0}/sqlglot/dialects/dialect.py

@@ -27,6 +27,8 @@ from sqlglot.tokens import Token, Tokenizer, TokenType
 from sqlglot.trie import new_trie
 from sqlglot.typing import EXPRESSION_METADATA
 
+from importlib.metadata import entry_points
+
 DATE_ADD_OR_DIFF = t.Union[
     exp.DateAdd,
     exp.DateDiff,
@@ -66,6 +68,8 @@ UNESCAPED_SEQUENCES = {
     "\\\\": "\\",
 }
 
+PLUGIN_GROUP_NAME = "sqlglot.dialects"
+
 
 class Dialects(str, Enum):
     """Dialects supported by SQLGLot."""
@@ -153,12 +157,54 @@ class _Dialect(type):
         if isinstance(key, Dialects):
             key = key.value
 
-        # This import will lead to a new dialect being loaded, and hence, registered.
-        # We check that the key is an actual sqlglot module to avoid blindly importing
-        # files. Custom user dialects need to be imported at the top-level package, in
-        # order for them to be registered as soon as possible.
+        # 1. Try standard sqlglot modules first
         if key in DIALECT_MODULE_NAMES:
+            module = importlib.import_module(f"sqlglot.dialects.{key}")
+            # If module was already imported, the class may not be in _classes
+            # Find and register the dialect class from the module
+            if key not in cls._classes:
+                for attr_name in dir(module):
+                    attr = getattr(module, attr_name, None)
+                    if (
+                        isinstance(attr, type)
+                        and issubclass(attr, Dialect)
+                        and attr.__name__.lower() == key
+                    ):
+                        cls._classes[key] = attr
+                        break
+            return
+
+        # 2. Try entry points (for plugins)
+        try:
+            all_eps = entry_points()
+            # Python 3.10+ has select() method, older versions use dict-like access
+            if hasattr(all_eps, "select"):
+                eps = all_eps.select(group=PLUGIN_GROUP_NAME, name=key)
+            else:
+                # For older Python versions, entry_points() returns a dict-like object
+                group_eps = all_eps.get(PLUGIN_GROUP_NAME, [])  # type: ignore
+                eps = [ep for ep in group_eps if ep.name == key]  # type: ignore
+
+            for entry_point in eps:
+                dialect_class = entry_point.load()
+                # Verify it's a Dialect subclass
+                # issubclass() returns False if not a subclass, TypeError only if not a class at all
+                if isinstance(dialect_class, type) and issubclass(dialect_class, Dialect):
+                    # Register the dialect using the entry point name (key)
+                    # The metaclass may have registered it by class name, but we need it by entry point name
+                    if key not in cls._classes:
+                        cls._classes[key] = dialect_class
+                    return
+        except ImportError:
+            # entry_point.load() failed (bad plugin - module/class doesn't exist)
+            pass
+
+        # 3. Try direct import (for backward compatibility)
+        # This allows namespace packages or explicit imports to work
+        try:
             importlib.import_module(f"sqlglot.dialects.{key}")
+        except ImportError:
+            pass
 
     @classmethod
     def __getitem__(cls, key: str) -> t.Type[Dialect]:
@@ -741,6 +787,18 @@ class Dialect(metaclass=_Dialect):
     For example, in BigQuery the default type of the NULL value is INT64.
     """
 
+    LEAST_GREATEST_IGNORES_NULLS = True
+    """
+    Whether LEAST/GREATEST functions ignore NULL values, e.g:
+    - BigQuery, Snowflake, MySQL, Presto/Trino: LEAST(1, NULL, 2) -> NULL
+    - Spark, Postgres, DuckDB, TSQL: LEAST(1, NULL, 2) -> 1
+    """
+
+    PRIORITIZE_NON_LITERAL_TYPES = False
+    """
+    Whether to prioritize non-literal types over literals during type annotation.
+    """
+
     # --- Autofilled ---
 
     tokenizer_class = Tokenizer
@@ -935,7 +993,9 @@ class Dialect(metaclass=_Dialect):
 
             result = cls.get(dialect_name.strip())
             if not result:
-                suggest_closest_match_and_fail("dialect", dialect_name, list(DIALECT_MODULE_NAMES))
+                # Include both built-in dialects and any loaded dialects for better error messages
+                all_dialects = set(DIALECT_MODULE_NAMES) | set(cls._classes.keys())
+                suggest_closest_match_and_fail("dialect", dialect_name, all_dialects)
 
             assert result is not None
             return result(**kwargs)
@@ -1300,6 +1360,59 @@ def var_map_sql(
     return self.func(map_func_name, *args)
 
 
+def months_between_sql(self: Generator, expression: exp.MonthsBetween) -> str:
+    """
+    Transpile MONTHS_BETWEEN to dialects that don't have native support.
+
+    Snowflake's MONTHS_BETWEEN returns whole months + fractional part where:
+    - Fractional part = (DAY(date1) - DAY(date2)) / 31
+    - Special case: If both dates are last day of month, fractional part = 0
+
+    Formula: DATEDIFF('month', date2, date1) + (DAY(date1) - DAY(date2)) / 31.0
+    """
+    date1 = expression.this
+    date2 = expression.expression
+
+    # Cast to DATE to ensure consistent behavior
+    date1_cast = exp.cast(date1, exp.DataType.Type.DATE, copy=False)
+    date2_cast = exp.cast(date2, exp.DataType.Type.DATE, copy=False)
+
+    # Whole months: DATEDIFF('month', date2, date1)
+    whole_months = exp.DateDiff(this=date1_cast, expression=date2_cast, unit=exp.var("month"))
+
+    # Day components
+    day1 = exp.Day(this=date1_cast.copy())
+    day2 = exp.Day(this=date2_cast.copy())
+
+    # Last day of month components
+    last_day_of_month1 = exp.LastDay(this=date1_cast.copy())
+    last_day_of_month2 = exp.LastDay(this=date2_cast.copy())
+
+    day_of_last_day1 = exp.Day(this=last_day_of_month1)
+    day_of_last_day2 = exp.Day(this=last_day_of_month2)
+
+    # Check if both are last day of month
+    last_day1 = exp.EQ(this=day1.copy(), expression=day_of_last_day1)
+    last_day2 = exp.EQ(this=day2.copy(), expression=day_of_last_day2)
+    both_last_day = exp.And(this=last_day1, expression=last_day2)
+
+    # Fractional part: (DAY(date1) - DAY(date2)) / 31.0
+    fractional = exp.Div(
+        this=exp.Paren(this=exp.Sub(this=day1.copy(), expression=day2.copy())),
+        expression=exp.Literal.number("31.0"),
+    )
+
+    # If both are last day of month, fractional = 0, else calculate fractional
+    fractional_with_check = exp.If(
+        this=both_last_day, true=exp.Literal.number("0"), false=fractional
+    )
+
+    # Final result: whole_months + fractional
+    result = exp.Add(this=whole_months, expression=fractional_with_check)
+
+    return self.sql(result)
+
+
 def build_formatted_time(
     exp_class: t.Type[E], dialect: str, default: t.Optional[bool | str] = None
 ) -> t.Callable[[t.List], E]:
@@ -2154,3 +2267,24 @@ def regexp_replace_global_modifier(expression: exp.RegexpReplace) -> exp.Express
             modifiers = exp.Literal.string(value + "g")
 
     return modifiers
+
+
+def getbit_sql(self: Generator, expression: exp.Getbit) -> str:
+    """
+    Generates SQL for Getbit according to DuckDB and Postgres, transpiling it if either:
+
+    1. The zero index corresponds to the least-significant bit
+    2. The input type is an integer value
+    """
+    value = expression.this
+    position = expression.expression
+
+    if not expression.args.get("zero_is_msb") and expression.is_type(
+        *exp.DataType.SIGNED_INTEGER_TYPES, *exp.DataType.UNSIGNED_INTEGER_TYPES
+    ):
+        # Use bitwise operations: (value >> position) & 1
+        shifted = exp.BitwiseRightShift(this=value, expression=position)
+        masked = exp.BitwiseAnd(this=shifted, expression=exp.Literal.number(1))
+        return self.sql(masked)
+
+    return self.func("GET_BIT", value, position)

{sqlglot-28.4.1 → sqlglot-28.6.0}/sqlglot/dialects/doris.py

@@ -178,6 +178,7 @@ class Doris(MySQL):
         VARCHAR_REQUIRES_SIZE = False
         WITH_PROPERTIES_PREFIX = "PROPERTIES"
         RENAME_TABLE_WITH_DB = False
+        UPDATE_STATEMENT_SUPPORTS_FROM = True
 
         TYPE_MAPPING = {
             **MySQL.Generator.TYPE_MAPPING,

{sqlglot-28.4.1 → sqlglot-28.6.0}/sqlglot/dialects/druid.py

@@ -17,4 +17,5 @@ class Druid(Dialect):
             **generator.Generator.TRANSFORMS,
             exp.CurrentTimestamp: lambda *_: "CURRENT_TIMESTAMP",
             exp.Mod: rename_func("MOD"),
+            exp.Array: lambda self, e: f"ARRAY[{self.expressions(e)}]",
         }