coltrace 0.1.0.dev7__py3-none-any.whl → 0.1.0.dev8__py3-none-any.whl

coltrace/__init__.py

@@ -7,7 +7,7 @@ from .models import ScanReport
 from .scanner import ScanConfig, scan_project
 from .source_models import SourceContract, SourceSchema, schema_from_columns
 
-__version__ = "0.1.0.dev7"
+__version__ = "0.1.0.dev8"
 __all__ = [
     "LineageReport",
     "ScanConfig",

coltrace/analysis.py

@@ -12,6 +12,7 @@ import fnmatch
 import hashlib
 import io
 import operator
+import re
 import sys
 import tokenize
 import warnings
@@ -136,6 +137,10 @@ class _Value:
 
 
 PLACEHOLDER = "__coltrace_param_{}__"
+PLACEHOLDER_PREFIX = "__coltrace_param_"
+_PLACEHOLDER_NAME = re.compile(r"__coltrace_param_\d+__")
+# Method names whose receiver dialect is a useful SQL parsing hint.
+_DIALECT_HINTS = {"sql": "databricks", "query": "bigquery", "query_and_wait": "bigquery"}
 
 # Library constants: scalar literals, not objects that could hold data.
 CONSTANT_SYMBOLS = frozenset(
@@ -219,6 +224,8 @@ class _Opaque:
     conversion: bool = False
     # Labels declared for the resulting DataFrame, such as columns=[...].
     columns: tuple[str, ...] | None = None
+    # SQL dialect suggested by the call shape; parsing still falls back.
+    dialect: str | None = None
 
 
 @dataclass
@@ -382,8 +389,16 @@ class _Analyzer:
         source_contracts: tuple[SourceContract, ...] = (),
         source_schemas: tuple[SourceSchema, ...] = (),
         observers: tuple[str, ...] = (),
+        sql_dialect: str | None = None,
     ) -> None:
         self.observers = observers
+        self.sql_dialect = sql_dialect
+        # Unknown interpolations in SQL text: stable names per source position.
+        self.placeholders: dict[str, str] = {}
+        self.placeholder_sites: dict[tuple[str, int, int, int, int], str] = {}
+        # Database relations read by SQL sources, and their physical columns.
+        self.table_frames: dict[str, str] = {}
+        self.table_columns: dict[tuple[str, str], str] = {}
         self.modules = modules
         self.ambiguous = ambiguous
         self.frames: list[Frame] = []
@@ -693,6 +708,7 @@ class _Analyzer:
         context: _Context,
         node: ast.AST,
         kind: str = "derive",
+        operation_kind: str | None = None,
     ) -> str:
         value = self._refresh(value)
         state.revision += 1
@@ -746,7 +762,9 @@ class _Analyzer:
         state.removed.discard(name)
         if state.schema is not None:
             state.schema.add(name)
-        operation = self._operation(context, node, kind, column.id, evidence, value.completeness)
+        operation = self._operation(
+            context, node, operation_kind or kind, column.id, evidence, value.completeness
+        )
         for dependency in dict.fromkeys(value.dependencies):
             self.edges.append(Edge(dependency, operation.id, "read", evidence))
         self.edges.append(Edge(operation.id, column.id, "write", evidence))
@@ -1439,7 +1457,14 @@ class _Analyzer:
             identifiers.extend(self.columns[column].dataframe_id for column in value.dependencies)
         return tuple(dict.fromkeys(identifiers))
 
-    def _consume(self, value: _Value, context: _Context, node: ast.AST, kind: str) -> str | None:
+    def _consume(
+        self,
+        value: _Value,
+        context: _Context,
+        node: ast.AST,
+        kind: str,
+        label: str | None = None,
+    ) -> str | None:
         dependencies = value.dependencies
         if value.frame is not None:
             dependencies = tuple(value.frame.current.values())
@@ -1467,7 +1492,7 @@ class _Analyzer:
                 context,
                 node,
                 event_kind,
-                kind.replace("_", " "),
+                label or kind.replace("_", " "),
                 frames=frames,
                 inputs=dependencies,
                 parents=self._parents(value)
@@ -1686,18 +1711,18 @@ class _Analyzer:
                 return folded
         if (
             isinstance(node.op, ast.Add)
-            and all(value.kind == "literal" for value in values)
+            and all(value.kind == "literal" or self._plain_unknown(value) for value in values)
             and (self._text(left) is not None or self._text(right) is not None)
         ):
             # A partially known string keeps its known text for SQL parsing.
             return _Value(
                 "literal",
                 completeness="complete",
-                template=(self._text(left) or PLACEHOLDER.format("l"))
-                + (self._text(right) or PLACEHOLDER.format("r")),
+                template=(self._text(left) or self._placeholder(node.left, context))
+                + (self._text(right) or self._placeholder(node.right, context)),
             )
         if isinstance(node.op, ast.Mod) and left.known and isinstance(left.constant, str):
-            return _Value("literal", completeness="complete")
+            return self._percent_format(node, left.constant, right, context)
         if isinstance(node.op, ast.Add):
             first, second = self._elements(left), self._elements(right)
             if (
@@ -1721,6 +1746,65 @@ class _Analyzer:
         )
         return self._degraded(values, kind=kind)
 
+    def _placeholder(self, node: ast.AST, context: _Context) -> str:
+        """A stable SQL-safe name for one unknown interpolation, labeled by its code."""
+        key = (
+            context.module.name,
+            getattr(node, "lineno", 0),
+            getattr(node, "col_offset", 0),
+            getattr(node, "end_lineno", 0),
+            getattr(node, "end_col_offset", 0),
+        )
+        name = self.placeholder_sites.get(key)
+        if name is None:
+            name = PLACEHOLDER.format(len(self.placeholders) + 1)
+            label = " ".join(self._code(context, node).split())
+            if len(label) > 60:
+                label = label[:57] + "..."
+            self.placeholders[name] = "{" + label + "}"
+            self.placeholder_sites[key] = name
+        return name
+
+    def _display_sql(self, text: str) -> str:
+        """Show unknown interpolations as their Python expression, e.g. ``{table}``."""
+        return _PLACEHOLDER_NAME.sub(
+            lambda match: self.placeholders.get(match.group(0), "{?}"), text
+        )
+
+    @staticmethod
+    def _plain_unknown(value: _Value) -> bool:
+        """An unknown scalar-like value: not a frame, column, object or collection."""
+        return (
+            value.kind == "unknown"
+            and value.frame is None
+            and not value.dependencies
+            and value.instance is None
+            and value.function is None
+            and value.items is None
+            and value.members is None
+            and value.opaque is None
+        )
+
+    def _percent_format(
+        self, node: ast.BinOp, text: str, right: _Value, context: _Context
+    ) -> _Value:
+        """``"..." % values``: fold known values, otherwise keep a SQL template."""
+        if right.known and isinstance(right.constant, (tuple, dict, str, int, float, bool)):
+            try:
+                result = text % right.constant
+            except (TypeError, ValueError, KeyError, OverflowError):
+                return _Value("literal", completeness="complete")
+            if len(result) <= 1_000_000:
+                return self._literal_value(result)
+            return _Value("literal", completeness="complete")
+        name = self._placeholder(node.right, context)
+        template = re.sub(
+            r"%%|%(\([^)]*\))?[-#0 +]*\d*(\.\d+)?[sdifrxXeEgGc]",
+            lambda match: "%" if match.group(0) == "%%" else name,
+            text,
+        )
+        return _Value("literal", completeness="complete", template=template)
+
     def _text(self, value: _Value) -> str | None:
         """String text, with placeholders for unknown interpolated parts."""
         if value.known and isinstance(value.constant, str):
@@ -1868,7 +1952,7 @@ class _Analyzer:
                     pattern.append(
                         item.template
                         if item.template is not None and formatted.format_spec is None
-                        else PLACEHOLDER.format(len(pattern))
+                        else self._placeholder(formatted.value, context)
                     )
                 if formatted.format_spec is not None:
                     values.append(self._expr(formatted.format_spec, context))
@@ -1981,7 +2065,9 @@ class _Analyzer:
         node: ast.ListComp | ast.SetComp | ast.GeneratorExp | ast.DictComp,
         context: _Context,
     ) -> _Value | None:
-        if len(node.generators) != 1 or isinstance(node, ast.GeneratorExp):
+        # A generator over known constants evaluates like a list: its consumer
+        # (join, tuple, any, ...) then folds statically.
+        if len(node.generators) != 1:
             return None
         generator = node.generators[0]
         if generator.is_async or not isinstance(generator.target, (ast.Name, ast.Tuple)):
@@ -1999,6 +2085,10 @@ class _Analyzer:
             for call in calls
         ):
             return None
+        if isinstance(node, ast.GeneratorExp) and calls:
+            # Only pure element expressions (names, constants, f-strings) are
+            # evaluated per item; anything else keeps the one-element summary.
+            return None
         iterable = self._expr(generator.iter, context)
         if (
             not iterable.known
@@ -2146,7 +2236,7 @@ class _Analyzer:
                 and node.func.attr == "format"
                 and receiver.template is not None
             ):
-                formatted = self._format(receiver.template, arguments, keywords)
+                formatted = self._format(receiver.template, arguments, keywords, node, context)
                 if formatted is not None:
                     text = (
                         formatted.template if formatted.template is not None else formatted.constant
@@ -2319,7 +2409,7 @@ class _Analyzer:
                 "Call effects and return provenance are unresolved; affected state is invalidated.",
             )
         self._invalidate(values, context, node)
-        return self._opaque_result(node, context, function, arguments, keywords, values)
+        return self._opaque_result(node, context, function, arguments, keywords, values, receiver)
 
     def _column_label(
         self, node: ast.Subscript, context: _Context
@@ -2837,7 +2927,7 @@ class _Analyzer:
         allowed = CONSTANT_METHODS.get(type(receiver.constant), frozenset())
         if method not in allowed:
             if method == "format" and isinstance(receiver.constant, str):
-                return self._format(receiver.constant, arguments, keywords)
+                return self._format(receiver.constant, arguments, keywords, node, context)
             return None
         try:
             result = getattr(receiver.constant, method)(*args, **kwargs)
@@ -2849,9 +2939,13 @@ class _Analyzer:
             return None
         return self._literal_value(result)
 
-    @staticmethod
     def _format(
-        text: str, arguments: list[_Value], keywords: list[tuple[str | None, _Value]]
+        self,
+        text: str,
+        arguments: list[_Value],
+        keywords: list[tuple[str | None, _Value]],
+        node: ast.Call,
+        context: _Context,
     ) -> _Value | None:
         """``str.format`` with simple field names; unknown values become placeholders."""
         import string
@@ -2864,10 +2958,17 @@ class _Analyzer:
             return None
         known = all(item.known for item in arguments) and all(item.known for _, item in keywords)
 
+        sources: dict[object, ast.AST] = dict(enumerate(node.args))
+        sources.update(
+            (keyword.arg, keyword.value) for keyword in node.keywords if keyword.arg is not None
+        )
+
         def shown(item: _Value, index: object) -> object:
             if item.known and isinstance(item.constant, (str, int, float, bool)):
                 return item.constant
-            return item.template or PLACEHOLDER.format(index)
+            if item.template:
+                return item.template
+            return self._placeholder(sources.get(index, node), context)
 
         try:
             result = text.format(
@@ -2877,7 +2978,7 @@ class _Analyzer:
         except (IndexError, KeyError, ValueError):
             return None
         if known:
-            return _Analyzer._literal_value(result)
+            return self._literal_value(result)
         return _Value("literal", completeness="complete", template=result)
 
     def _derived_call(
@@ -4361,34 +4462,71 @@ class _Analyzer:
         relations: tuple[str, ...] = (item.relation,) if item.relation else ()
         controls: tuple[str, ...] = ()
         complete = False
+        # Physical (relation, column) inputs per output field, and SQL controls.
+        references: dict[str, tuple[tuple[str, str], ...]] = {}
+        control_references: tuple[tuple[str, str], ...] = ()
         if item.kind == "sql":
             if item.query is not None:
                 from .sql_sources import summarize_sql
 
                 try:
-                    summary = summarize_sql(item.query, item.dialect)
+                    summary = summarize_sql(
+                        item.query,
+                        item.dialect or self.sql_dialect,
+                        fallback=True,
+                        placeholder=PLACEHOLDER_PREFIX,
+                    )
                 except ValueError as error:
                     self._diagnose(context, node, "CT_UNRESOLVED_SQL", str(error))
                 else:
-                    marker = PLACEHOLDER.split("{")[0]
+                    marker = PLACEHOLDER_PREFIX
+                    static = [field for field in summary.fields if marker not in field.name]
                     fields = tuple(
-                        SourceField(field.name, field.expression, field.inputs)
-                        for field in summary.fields
-                        if marker not in field.name
+                        SourceField(
+                            field.name,
+                            self._display_sql(field.expression),
+                            tuple(self._display_sql(name) for name in field.inputs),
+                        )
+                        for field in static
                     )
-                    relations, controls, complete = (
-                        tuple(item for item in summary.relations if marker not in item),
-                        summary.controls,
-                        summary.complete and len(fields) == len(summary.fields),
+                    references = {field.name: field.references for field in static}
+                    control_references = tuple(
+                        reference
+                        for reference in summary.control_references
+                        if marker not in reference[1]
                     )
-                    if marker in item.query:
+                    relations = tuple(self._display_sql(name) for name in summary.relations)
+                    controls = tuple(
+                        self._display_sql(name)
+                        for name in summary.controls
+                        if marker not in name.rsplit(".", 1)[-1]
+                    )
+                    complete = summary.complete and len(static) == len(summary.fields)
+                    interpolations = list(dict.fromkeys(_PLACEHOLDER_NAME.findall(item.query)))
+                    if interpolations:
+                        shown = ", ".join(
+                            self.placeholders.get(name, "{?}") for name in interpolations[:4]
+                        )
+                        more = len(interpolations) - 4
                         self._note(
+                            context,
+                            node,
+                            "CT_SQL_INTERPOLATION",
+                            f"SQL text has {len(interpolations)} interpolation(s) that are not "
+                            f"statically known ({shown}{f', +{more}' if more > 0 else ''}). "
+                            "The known text is parsed; relations and columns named by them "
+                            "are shown as {expression} and fields reading them are partial.",
+                        )
+                    if len(static) != len(summary.fields):
+                        self._diagnose(
                             context,
                             node,
                             "CT_PARTIAL_SQL",
-                            "SQL contains interpolations that are not statically known; they "
-                            "were replaced by placeholders and are not modeled as fields.",
+                            "Some SQL output labels are interpolated at runtime; they are not "
+                            "modeled as DataFrame columns.",
                         )
+                    for message in summary.notes:
+                        self._note(context, node, "CT_SQL_RECOVERED", message)
                     for message in summary.diagnostics:
                         self._diagnose(context, node, "CT_PARTIAL_SQL", message)
             else:
@@ -4425,6 +4563,7 @@ class _Analyzer:
                 fields = ()
         if item.columns:
             fields = tuple(SourceField(name, name) for name in item.columns)
+            references = {}
             complete = True
         if item.output_columns is not None:
             if (
@@ -4448,6 +4587,10 @@ class _Analyzer:
                 and len(fields) == len(item.output_columns)
                 and not item.reader.endswith("read_sql_table")
             ):
+                references = {
+                    name: references.get(original.name, ())
+                    for name, original in zip(item.output_columns, fields, strict=True)
+                }
                 fields = tuple(
                     SourceField(name, original.expression, original.inputs)
                     for name, original in zip(item.output_columns, fields, strict=True)
@@ -4464,7 +4607,7 @@ class _Analyzer:
         state.schema = {field.name for field in fields} if complete else None
         expression = self._code(context, node)
         if item.query is not None:
-            expression += "\nSQL: " + item.query
+            expression += "\nSQL: " + self._display_sql(item.query)
         expression += "\nSource fields: " + ", ".join(
             f"{field.name} <- {field.expression}" for field in fields
         )
@@ -4494,18 +4637,28 @@ class _Analyzer:
                     "only observed labels become source columns.",
                 )
         for source_field in seed_fields:
+            value, relation = self._source_field_value(
+                source_field, references.get(source_field.name, ()), context, node
+            )
             self._write(
-                state,
-                source_field.name,
+                state, source_field.name, value, context, node, "source", operation_kind=relation
+            )
+        if control_references:
+            # WHERE/JOIN/GROUP/ORDER columns select rows; they are not value inputs.
+            self._consume(
                 _Value(
-                    "literal",
-                    expression=source_field.expression,
+                    "series",
+                    dependencies=tuple(
+                        self._table_column(relation, column, context, node)
+                        for relation, column in control_references
+                    ),
                     evidence="inferred",
                     completeness="partial",
                 ),
                 context,
                 node,
-                "source",
+                "filter",
+                "SQL row control (WHERE, JOIN, GROUP BY, ORDER BY or window)",
             )
         self.sources.append(
             SourceInfo(
@@ -4517,7 +4670,7 @@ class _Analyzer:
                 context.module.name,
                 context.scope,
                 context.key,
-                query=item.query or "",
+                query=self._display_sql(item.query or ""),
                 relations=relations,
                 fields=fields,
                 controls=controls,
@@ -4529,6 +4682,123 @@ class _Analyzer:
         self._seed_source_schema(state, context, node)
         return self._frame_value(state)
 
+    def _source_field_value(
+        self,
+        source_field: SourceField,
+        references: tuple[tuple[str, str], ...],
+        context: _Context,
+        node: ast.AST,
+    ) -> tuple[_Value, str | None]:
+        """A SQL output field's value, reading the physical columns it is built from.
+
+        A field that only selects one column keeps its values (``pass``) or
+        renames them; any other expression derives a new value.
+        """
+        identifiers = tuple(
+            self._table_column(relation, column, context, node)
+            for relation, column in references
+            if PLACEHOLDER_PREFIX not in column
+        )
+        dynamic = len(identifiers) != len(references)
+        if not identifiers:
+            return (
+                _Value(
+                    "literal",
+                    expression=source_field.expression,
+                    evidence="inferred",
+                    completeness="partial",
+                ),
+                None,
+            )
+        value = _Value(
+            "series",
+            dependencies=identifiers,
+            expression=source_field.expression,
+            evidence="inferred",
+            completeness="partial",
+        )
+        relation: str | None = None
+        if len(references) == 1 and not dynamic:
+            column = references[0][1]
+            bare = source_field.expression.rsplit(".", 1)[-1].strip('`"[]')
+            if bare == column:
+                relation = "pass" if column == source_field.name else "rename"
+        return value, relation
+
+    def _table_column(self, relation: str, column: str, context: _Context, node: ast.AST) -> str:
+        """The column node of a database relation that SQL text reads.
+
+        A fully named relation is one identity across the project. A relation
+        named by unknown interpolations stays local to its extraction site,
+        because two such names need not denote the same table.
+        """
+        location = self._location(context, node)
+        key = relation
+        if PLACEHOLDER_PREFIX in relation:
+            key = f"{relation}@{location.path}:{location.line}|{context.key}"
+        frame_id = self.table_frames.get(key)
+        if frame_id is None:
+            label = self._display_sql(relation)
+            frame_id = _identifier("table", key)
+            record = Frame(
+                frame_id,
+                label,
+                location,
+                context.module.name,
+                context.scope,
+                context.key,
+                "inferred",
+                "table",
+            )
+            state = _State(record, index_key=record.id)
+            state.history = (
+                self._event(
+                    context,
+                    node,
+                    "source_table",
+                    f"Database relation {label} read by SQL",
+                    frames=(record.id,),
+                    expression=self._code(context, node),
+                    evidence="inferred",
+                    completeness="partial",
+                ),
+            )
+            self.frame_index[record.id] = len(self.frames)
+            self.frames.append(record)
+            self.states[record.id] = state
+            self.table_frames[key] = frame_id
+        identifier = self.table_columns.get((frame_id, column))
+        if identifier is None:
+            identifier = _identifier("tcol", frame_id, column)
+            label = self.frames[self.frame_index[frame_id]].origin
+            self.columns[identifier] = Column(
+                identifier,
+                frame_id,
+                column,
+                0,
+                location,
+                context.module.name,
+                context.scope,
+                context.key,
+                "table",
+                "inferred",
+                "partial",
+            )
+            self.column_history[identifier] = self._event(
+                context,
+                node,
+                "source_table",
+                f"Database column {column} of {label}",
+                frames=(frame_id,),
+                outputs=(identifier,),
+                parents=self.states[frame_id].history,
+                expression=self._code(context, node),
+                evidence="inferred",
+                completeness="partial",
+            )
+            self.table_columns[(frame_id, column)] = identifier
+        return identifier
+
     def _matching_source_schema(self, context: _Context, node: ast.AST) -> SourceSchema | None:
         location = self._location(context, node)
         matches = [
@@ -5874,6 +6144,7 @@ class _Analyzer:
             return self.frame_usage[key][1 if loose else 0]
         names: set[str] = set()
         weak: set[str] = set()
+        # Names ruled out as Pandas frames (Spark-only APIs, SQL clients).
         spark: set[str] = set()
 
         class Visitor(ast.NodeVisitor):
@@ -5914,6 +6185,25 @@ class _Analyzer:
                     names.add(child.value.id)
                 self.generic_visit(child)
 
+            def visit_Call(self, child: ast.Call) -> None:
+                # client.query("SELECT ...") is a SQL client, not DataFrame.query.
+                if (
+                    isinstance(child.func, ast.Attribute)
+                    and isinstance(child.func.value, ast.Name)
+                    and child.func.attr in {"query", "sql", "execute"}
+                    and child.args
+                ):
+                    first = child.args[0]
+                    if isinstance(first, ast.JoinedStr) and first.values:
+                        first = first.values[0]
+                    if (
+                        isinstance(first, ast.Constant)
+                        and isinstance(first.value, str)
+                        and _Analyzer._looks_like_sql(first.value)
+                    ):
+                        spark.add(child.func.value.id)
+                self.generic_visit(child)
+
             def visit_FunctionDef(self, child: ast.FunctionDef) -> None:
                 pass
 
@@ -5943,15 +6233,12 @@ class _Analyzer:
         arguments: list[_Value],
         keywords: list[tuple[str | None, _Value]],
         values: list[_Value],
+        receiver: _Value | None = None,
     ) -> _Value:
         """An unresolved call result; it may later be used as a DataFrame."""
         callee = ast.unparse(node.func)
-        conversion = (
-            isinstance(node.func, ast.Attribute)
-            and node.func.attr in PANDAS_CONVERSIONS
-            and not node.args
-            and not node.keywords
-        )
+        method = node.func.attr if isinstance(node.func, ast.Attribute) else ""
+        conversion = method in PANDAS_CONVERSIONS and not node.args and not node.keywords
         query = next(
             (
                 text
@@ -5960,15 +6247,37 @@ class _Analyzer:
             ),
             None,
         )
+        dialect = _DIALECT_HINTS.get(method) if query is not None else None
+        inner = receiver.opaque if receiver is not None else None
+        if conversion and inner is not None and inner.query is not None:
+            # spark.sql(text).toPandas(), client.query(text).to_dataframe(): the
+            # documented conversion returns the rows the SQL text describes.
+            query, dialect = inner.query, inner.dialect
+            callee = f"{inner.callee}(...).{method}"
         return _Value(
             escaped=self._escaped(values),
-            opaque=_Opaque(node, context, callee, query, conversion),
+            opaque=_Opaque(node, context, callee, query, conversion, dialect=dialect),
         )
 
     @staticmethod
     def _looks_like_sql(text: str) -> bool:
-        head = text.lstrip().lstrip("(").lstrip().lower()
-        return head.startswith(("select ", "select\n", "with ", "with\n"))
+        """A SELECT or WITH statement, possibly after comments or parentheses."""
+        head = text
+        for _ in range(100):
+            head = head.lstrip().lstrip("(").lstrip()
+            if head.startswith("--"):
+                newline = head.find("\n")
+                if newline < 0:
+                    return False
+                head = head[newline + 1 :]
+            elif head.startswith("/*"):
+                end = head.find("*/")
+                if end < 0:
+                    return False
+                head = head[end + 2 :]
+            else:
+                break
+        return re.match(r"(select|with)\s", head, re.IGNORECASE) is not None
 
     def _promote(self, name: str, value: _Value, context: _Context) -> _Value:
         """Bind an unresolved call result as an inferred-origin DataFrame when used as one."""
@@ -5994,7 +6303,7 @@ class _Analyzer:
             "the extraction explicit.",
         )
         if opaque.query is not None:
-            item = Extraction("sql", opaque.callee, query=opaque.query)
+            item = Extraction("sql", opaque.callee, query=opaque.query, dialect=opaque.dialect)
             self._note(
                 context,
                 node,
@@ -7933,7 +8242,14 @@ def analyze_project(
     }
     if len({item.callable for item in source_contracts}) != len(source_contracts):
         raise ValueError("Source contracts must have unique callable identities")
-    analyzer = _Analyzer(modules, ambiguous, source_contracts, source_schemas, settings.observers)
+    analyzer = _Analyzer(
+        modules,
+        ambiguous,
+        source_contracts,
+        source_schemas,
+        settings.observers,
+        settings.sql_dialect,
+    )
     analyzer.run()
     for schema in source_schemas:
         if schema not in analyzer.used_source_schemas: