sqlmesh 0.217.1.dev1__py3-none-any.whl → 0.227.2.dev4__py3-none-any.whl

sqlmesh/core/macros.py

@@ -128,6 +128,17 @@ def _macro_str_replace(text: str) -> str:
     return f"self.template({text}, locals())"
 
 
+class CaseInsensitiveMapping(t.Dict[str, t.Any]):
+    def __init__(self, data: t.Dict[str, t.Any]) -> None:
+        super().__init__(data)
+
+    def __getitem__(self, key: str) -> t.Any:
+        return super().__getitem__(key.lower())
+
+    def get(self, key: str, default: t.Any = None, /) -> t.Any:
+        return super().get(key.lower(), default)
+
+
 class MacroDialect(Python):
     class Generator(Python.Generator):
         TRANSFORMS = {
@@ -256,14 +267,18 @@ class MacroEvaluator:
                 changed = True
                 variables = self.variables
 
-                if node.name not in self.locals and node.name.lower() not in variables:
+                # This makes all variables case-insensitive, e.g. @X is the same as @x. We do this
+                # for consistency, since `variables` and `blueprint_variables` are normalized.
+                var_name = node.name.lower()
+
+                if var_name not in self.locals and var_name not in variables:
                     if not isinstance(node.parent, StagedFilePath):
                         raise SQLMeshError(f"Macro variable '{node.name}' is undefined.")
 
                     return node
 
                 # Precedence order is locals (e.g. @DEF) > blueprint variables > config variables
-                value = self.locals.get(node.name, variables.get(node.name.lower()))
+                value = self.locals.get(var_name, variables.get(var_name))
                 if isinstance(value, list):
                     return exp.convert(
                         tuple(
@@ -313,11 +328,16 @@ class MacroEvaluator:
         """
         # We try to convert all variables into sqlglot expressions because they're going to be converted
         # into strings; in sql we don't convert strings because that would result in adding quotes
-        mapping = {
-            k: convert_sql(v, self.dialect)
+        base_mapping = {
+            k.lower(): convert_sql(v, self.dialect)
             for k, v in chain(self.variables.items(), self.locals.items(), local_variables.items())
+            if k.lower()
+            not in (
+                "engine_adapter",
+                "snapshot",
+            )
         }
-        return MacroStrTemplate(str(text)).safe_substitute(mapping)
+        return MacroStrTemplate(str(text)).safe_substitute(CaseInsensitiveMapping(base_mapping))
 
     def evaluate(self, node: MacroFunc) -> exp.Expression | t.List[exp.Expression] | None:
         if isinstance(node, MacroDef):
@@ -327,7 +347,9 @@ class MacroEvaluator:
                     args[0] if len(args) == 1 else exp.Tuple(expressions=list(args))
                 )
             else:
-                self.locals[node.name] = self.transform(node.expression)
+                # Make variables defined through `@DEF` case-insensitive
+                self.locals[node.name.lower()] = self.transform(node.expression)
+
             return node
 
         if isinstance(node, (MacroSQL, MacroStrReplace)):
@@ -630,7 +652,7 @@ def _norm_var_arg_lambda(
     ) -> exp.Expression | t.List[exp.Expression] | None:
         if isinstance(node, (exp.Identifier, exp.Var)):
             if not isinstance(node.parent, exp.Column):
-                name = node.name
+                name = node.name.lower()
                 if name in args:
                     return args[name].copy()
                 if name in evaluator.locals:
@@ -663,7 +685,7 @@ def _norm_var_arg_lambda(
         return expressions, lambda args: func.this.transform(
             substitute,
             {
-                expression.name: arg
+                expression.name.lower(): arg
                 for expression, arg in zip(
                     func.expressions, args.expressions if isinstance(args, exp.Tuple) else [args]
                 )
@@ -1128,7 +1150,7 @@ def haversine_distance(
 def pivot(
     evaluator: MacroEvaluator,
     column: SQL,
-    values: t.List[SQL],
+    values: t.List[exp.Expression],
     alias: bool = True,
     agg: exp.Expression = exp.Literal.string("SUM"),
     cmp: exp.Expression = exp.Literal.string("="),
@@ -1146,10 +1168,10 @@ def pivot(
         >>> from sqlmesh.core.macros import MacroEvaluator
         >>> sql = "SELECT date_day, @PIVOT(status, ['cancelled', 'completed']) FROM rides GROUP BY 1"
         >>> MacroEvaluator().transform(parse_one(sql)).sql()
-        'SELECT date_day, SUM(CASE WHEN status = \\'cancelled\\' THEN 1 ELSE 0 END) AS "\\'cancelled\\'", SUM(CASE WHEN status = \\'completed\\' THEN 1 ELSE 0 END) AS "\\'completed\\'" FROM rides GROUP BY 1'
+        'SELECT date_day, SUM(CASE WHEN status = \\'cancelled\\' THEN 1 ELSE 0 END) AS "cancelled", SUM(CASE WHEN status = \\'completed\\' THEN 1 ELSE 0 END) AS "completed" FROM rides GROUP BY 1'
         >>> sql = "SELECT @PIVOT(a, ['v'], then_value := tv, suffix := '_sfx', quote := FALSE)"
         >>> MacroEvaluator(dialect="bigquery").transform(parse_one(sql)).sql("bigquery")
-        "SELECT SUM(CASE WHEN a = 'v' THEN tv ELSE 0 END) AS `v_sfx`"
+        "SELECT SUM(CASE WHEN a = 'v' THEN tv ELSE 0 END) AS v_sfx"
     """
     aggregates: t.List[exp.Expression] = []
     for value in values:
@@ -1157,12 +1179,12 @@ def pivot(
         if distinct:
             proj += "DISTINCT "
 
-        proj += f"CASE WHEN {column} {cmp.name} {value} THEN {then_value} ELSE {else_value} END) "
+        proj += f"CASE WHEN {column} {cmp.name} {value.sql(evaluator.dialect)} THEN {then_value} ELSE {else_value} END) "
         node = evaluator.parse_one(proj)
 
         if alias:
             node = node.as_(
-                f"{prefix.name}{value}{suffix.name}",
+                f"{prefix.name}{value.name}{suffix.name}",
                 quoted=quote,
                 copy=False,
                 dialect=evaluator.dialect,

sqlmesh/core/model/common.py

@@ -641,6 +641,7 @@ properties_validator: t.Callable = field_validator(
     "physical_properties_",
     "virtual_properties_",
     "materialization_properties_",
+    "grants_",
     mode="before",
     check_fields=False,
 )(parse_properties)
@@ -662,6 +663,7 @@ depends_on_validator: t.Callable = field_validator(
 
 class ParsableSql(PydanticModel):
     sql: str
+    transaction: t.Optional[bool] = None
 
     _parsed: t.Optional[exp.Expression] = None
     _parsed_dialect: t.Optional[str] = None

sqlmesh/core/model/definition.py

@@ -67,6 +67,7 @@ if t.TYPE_CHECKING:
     from sqlmesh.core.context import ExecutionContext
     from sqlmesh.core.engine_adapter import EngineAdapter
     from sqlmesh.core.engine_adapter._typing import QueryOrDF
+    from sqlmesh.core.engine_adapter.shared import DataObjectType
     from sqlmesh.core.linter.rule import Rule
     from sqlmesh.core.snapshot import DeployabilityIndex, Node, Snapshot
     from sqlmesh.utils.jinja import MacroReference
@@ -362,6 +363,7 @@ class _Model(ModelMeta, frozen=True):
         expand: t.Iterable[str] = tuple(),
         deployability_index: t.Optional[DeployabilityIndex] = None,
         engine_adapter: t.Optional[EngineAdapter] = None,
+        inside_transaction: t.Optional[bool] = True,
         **kwargs: t.Any,
     ) -> t.List[exp.Expression]:
         """Renders pre-statements for a model.
@@ -383,7 +385,11 @@ class _Model(ModelMeta, frozen=True):
             The list of rendered expressions.
         """
         return self._render_statements(
-            self.pre_statements,
+            [
+                stmt
+                for stmt in self.pre_statements
+                if stmt.args.get("transaction", True) == inside_transaction
+            ],
             start=start,
             end=end,
             execution_time=execution_time,
@@ -404,6 +410,7 @@ class _Model(ModelMeta, frozen=True):
         expand: t.Iterable[str] = tuple(),
         deployability_index: t.Optional[DeployabilityIndex] = None,
         engine_adapter: t.Optional[EngineAdapter] = None,
+        inside_transaction: t.Optional[bool] = True,
         **kwargs: t.Any,
     ) -> t.List[exp.Expression]:
         """Renders post-statements for a model.
@@ -419,13 +426,18 @@ class _Model(ModelMeta, frozen=True):
                 that depend on materialized tables.  Model definitions are inlined and can thus be run end to
                 end on the fly.
             deployability_index: Determines snapshots that are deployable in the context of this render.
+            inside_transaction: Whether to render hooks with transaction=True (inside) or transaction=False (outside).
             kwargs: Additional kwargs to pass to the renderer.
 
         Returns:
             The list of rendered expressions.
         """
         return self._render_statements(
-            self.post_statements,
+            [
+                stmt
+                for stmt in self.post_statements
+                if stmt.args.get("transaction", True) == inside_transaction
+            ],
             start=start,
             end=end,
             execution_time=execution_time,
@@ -566,6 +578,8 @@ class _Model(ModelMeta, frozen=True):
         result = []
         for v in value:
             parsed = v.parse(self.dialect)
+            if getattr(v, "transaction", None) is not None:
+                parsed.set("transaction", v.transaction)
             if not isinstance(parsed, exp.Semicolon):
                 result.append(parsed)
         return result
@@ -1186,6 +1200,8 @@ class _Model(ModelMeta, frozen=True):
                 gen(self.session_properties_) if self.session_properties_ else None,
                 *[gen(g) for g in self.grains],
                 *self._audit_metadata_hash_values(),
+                json.dumps(self.grants, sort_keys=True) if self.grants else None,
+                self.grants_target_layer,
             ]
 
             for key, value in (self.virtual_properties or {}).items():
@@ -1197,6 +1213,9 @@ class _Model(ModelMeta, frozen=True):
                 for k, v in sorted(args.items()):
                     metadata.append(f"{k}:{gen(v)}")
 
+            if self.dbt_node_info:
+                metadata.append(self.dbt_node_info.json(sort_keys=True))
+
             metadata.extend(self._additional_metadata)
 
             self._metadata_hash = hash_data(metadata)
@@ -1207,6 +1226,24 @@ class _Model(ModelMeta, frozen=True):
         """Return True if this is a model node"""
         return True
 
+    @property
+    def grants_table_type(self) -> DataObjectType:
+        """Get the table type for grants application (TABLE, VIEW, MATERIALIZED_VIEW).
+
+        Returns:
+            The DataObjectType that should be used when applying grants to this model.
+        """
+        from sqlmesh.core.engine_adapter.shared import DataObjectType
+
+        if self.kind.is_view:
+            if hasattr(self.kind, "materialized") and getattr(self.kind, "materialized", False):
+                return DataObjectType.MATERIALIZED_VIEW
+            return DataObjectType.VIEW
+        if self.kind.is_managed:
+            return DataObjectType.MANAGED_TABLE
+        # All other materialized models are tables
+        return DataObjectType.TABLE
+
     @property
     def _additional_metadata(self) -> t.List[str]:
         additional_metadata = []
@@ -1820,6 +1857,12 @@ class SeedModel(_Model):
         for column_name, column_hash in self.column_hashes.items():
             data.append(column_name)
             data.append(column_hash)
+
+        # Include grants in data hash for seed models to force recreation on grant changes
+        # since seed models don't support migration
+        data.append(json.dumps(self.grants, sort_keys=True) if self.grants else "")
+        data.append(self.grants_target_layer)
+
         return data
 
 
@@ -2562,9 +2605,17 @@ def _create_model(
         if statement_field in kwargs:
             # Macros extracted from these statements need to be treated as metadata only
             is_metadata = statement_field == "on_virtual_update"
-            statements.extend((stmt, is_metadata) for stmt in kwargs[statement_field])
+            for stmt in kwargs[statement_field]:
+                # Extract the expression if it's ParsableSql already
+                expr = stmt.parse(dialect) if isinstance(stmt, ParsableSql) else stmt
+                statements.append((expr, is_metadata))
             kwargs[statement_field] = [
-                ParsableSql.from_parsed_expression(stmt, dialect, use_meta_sql=use_original_sql)
+                # this to retain the transaction information
+                stmt
+                if isinstance(stmt, ParsableSql)
+                else ParsableSql.from_parsed_expression(
+                    stmt, dialect, use_meta_sql=use_original_sql
+                )
                 for stmt in kwargs[statement_field]
             ]
 
@@ -2866,6 +2917,13 @@ def render_meta_fields(
             for key, value in field_value.items():
                 if key in RUNTIME_RENDERED_MODEL_FIELDS:
                     rendered_dict[key] = parse_strings_with_macro_refs(value, dialect)
+                elif (
+                    # don't parse kind auto_restatement_cron="@..." kwargs (e.g. @daily) into MacroVar
+                    key == "auto_restatement_cron"
+                    and isinstance(value, str)
+                    and value.lower() in CRON_SHORTCUTS
+                ):
+                    rendered_dict[key] = value
                 elif (rendered := render_field_value(value)) is not None:
                     rendered_dict[key] = rendered
 
@@ -3012,6 +3070,9 @@ META_FIELD_CONVERTER: t.Dict[str, t.Callable] = {
     "formatting": str,
     "optimize_query": str,
     "virtual_environment_mode": lambda value: exp.Literal.string(value.value),
+    "dbt_node_info_": lambda value: value.to_expression(),
+    "grants_": lambda value: value,
+    "grants_target_layer": lambda value: exp.Literal.string(value.value),
 }
 
 

sqlmesh/core/model/kind.py

@@ -23,7 +23,7 @@ from sqlmesh.utils.pydantic import (
     PydanticModel,
     SQLGlotBool,
     SQLGlotColumn,
-    SQLGlotListOfColumnsOrStar,
+    SQLGlotListOfFieldsOrStar,
     SQLGlotListOfFields,
     SQLGlotPositiveInt,
     SQLGlotString,
@@ -119,6 +119,10 @@ class ModelKindMixin:
     def is_managed(self) -> bool:
         return self.model_kind_name == ModelKindName.MANAGED
 
+    @property
+    def is_dbt_custom(self) -> bool:
+        return self.model_kind_name == ModelKindName.DBT_CUSTOM
+
     @property
     def is_symbolic(self) -> bool:
         """A symbolic model is one that doesn't execute at all."""
@@ -150,6 +154,11 @@ class ModelKindMixin:
     def supports_python_models(self) -> bool:
         return True
 
+    @property
+    def supports_grants(self) -> bool:
+        """Whether this model kind supports grants configuration."""
+        return self.is_materialized or self.is_view
+
 
 class ModelKindName(str, ModelKindMixin, Enum):
     """The kind of model, determining how this data is computed and stored in the warehouse."""
@@ -170,6 +179,7 @@ class ModelKindName(str, ModelKindMixin, Enum):
     EXTERNAL = "EXTERNAL"
     CUSTOM = "CUSTOM"
     MANAGED = "MANAGED"
+    DBT_CUSTOM = "DBT_CUSTOM"
 
     @property
     def model_kind_name(self) -> t.Optional[ModelKindName]:
@@ -842,7 +852,7 @@ class SCDType2ByTimeKind(_SCDType2Kind):
 
 class SCDType2ByColumnKind(_SCDType2Kind):
     name: t.Literal[ModelKindName.SCD_TYPE_2_BY_COLUMN] = ModelKindName.SCD_TYPE_2_BY_COLUMN
-    columns: SQLGlotListOfColumnsOrStar
+    columns: SQLGlotListOfFieldsOrStar
     execution_time_as_valid_from: SQLGlotBool = False
     updated_at_name: t.Optional[SQLGlotColumn] = None
 
@@ -887,6 +897,46 @@ class ManagedKind(_ModelKind):
         return False
 
 
+class DbtCustomKind(_ModelKind):
+    name: t.Literal[ModelKindName.DBT_CUSTOM] = ModelKindName.DBT_CUSTOM
+    materialization: str
+    adapter: str = "default"
+    definition: str
+    dialect: t.Optional[str] = Field(None, validate_default=True)
+
+    _dialect_validator = kind_dialect_validator
+
+    @field_validator("materialization", "adapter", "definition", mode="before")
+    @classmethod
+    def _validate_fields(cls, v: t.Any) -> str:
+        return validate_string(v)
+
+    @property
+    def data_hash_values(self) -> t.List[t.Optional[str]]:
+        return [
+            *super().data_hash_values,
+            self.materialization,
+            self.definition,
+            self.adapter,
+            self.dialect,
+        ]
+
+    def to_expression(
+        self, expressions: t.Optional[t.List[exp.Expression]] = None, **kwargs: t.Any
+    ) -> d.ModelKind:
+        return super().to_expression(
+            expressions=[
+                *(expressions or []),
+                *_properties(
+                    {
+                        "materialization": exp.Literal.string(self.materialization),
+                        "adapter": exp.Literal.string(self.adapter),
+                    }
+                ),
+            ],
+        )
+
+
 class EmbeddedKind(_ModelKind):
     name: t.Literal[ModelKindName.EMBEDDED] = ModelKindName.EMBEDDED
 
@@ -992,6 +1042,7 @@ ModelKind = t.Annotated[
         SCDType2ByColumnKind,
         CustomKind,
         ManagedKind,
+        DbtCustomKind,
     ],
     Field(discriminator="name"),
 ]
@@ -1011,6 +1062,7 @@ MODEL_KIND_NAME_TO_TYPE: t.Dict[str, t.Type[ModelKind]] = {
     ModelKindName.SCD_TYPE_2_BY_COLUMN: SCDType2ByColumnKind,
     ModelKindName.CUSTOM: CustomKind,
     ModelKindName.MANAGED: ManagedKind,
+    ModelKindName.DBT_CUSTOM: DbtCustomKind,
 }
 
 
@@ -1053,6 +1105,18 @@ def create_model_kind(v: t.Any, dialect: str, defaults: t.Dict[str, t.Any]) -> M
                 ):
                     props[on_change_property] = defaults.get(on_change_property)
 
+        # only pass the batch_concurrency user default to models inheriting from _IncrementalBy
+        # that don't explicitly set it in the model definition, but ignore subclasses of _IncrementalBy
+        # that hardcode a specific batch_concurrency
+        if issubclass(kind_type, _IncrementalBy):
+            BATCH_CONCURRENCY: t.Final = "batch_concurrency"
+            if (
+                props.get(BATCH_CONCURRENCY) is None
+                and defaults.get(BATCH_CONCURRENCY) is not None
+                and kind_type.all_field_infos()[BATCH_CONCURRENCY].default is None
+            ):
+                props[BATCH_CONCURRENCY] = defaults.get(BATCH_CONCURRENCY)
+
         if kind_type == CustomKind:
             # load the custom materialization class and check if it uses a custom kind type
             from sqlmesh.core.snapshot.evaluator import get_custom_materialization_type

sqlmesh/core/model/meta.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import typing as t
+from enum import Enum
 from functools import cached_property
 from typing_extensions import Self
 
@@ -13,6 +14,7 @@ from sqlmesh.core import dialect as d
 from sqlmesh.core.config.common import VirtualEnvironmentMode
 from sqlmesh.core.config.linter import LinterConfig
 from sqlmesh.core.dialect import normalize_model_name
+from sqlmesh.utils import classproperty
 from sqlmesh.core.model.common import (
     bool_validator,
     default_catalog_validator,
@@ -46,10 +48,41 @@ from sqlmesh.utils.pydantic import (
 
 if t.TYPE_CHECKING:
     from sqlmesh.core._typing import CustomMaterializationProperties, SessionProperties
+    from sqlmesh.core.engine_adapter._typing import GrantsConfig
 
 FunctionCall = t.Tuple[str, t.Dict[str, exp.Expression]]
 
 
+class GrantsTargetLayer(str, Enum):
+    """Target layer(s) where grants should be applied."""
+
+    ALL = "all"
+    PHYSICAL = "physical"
+    VIRTUAL = "virtual"
+
+    @classproperty
+    def default(cls) -> "GrantsTargetLayer":
+        return GrantsTargetLayer.VIRTUAL
+
+    @property
+    def is_all(self) -> bool:
+        return self == GrantsTargetLayer.ALL
+
+    @property
+    def is_physical(self) -> bool:
+        return self == GrantsTargetLayer.PHYSICAL
+
+    @property
+    def is_virtual(self) -> bool:
+        return self == GrantsTargetLayer.VIRTUAL
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return str(self)
+
+
 class ModelMeta(_Node):
     """Metadata for models which can be defined in SQL."""
 
@@ -85,6 +118,8 @@ class ModelMeta(_Node):
     )
     formatting: t.Optional[bool] = Field(default=None, exclude=True)
     virtual_environment_mode: VirtualEnvironmentMode = VirtualEnvironmentMode.default
+    grants_: t.Optional[exp.Tuple] = Field(default=None, alias="grants")
+    grants_target_layer: GrantsTargetLayer = GrantsTargetLayer.default
 
     _bool_validator = bool_validator
     _model_kind_validator = model_kind_validator
@@ -247,11 +282,15 @@ class ModelMeta(_Node):
 
         columns_to_types = info.data.get("columns_to_types_")
         if columns_to_types:
-            for column_name in col_descriptions:
+            from sqlmesh.core.console import get_console
+
+            console = get_console()
+            for column_name in list(col_descriptions):
                 if column_name not in columns_to_types:
-                    raise ConfigError(
+                    console.log_warning(
                         f"In model '{info.data['name']}', a description is provided for column '{column_name}' but it is not a column in the model."
                     )
+                    del col_descriptions[column_name]
 
         return col_descriptions
 
@@ -283,6 +322,14 @@ class ModelMeta(_Node):
     def ignored_rules_validator(cls, vs: t.Any) -> t.Any:
         return LinterConfig._validate_rules(vs)
 
+    @field_validator("grants_target_layer", mode="before")
+    def _grants_target_layer_validator(cls, v: t.Any) -> t.Any:
+        if isinstance(v, exp.Identifier):
+            return v.this
+        if isinstance(v, exp.Literal) and v.is_string:
+            return v.this
+        return v
+
     @field_validator("session_properties_", mode="before")
     def session_properties_validator(cls, v: t.Any, info: ValidationInfo) -> t.Any:
         # use the generic properties validator to parse the session properties
@@ -390,6 +437,10 @@ class ModelMeta(_Node):
                 f"Model {self.name} has `storage_format` set to a table format '{storage_format}' which is deprecated. Please use the `table_format` property instead."
             )
 
+        # Validate grants configuration for model kind support
+        if self.grants is not None and not kind.supports_grants:
+            raise ValueError(f"grants cannot be set for {kind.name} models")
+
         return self
 
     @property
@@ -461,6 +512,30 @@ class ModelMeta(_Node):
             return self.kind.materialization_properties
         return {}
 
+    @cached_property
+    def grants(self) -> t.Optional[GrantsConfig]:
+        """A dictionary of grants mapping permission names to lists of grantees."""
+
+        if self.grants_ is None:
+            return None
+
+        if not self.grants_.expressions:
+            return {}
+
+        grants_dict = {}
+        for eq_expr in self.grants_.expressions:
+            try:
+                permission_name = self._validate_config_expression(eq_expr.left)
+                grantee_list = self._validate_nested_config_values(eq_expr.expression)
+                grants_dict[permission_name] = grantee_list
+            except ConfigError as e:
+                permission_name = (
+                    eq_expr.left.name if hasattr(eq_expr.left, "name") else str(eq_expr.left)
+                )
+                raise ConfigError(f"Invalid grants configuration for '{permission_name}': {e}")
+
+        return grants_dict if grants_dict else None
+
     @property
     def all_references(self) -> t.List[Reference]:
         """All references including grains."""
@@ -525,3 +600,33 @@ class ModelMeta(_Node):
     @property
     def ignored_rules(self) -> t.Set[str]:
         return self.ignored_rules_ or set()
+
+    def _validate_config_expression(self, expr: exp.Expression) -> str:
+        if isinstance(expr, (d.MacroFunc, d.MacroVar)):
+            raise ConfigError(f"Unresolved macro: {expr.sql(dialect=self.dialect)}")
+
+        if isinstance(expr, exp.Null):
+            raise ConfigError("NULL value")
+
+        if isinstance(expr, exp.Literal):
+            return str(expr.this).strip()
+        if isinstance(expr, (exp.Column, exp.Identifier)):
+            return expr.name
+        return expr.sql(dialect=self.dialect).strip()
+
+    def _validate_nested_config_values(self, value_expr: exp.Expression) -> t.List[str]:
+        result = []
+
+        def flatten_expr(expr: exp.Expression) -> None:
+            if isinstance(expr, exp.Array):
+                for elem in expr.expressions:
+                    flatten_expr(elem)
+            elif isinstance(expr, (exp.Tuple, exp.Paren)):
+                expressions = [expr.unnest()] if isinstance(expr, exp.Paren) else expr.expressions
+                for elem in expressions:
+                    flatten_expr(elem)
+            else:
+                result.append(self._validate_config_expression(expr))
+
+        flatten_expr(value_expr)
+        return result