sqlbuild 0.101.14__tar.gz → 0.101.16__tar.gz

{sqlbuild-0.101.14 → sqlbuild-0.101.16}/Cargo.lock

@@ -529,7 +529,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.101.14"
+version = "0.101.16"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.101.14 → sqlbuild-0.101.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.101.14
+Version: 0.101.16
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: orjson>=3.10.0

{sqlbuild-0.101.14 → sqlbuild-0.101.16}/crates/sqlbuild-rules-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-rules-native"
-version = "0.101.14"
+version = "0.101.16"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.101.14 → sqlbuild-0.101.16}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.101.14"
+version = "0.101.16"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlbuild-0.101.14 → sqlbuild-0.101.16}/src/sqlbuild/adapters/snowflake/classes/snowflake_adapter.py

@@ -2152,9 +2152,33 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
                 "UPPER": first_arg_nullability,
             },
             function_return_types={
+                "DATE_FROM_PARTS": "DATE",
+                "LISTAGG": "TEXT",
+                "LIST_AGG": "TEXT",
+                "OBJECT_AGG": "OBJECT",
+                "OBJECT_CONSTRUCT": "OBJECT",
+                "REGEXP_REPLACE": "TEXT",
+                "REGEXP_SUBSTR": "TEXT",
+                "REPLACE": "TEXT",
+                "SPLIT_PART": "TEXT",
+                "STRING_AGG": "TEXT",
                 "TO_ARRAY": "ARRAY",
+                "TO_DATE": "DATE",
+                "TO_JSON": "TEXT",
                 "TO_OBJECT": "OBJECT",
+                "TO_TIMESTAMP": "TIMESTAMP",
+                "TO_TIMESTAMP_LTZ": "TIMESTAMP_LTZ",
+                "TO_TIMESTAMP_NTZ": "TIMESTAMP_NTZ",
+                "TO_TIMESTAMP_TZ": "TIMESTAMP_TZ",
                 "TO_VARIANT": "VARIANT",
+                "TO_VARCHAR": "TEXT",
+                "TRIM": "TEXT",
+                "TRY_TO_DATE": "DATE",
+                "TRY_TO_DOUBLE": "FLOAT",
+                "TRY_TO_TIMESTAMP": "TIMESTAMP",
+                "TRY_TO_TIMESTAMP_LTZ": "TIMESTAMP_LTZ",
+                "TRY_TO_TIMESTAMP_NTZ": "TIMESTAMP_NTZ",
+                "TRY_TO_TIMESTAMP_TZ": "TIMESTAMP_TZ",
             },
         )
 

{sqlbuild-0.101.14 → sqlbuild-0.101.16}/src/sqlbuild/compiler/compile/_helpers/analysis/columns.py

@@ -1208,8 +1208,11 @@ def _polyglot_expression_type(
     *, expression: Any, inference_profile: ExpressionInferenceProfile
 ) -> str | None:
     kind: str = str(getattr(expression, "kind", ""))
-    function_type: str | None = inference_profile.function_return_type(
-        str(getattr(expression, "name", ""))
+    function_name: str = str(getattr(expression, "name", "")) or kind
+    function_type: str | None = (
+        inference_profile.function_return_type(function_name)
+        if kind != _POLYGLOT_KIND_COLUMN
+        else None
     )
     if function_type is not None:
         return function_type

{sqlbuild-0.101.14 → sqlbuild-0.101.16}/src/sqlbuild/compiler/compile/_helpers/analysis/cte_facts.py

@@ -5,19 +5,52 @@ from __future__ import annotations
 from typing import Any, Protocol, cast
 
 from sqlbuild.adapter.contract.models import ExpressionInferenceProfile
+from sqlbuild.adapter.contract.types import TypeFamily
+from sqlbuild.adapter.type_system.main.normalize_type import normalize_type
+from sqlbuild.adapter.type_system.main.types_equal import types_equal
 from sqlbuild.compiler.compile.constants import SQL_WILDCARD_TOKEN
 from sqlbuild.compiler.lineage.types import InferredNullability
-from sqlbuild.compiler.sql_analysis.constants import POLYGLOT_CAST_KINDS as _POLYGLOT_CAST_KINDS
+from sqlbuild.compiler.sql_analysis.constants import (
+    POLYGLOT_BINARY_OPERAND_COUNT as _POLYGLOT_BINARY_OPERAND_COUNT,
+)
+from sqlbuild.compiler.sql_analysis.constants import (
+    POLYGLOT_BOOLEAN_RESULT_KINDS as _POLYGLOT_BOOLEAN_RESULT_KINDS,
+)
 from sqlbuild.compiler.sql_analysis.constants import POLYGLOT_KIND_ALIAS as _POLYGLOT_KIND_ALIAS
 from sqlbuild.compiler.sql_analysis.constants import (
     POLYGLOT_KIND_ANNOTATED as _POLYGLOT_KIND_ANNOTATED,
 )
+from sqlbuild.compiler.sql_analysis.constants import POLYGLOT_KIND_CASE as _POLYGLOT_KIND_CASE
+from sqlbuild.compiler.sql_analysis.constants import (
+    POLYGLOT_KIND_COALESCE as _POLYGLOT_KIND_COALESCE,
+)
 from sqlbuild.compiler.sql_analysis.constants import POLYGLOT_KIND_COLUMN as _POLYGLOT_KIND_COLUMN
+from sqlbuild.compiler.sql_analysis.constants import POLYGLOT_KIND_CONCAT as _POLYGLOT_KIND_CONCAT
+from sqlbuild.compiler.sql_analysis.constants import (
+    POLYGLOT_KIND_FUNCTION as _POLYGLOT_KIND_FUNCTION,
+)
+from sqlbuild.compiler.sql_analysis.constants import (
+    POLYGLOT_KIND_IF_FUNC as _POLYGLOT_KIND_IF_FUNC,
+)
+from sqlbuild.compiler.sql_analysis.constants import POLYGLOT_KIND_LITERAL as _POLYGLOT_KIND_LITERAL
+from sqlbuild.compiler.sql_analysis.constants import POLYGLOT_KIND_NULL as _POLYGLOT_KIND_NULL
 from sqlbuild.compiler.sql_analysis.constants import POLYGLOT_KIND_SELECT as _POLYGLOT_KIND_SELECT
+from sqlbuild.compiler.sql_analysis.constants import (
+    POLYGLOT_KIND_SUBSTRING as _POLYGLOT_KIND_SUBSTRING,
+)
 from sqlbuild.compiler.sql_analysis.constants import POLYGLOT_KIND_TABLE as _POLYGLOT_KIND_TABLE
+from sqlbuild.compiler.sql_analysis.constants import (
+    POLYGLOT_LITERAL_TYPE_STRING as _POLYGLOT_LITERAL_TYPE_STRING,
+)
+from sqlbuild.compiler.sql_analysis.constants import (
+    POLYGLOT_NULLIF_FUNCTION_NAME as _POLYGLOT_NULLIF_FUNCTION_NAME,
+)
 from sqlbuild.compiler.sql_analysis.constants import (
     POLYGLOT_PAYLOAD_COLUMN as _POLYGLOT_PAYLOAD_COLUMN,
 )
+from sqlbuild.compiler.sql_analysis.constants import (
+    POLYGLOT_PAYLOAD_LITERAL_TYPE as _POLYGLOT_PAYLOAD_LITERAL_TYPE,
+)
 from sqlbuild.compiler.sql_analysis.constants import POLYGLOT_PAYLOAD_NAME as _POLYGLOT_PAYLOAD_NAME
 from sqlbuild.compiler.sql_analysis.constants import (
     POLYGLOT_PAYLOAD_TABLE as _POLYGLOT_PAYLOAD_TABLE,
@@ -25,6 +58,11 @@ from sqlbuild.compiler.sql_analysis.constants import (
 from sqlbuild.compiler.sql_analysis.constants import (
     POLYGLOT_SET_OPERATION_KINDS as _POLYGLOT_SET_OPERATION_KINDS,
 )
+from sqlbuild.compiler.sql_analysis.constants import (
+    POLYGLOT_TYPE_PASSTHROUGH_KINDS as _POLYGLOT_TYPE_PASSTHROUGH_KINDS,
+)
+
+_NULL_SET_OPERATION_TYPE: str = "__SQLBUILD_NULL_SET_OPERATION_TYPE__"
 
 
 class _ExpressionTypeResolver(Protocol):
@@ -245,8 +283,8 @@ def _polyglot_direct_select_output_nullability(
     )
     inferred: dict[str, InferredNullability] = {}
     projection: Any
-    for projection in getattr(select, "expressions", ()):
-        projection = _unwrap_polyglot_annotations(projection)
+    for raw_projection in getattr(select, "expressions", ()):
+        projection: Any = _unwrap_polyglot_annotations(raw_projection)
         if bool(getattr(projection, "is_star", False)):
             continue
         output_name: str = str(getattr(projection, "output_name", "") or "")
@@ -365,6 +403,7 @@ def _polyglot_select_output_types(
     inference_profile: ExpressionInferenceProfile,
     expression_type_resolver: _ExpressionTypeResolver,
 ) -> dict[str, str]:
+    select = _unwrap_polyglot_annotations(select)
     if _polyglot_top_level_ctes(select):
         return _polyglot_cte_passthrough_types_from_parsed(
             parsed=select,
@@ -394,26 +433,190 @@ def _polyglot_set_operation_output_types(
     inference_profile: ExpressionInferenceProfile,
     expression_type_resolver: _ExpressionTypeResolver,
 ) -> dict[str, str]:
-    branch_types: list[dict[str, str]] = []
+    if bool(getattr(operation, "args", {}).get("by_name")):
+        branch_types: list[dict[str, str]] = []
+        for side in ("left", "right"):
+            branch: Any = getattr(operation, "args", {}).get(side)
+            if branch is None:
+                return {}
+            branch_types.append(
+                _polyglot_select_output_types(
+                    select=branch,
+                    relation_types=relation_types,
+                    inference_profile=inference_profile,
+                    expression_type_resolver=expression_type_resolver,
+                )
+            )
+        left_types, right_types = branch_types
+        return {
+            name: common_type
+            for name, left_type in left_types.items()
+            if (
+                common_type := _polyglot_common_set_operation_type(
+                    left=left_type,
+                    right=_case_insensitive_mapping_get(mapping=right_types, key=name),
+                    inference_profile=inference_profile,
+                )
+            )
+            is not None
+        }
+    branch_slots: list[tuple[tuple[str, str | None], ...]] = []
     for side in ("left", "right"):
         branch: Any = getattr(operation, "args", {}).get(side)
         if branch is None:
             return {}
-        inferred: dict[str, str] = _polyglot_select_output_types(
+        inferred: tuple[tuple[str, str | None], ...] = _polyglot_select_output_type_slots(
             select=branch,
             relation_types=relation_types,
             inference_profile=inference_profile,
             expression_type_resolver=expression_type_resolver,
         )
-        branch_types.append(inferred)
-    left_types, right_types = branch_types
-    if bool(getattr(operation, "args", {}).get("by_name")):
-        return {
-            name: left_type
-            for name, left_type in left_types.items()
-            if _case_insensitive_mapping_get(mapping=right_types, key=name) == left_type
-        }
-    return {}
+        if not inferred:
+            return {}
+        branch_slots.append(inferred)
+    left_slots, right_slots = branch_slots
+    if len(left_slots) != len(right_slots):
+        return {}
+    return {
+        left_name: common_type
+        for (left_name, left_type), (_, right_type) in zip(
+            left_slots,
+            right_slots,
+            strict=True,
+        )
+        if (
+            common_type := _polyglot_common_set_operation_type(
+                left=left_type,
+                right=right_type,
+                inference_profile=inference_profile,
+            )
+        )
+        is not None
+    }
+
+
+def _polyglot_select_output_type_slots(
+    *,
+    select: Any,
+    relation_types: dict[str, dict[str, str]],
+    inference_profile: ExpressionInferenceProfile,
+    expression_type_resolver: _ExpressionTypeResolver,
+) -> tuple[tuple[str, str | None], ...]:
+    select = _unwrap_polyglot_annotations(select)
+    if str(getattr(select, "kind", "")) in _POLYGLOT_SET_OPERATION_KINDS:
+        branch_slots: list[tuple[tuple[str, str | None], ...]] = []
+        for side in ("left", "right"):
+            branch: Any = getattr(select, "args", {}).get(side)
+            if branch is None:
+                return ()
+            slots: tuple[tuple[str, str | None], ...] = _polyglot_select_output_type_slots(
+                select=branch,
+                relation_types=relation_types,
+                inference_profile=inference_profile,
+                expression_type_resolver=expression_type_resolver,
+            )
+            if not slots:
+                return ()
+            branch_slots.append(slots)
+        left_slots, right_slots = branch_slots
+        if bool(getattr(select, "args", {}).get("by_name")):
+            right_types: dict[str, str | None] = dict(right_slots)
+            return tuple(
+                (
+                    name,
+                    _polyglot_common_set_operation_type(
+                        left=left_type,
+                        right=_case_insensitive_mapping_get(mapping=right_types, key=name),
+                        inference_profile=inference_profile,
+                    ),
+                )
+                for name, left_type in left_slots
+            )
+        if len(left_slots) != len(right_slots):
+            return ()
+        return tuple(
+            (
+                left_name,
+                _polyglot_common_set_operation_type(
+                    left=left_type,
+                    right=right_type,
+                    inference_profile=inference_profile,
+                ),
+            )
+            for (left_name, left_type), (_, right_type) in zip(
+                left_slots,
+                right_slots,
+                strict=True,
+            )
+        )
+    if str(getattr(select, "kind", "")) != _POLYGLOT_KIND_SELECT:
+        return ()
+    inferred: dict[str, str] = _polyglot_direct_select_output_types(
+        select=select,
+        relation_types=relation_types,
+        inference_profile=inference_profile,
+        expression_type_resolver=expression_type_resolver,
+    )
+    slots: list[tuple[str, str | None]] = []
+    for raw_projection in getattr(select, "expressions", ()):
+        projection: Any = _unwrap_polyglot_annotations(raw_projection)
+        if bool(getattr(projection, "is_star", False)):
+            return ()
+        output_name: str = str(getattr(projection, "output_name", "") or "")
+        if not output_name or output_name == SQL_WILDCARD_TOKEN:
+            return ()
+        inferred_type: str | None = _case_insensitive_mapping_get(
+            mapping=inferred,
+            key=output_name,
+        )
+        if inferred_type is None:
+            expression: Any = (
+                projection.this
+                if str(getattr(projection, "kind", "")) == _POLYGLOT_KIND_ALIAS
+                else projection
+            )
+            if str(getattr(expression, "kind", "")) == _POLYGLOT_KIND_NULL:
+                inferred_type = _NULL_SET_OPERATION_TYPE
+        slots.append((output_name, inferred_type))
+    return tuple(slots)
+
+
+def _polyglot_common_set_operation_type(
+    *,
+    left: str | None,
+    right: str | None,
+    inference_profile: ExpressionInferenceProfile,
+) -> str | None:
+    if left == _NULL_SET_OPERATION_TYPE and right == _NULL_SET_OPERATION_TYPE:
+        return None
+    if left == _NULL_SET_OPERATION_TYPE:
+        return right
+    if right == _NULL_SET_OPERATION_TYPE:
+        return left
+    if left is None or right is None:
+        return None
+    return (
+        left
+        if _polyglot_types_equal(
+            left=left,
+            right=right,
+            inference_profile=inference_profile,
+        )
+        else None
+    )
+
+
+def _polyglot_types_equal(
+    *,
+    left: str,
+    right: str,
+    inference_profile: ExpressionInferenceProfile,
+) -> bool:
+    return left == right or types_equal(
+        left=left,
+        right=right,
+        dialect=inference_profile.sql_analysis_dialect,
+    )
 
 
 def _polyglot_direct_select_output_types(
@@ -458,23 +661,179 @@ def _polyglot_direct_select_output_types(
             if str(getattr(projection, "kind", "")) == _POLYGLOT_KIND_ALIAS
             else projection
         )
-        expression_kind: str = str(getattr(expression, "kind", ""))
-        inferred_type: str | None = (
-            expression_type_resolver(
-                expression=expression,
+        inferred_type: str | None = _polyglot_direct_expression_type(
+            expression=expression,
+            types_by_alias=types_by_alias,
+            inference_profile=inference_profile,
+            expression_type_resolver=expression_type_resolver,
+        )
+        if inferred_type is not None:
+            inferred[output_name] = inferred_type
+    return inferred
+
+
+def _polyglot_direct_expression_type(
+    *,
+    expression: Any,
+    types_by_alias: dict[str, dict[str, str]],
+    inference_profile: ExpressionInferenceProfile,
+    expression_type_resolver: _ExpressionTypeResolver,
+) -> str | None:
+    expression = _unwrap_polyglot_annotations(expression)
+    kind: str = str(getattr(expression, "kind", ""))
+    inferred_type: str | None = expression_type_resolver(
+        expression=expression,
+        inference_profile=inference_profile,
+    )
+    if inferred_type is not None:
+        return inferred_type
+    if kind == _POLYGLOT_KIND_COLUMN:
+        return _polyglot_direct_column_type(
+            expression=expression,
+            types_by_alias=types_by_alias,
+        )
+    if kind in _POLYGLOT_BOOLEAN_RESULT_KINDS:
+        return "BOOLEAN"
+    if kind == _POLYGLOT_KIND_CONCAT:
+        operands: tuple[Any, ...] = tuple(
+            operand
+            for key in ("left", "right")
+            if (operand := getattr(expression, "args", {}).get(key)) is not None
+        )
+        if len(operands) != _POLYGLOT_BINARY_OPERAND_COUNT:
+            return None
+        operand_types: list[str] = []
+        for operand in operands:
+            if (
+                str(getattr(operand, "kind", "")) == _POLYGLOT_KIND_LITERAL
+                and getattr(operand, "args", {}).get(_POLYGLOT_PAYLOAD_LITERAL_TYPE)
+                == _POLYGLOT_LITERAL_TYPE_STRING
+            ):
+                operand_types.append("TEXT")
+                continue
+            operand_type: str | None = _polyglot_direct_expression_type(
+                expression=operand,
+                types_by_alias=types_by_alias,
                 inference_profile=inference_profile,
+                expression_type_resolver=expression_type_resolver,
+            )
+            if operand_type is None:
+                return None
+            operand_types.append(operand_type)
+        return (
+            "TEXT"
+            if all(
+                normalize_type(
+                    type_sql=operand_type,
+                    dialect=inference_profile.sql_analysis_dialect,
+                ).family
+                == TypeFamily.STRING
+                for operand_type in operand_types
             )
-            if expression_kind in _POLYGLOT_CAST_KINDS
             else None
         )
-        if inferred_type is None and expression_kind == _POLYGLOT_KIND_COLUMN:
-            inferred_type = _polyglot_direct_column_type(
-                expression=expression,
+    if kind == _POLYGLOT_KIND_SUBSTRING:
+        inner: Any | None = getattr(expression, "args", {}).get("this")
+        return (
+            _polyglot_direct_expression_type(
+                expression=inner,
                 types_by_alias=types_by_alias,
+                inference_profile=inference_profile,
+                expression_type_resolver=expression_type_resolver,
             )
-        if inferred_type is not None:
-            inferred[output_name] = inferred_type
-    return inferred
+            if inner is not None
+            else None
+        )
+    if kind in _POLYGLOT_TYPE_PASSTHROUGH_KINDS:
+        inner: Any | None = getattr(expression, "this", None) or getattr(
+            expression, "args", {}
+        ).get("this")
+        return (
+            _polyglot_direct_expression_type(
+                expression=inner,
+                types_by_alias=types_by_alias,
+                inference_profile=inference_profile,
+                expression_type_resolver=expression_type_resolver,
+            )
+            if inner is not None
+            else None
+        )
+    result_expressions: tuple[Any, ...] = _polyglot_result_expressions(expression)
+    if result_expressions:
+        return _polyglot_common_result_type(
+            expressions=result_expressions,
+            types_by_alias=types_by_alias,
+            inference_profile=inference_profile,
+            expression_type_resolver=expression_type_resolver,
+        )
+    return None
+
+
+def _polyglot_result_expressions(expression: Any) -> tuple[Any, ...]:
+    kind: str = str(getattr(expression, "kind", ""))
+    args: dict[str, Any] = getattr(expression, "args", {})
+    if kind == _POLYGLOT_KIND_COALESCE:
+        values: object = args.get("expressions")
+        return tuple(values) if isinstance(values, list) else ()
+    if kind == _POLYGLOT_KIND_IF_FUNC:
+        return tuple(
+            value for key in ("true_value", "false_value") if (value := args.get(key)) is not None
+        )
+    if kind == _POLYGLOT_KIND_CASE:
+        values: list[Any] = []
+        whens: object = args.get("whens")
+        children: tuple[Any, ...] = tuple(expression.children())
+        if isinstance(whens, list):
+            first_condition_index: int = 1 if args.get("operand") is not None else 0
+            values.extend(
+                children[first_condition_index + (index * 2) + 1] for index in range(len(whens))
+            )
+        if args.get("else_") is not None and children:
+            values.append(children[-1])
+        return tuple(values)
+    if (
+        kind == _POLYGLOT_KIND_FUNCTION
+        and str(getattr(expression, "name", "")).upper() == _POLYGLOT_NULLIF_FUNCTION_NAME
+    ):
+        values = args.get("args")
+        return (values[0],) if isinstance(values, list) and values else ()
+    return ()
+
+
+def _polyglot_common_result_type(
+    *,
+    expressions: tuple[Any, ...],
+    types_by_alias: dict[str, dict[str, str]],
+    inference_profile: ExpressionInferenceProfile,
+    expression_type_resolver: _ExpressionTypeResolver,
+) -> str | None:
+    resolved_types: list[str] = []
+    for raw_expression in expressions:
+        expression: Any = _unwrap_polyglot_annotations(raw_expression)
+        if str(getattr(expression, "kind", "")) == _POLYGLOT_KIND_NULL:
+            continue
+        resolved_type: str | None = _polyglot_direct_expression_type(
+            expression=expression,
+            types_by_alias=types_by_alias,
+            inference_profile=inference_profile,
+            expression_type_resolver=expression_type_resolver,
+        )
+        if resolved_type is None:
+            return None
+        resolved_types.append(resolved_type)
+    if not resolved_types:
+        return None
+    first_type: str = resolved_types[0]
+    if all(
+        _polyglot_types_equal(
+            left=first_type,
+            right=other_type,
+            inference_profile=inference_profile,
+        )
+        for other_type in resolved_types[1:]
+    ):
+        return first_type
+    return None
 
 
 def _polyglot_direct_select_tables(select: Any) -> tuple[Any, ...]:

{sqlbuild-0.101.14 → sqlbuild-0.101.16}/src/sqlbuild/compiler/compile/_helpers/attachment/audits.py

@@ -306,6 +306,9 @@ def build_model_attached_audit_inputs(
     attached_audit_inputs: list[CompileAuditInput] = []
     audit_instance: SchemaAuditInstance
     for audit_instance in model_input.schema_entry.audits:
+        attached_column_name: str | None = _explicit_audit_column_name(
+            audit_instance=audit_instance,
+        )
         attached_audit_inputs.append(
             build_attached_audit_input(
                 audit_instance=audit_instance,
@@ -319,7 +322,7 @@ def build_model_attached_audit_inputs(
                 },
                 attached_target_kind=AttachedAuditTargetKind.MODEL,
                 attached_target_name=model_input.model_file.file_path.stem,
-                attached_column_name=None,
+                attached_column_name=attached_column_name,
                 context=context,
             )
         )
@@ -406,6 +409,14 @@ def build_source_attached_audit_inputs(
     return tuple(attached_audit_inputs)
 
 
+def _explicit_audit_column_name(
+    *,
+    audit_instance: SchemaAuditInstance,
+) -> str | None:
+    raw_column: object | None = audit_instance.arguments.get("column")
+    return raw_column if isinstance(raw_column, str) else None
+
+
 def _scoped_audit_declarations(
     *, context: _AuditAttachmentContext, file_path: Path, resource: ResourceIdentity
 ) -> DeclarationExpansionContext:

{sqlbuild-0.101.14 → sqlbuild-0.101.16}/src/sqlbuild/compiler/sql_analysis/constants.py

@@ -13,11 +13,16 @@ POLYGLOT_KIND_ALIAS: str = "alias"
 POLYGLOT_KIND_ANNOTATED: str = "annotated"
 POLYGLOT_KIND_ARRAY_AGG: str = "array_agg"
 POLYGLOT_KIND_AVG: str = "avg"
+POLYGLOT_KIND_BOOLEAN: str = "boolean"
+POLYGLOT_KIND_CASE: str = "case"
 POLYGLOT_KIND_CAST: str = "cast"
 POLYGLOT_KIND_COALESCE: str = "coalesce"
 POLYGLOT_KIND_COLUMN: str = "column"
+POLYGLOT_KIND_CONCAT: str = "concat"
 POLYGLOT_KIND_COUNT: str = "count"
 POLYGLOT_KIND_EXCEPT: str = "except"
+POLYGLOT_KIND_FUNCTION: str = "function"
+POLYGLOT_KIND_IF_FUNC: str = "if_func"
 POLYGLOT_KIND_INTERSECT: str = "intersect"
 POLYGLOT_KIND_LITERAL: str = "literal"
 POLYGLOT_KIND_MAX: str = "max"
@@ -25,15 +30,47 @@ POLYGLOT_KIND_MIN: str = "min"
 POLYGLOT_KIND_NULL: str = "null"
 POLYGLOT_KIND_SELECT: str = "select"
 POLYGLOT_KIND_STRING_AGG: str = "string_agg"
+POLYGLOT_KIND_SUBSTRING: str = "substring"
 POLYGLOT_KIND_SUM: str = "sum"
 POLYGLOT_KIND_TABLE: str = "table"
 POLYGLOT_KIND_TIMESTAMP: str = "timestamp"
 POLYGLOT_KIND_TRY_CAST: str = "try_cast"
 POLYGLOT_KIND_UNION: str = "union"
+POLYGLOT_KIND_WINDOW_FUNCTION: str = "window_function"
+POLYGLOT_KIND_WITHIN_GROUP: str = "within_group"
+POLYGLOT_BOOLEAN_RESULT_KINDS: frozenset[str] = frozenset(
+    {
+        POLYGLOT_KIND_BOOLEAN,
+        "and",
+        "between",
+        "eq",
+        "exists",
+        "gt",
+        "gte",
+        "ilike",
+        "in",
+        "is",
+        "like",
+        "lt",
+        "lte",
+        "neq",
+        "not",
+        "or",
+        "regexp_like",
+    }
+)
 POLYGLOT_SET_OPERATION_KINDS: frozenset[str] = frozenset(
     {POLYGLOT_KIND_UNION, POLYGLOT_KIND_INTERSECT, POLYGLOT_KIND_EXCEPT}
 )
 POLYGLOT_CAST_KINDS: frozenset[str] = frozenset({POLYGLOT_KIND_CAST, POLYGLOT_KIND_TRY_CAST})
+POLYGLOT_TYPE_PASSTHROUGH_KINDS: frozenset[str] = frozenset(
+    {
+        POLYGLOT_KIND_MAX,
+        POLYGLOT_KIND_MIN,
+        POLYGLOT_KIND_WINDOW_FUNCTION,
+        POLYGLOT_KIND_WITHIN_GROUP,
+    }
+)
 POLYGLOT_AGGREGATE_KINDS: frozenset[str] = frozenset(
     {
         POLYGLOT_KIND_AVG,
@@ -53,6 +90,7 @@ POLYGLOT_PAYLOAD_FROM: str = "from"
 POLYGLOT_PAYLOAD_EXPRESSIONS: str = "expressions"
 POLYGLOT_PAYLOAD_JOINS: str = "joins"
 POLYGLOT_PAYLOAD_KIND: str = "kind"
+POLYGLOT_PAYLOAD_LITERAL_TYPE: str = "literal_type"
 POLYGLOT_PAYLOAD_NAME: str = "name"
 POLYGLOT_PAYLOAD_PRECISION: str = "precision"
 POLYGLOT_PAYLOAD_SCALE: str = "scale"
@@ -65,6 +103,9 @@ TIMESTAMP_WITH_TIME_ZONE_SQL_TYPE_NAME: str = "TIMESTAMPTZ"
 POLYGLOT_JOIN_FULL: str = "FULL"
 POLYGLOT_JOIN_LEFT: str = "LEFT"
 POLYGLOT_JOIN_RIGHT: str = "RIGHT"
+POLYGLOT_LITERAL_TYPE_STRING: str = "string"
+POLYGLOT_NULLIF_FUNCTION_NAME: str = "NULLIF"
+POLYGLOT_BINARY_OPERAND_COUNT: int = 2
 POLYGLOT_ANALYSIS_BASE_TABLES: str = "baseTables"
 POLYGLOT_ANALYSIS_BODY_SQL: str = "bodySql"
 POLYGLOT_ANALYSIS_CAST_TYPE: str = "castType"