sqlmesh 0.189.1.dev2__py3-none-any.whl → 0.189.2__py3-none-any.whl

sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.189.1.dev2'
-__version_tuple__ = version_tuple = (0, 189, 1, 'dev2')
+__version__ = version = '0.189.2'
+__version_tuple__ = version_tuple = (0, 189, 2)

sqlmesh/core/engine_adapter/bigquery.py

@@ -199,6 +199,10 @@ class BigQueryEngineAdapter(InsertOverwriteWithMergeMixin, ClusteredByMixin, Row
                 (label_tuple.expressions[0].name, label_tuple.expressions[1].name)
                 for label_tuple in label_tuples
             )
+        elif query_label_property is not None:
+            raise SQLMeshError(
+                "Invalid value for `session_properties.query_label`. Must be an array or tuple."
+            )
 
         if parsed_query_label:
             query_label_str = ",".join([":".join(label) for label in parsed_query_label])

sqlmesh/core/engine_adapter/trino.py

@@ -27,6 +27,7 @@ from sqlmesh.core.engine_adapter.shared import (
     set_catalog,
 )
 from sqlmesh.core.schema_diff import SchemaDiffer
+from sqlmesh.utils.errors import SQLMeshError
 from sqlmesh.utils.date import TimeLike
 
 if t.TYPE_CHECKING:
@@ -99,6 +100,11 @@ class TrinoEngineAdapter(
         if not isinstance(authorization, exp.Expression):
             authorization = exp.Literal.string(authorization)
 
+        if not authorization.is_string:
+            raise SQLMeshError(
+                "Invalid value for `session_properties.authorization`. Must be a string literal."
+            )
+
         authorization_sql = authorization.sql(dialect=self.dialect)
 
         self.execute(f"SET SESSION AUTHORIZATION {authorization_sql}")

sqlmesh/core/linter/definition.py

@@ -8,7 +8,7 @@ import operator as op
 from collections.abc import Iterator, Iterable, Set, Mapping, Callable
 from functools import reduce
 from sqlmesh.core.model import Model
-from sqlmesh.core.linter.rule import Rule, RuleViolation
+from sqlmesh.core.linter.rule import Rule, RuleViolation, Range
 from sqlmesh.core.console import LinterConsole, get_console
 
 if t.TYPE_CHECKING:
@@ -74,6 +74,7 @@ class Linter:
                 violation_msg=violation.violation_msg,
                 model=model,
                 violation_type="error",
+                violation_range=violation.violation_range,
             )
             for violation in error_violations
         ] + [
@@ -82,6 +83,7 @@ class Linter:
                 violation_msg=violation.violation_msg,
                 model=model,
                 violation_type="warning",
+                violation_range=violation.violation_range,
             )
             for violation in warn_violations
         ]
@@ -149,7 +151,8 @@ class AnnotatedRuleViolation(RuleViolation):
         violation_msg: str,
         model: Model,
         violation_type: t.Literal["error", "warning"],
+        violation_range: t.Optional[Range] = None,
     ) -> None:
-        super().__init__(rule, violation_msg)
+        super().__init__(rule, violation_msg, violation_range)
         self.model = model
         self.violation_type = violation_type

sqlmesh/core/linter/helpers.py

@@ -0,0 +1,115 @@
+from pathlib import Path
+
+from sqlmesh.core.linter.rule import Position, Range
+from sqlmesh.utils.pydantic import PydanticModel
+import typing as t
+
+
+class TokenPositionDetails(PydanticModel):
+    """
+    Details about a token's position in the source code in the structure provided by SQLGlot.
+
+    Attributes:
+        line (int): The line that the token ends on.
+        col (int): The column that the token ends on.
+        start (int): The start index of the token.
+        end (int): The ending index of the token.
+    """
+
+    line: int
+    col: int
+    start: int
+    end: int
+
+    @staticmethod
+    def from_meta(meta: t.Dict[str, int]) -> "TokenPositionDetails":
+        return TokenPositionDetails(
+            line=meta["line"],
+            col=meta["col"],
+            start=meta["start"],
+            end=meta["end"],
+        )
+
+    def to_range(self, read_file: t.Optional[t.List[str]]) -> Range:
+        """
+        Convert a TokenPositionDetails object to a Range object.
+
+        In the circumstances where the token's start and end positions are the same,
+        there is no need for a read_file parameter, as the range can be derived from the token's
+        line and column. This is an optimization to avoid unnecessary file reads and should
+        only be used when the token represents a single character or position in the file.
+
+        If the token's start and end positions are different, the read_file parameter is required.
+
+        :param read_file: List of lines from the file. Optional
+        :return: A Range object representing the token's position
+        """
+        if self.start == self.end:
+            # If the start and end positions are the same, we can create a range directly
+            return Range(
+                start=Position(line=self.line - 1, character=self.col - 1),
+                end=Position(line=self.line - 1, character=self.col),
+            )
+
+        if read_file is None:
+            raise ValueError("read_file must be provided when start and end positions differ.")
+
+        # Convert from 1-indexed to 0-indexed for line only
+        end_line_0 = self.line - 1
+        end_col_0 = self.col
+
+        # Find the start line and column by counting backwards from the end position
+        start_pos = self.start
+        end_pos = self.end
+
+        # Initialize with the end position
+        start_line_0 = end_line_0
+        start_col_0 = end_col_0 - (end_pos - start_pos + 1)
+
+        # If start_col_0 is negative, we need to go back to previous lines
+        while start_col_0 < 0 and start_line_0 > 0:
+            start_line_0 -= 1
+            start_col_0 += len(read_file[start_line_0])
+            # Account for newline character
+            if start_col_0 >= 0:
+                break
+            start_col_0 += 1  # For the newline character
+
+        # Ensure we don't have negative values
+        start_col_0 = max(0, start_col_0)
+        return Range(
+            start=Position(line=start_line_0, character=start_col_0),
+            end=Position(line=end_line_0, character=end_col_0),
+        )
+
+
+def read_range_from_file(file: Path, text_range: Range) -> str:
+    """
+    Read the file and return the content within the specified range.
+
+    Args:
+        file: Path to the file to read
+        text_range: The range of text to extract
+
+    Returns:
+        The content within the specified range
+    """
+    with file.open("r", encoding="utf-8") as f:
+        lines = f.readlines()
+
+    # Ensure the range is within bounds
+    start_line = max(0, text_range.start.line)
+    end_line = min(len(lines), text_range.end.line + 1)
+
+    if start_line >= end_line:
+        return ""
+
+    # Extract the relevant portions of each line
+    result = []
+    for i in range(start_line, end_line):
+        line = lines[i]
+        start_char = text_range.start.character if i == text_range.start.line else 0
+        end_char = text_range.end.character if i == text_range.end.line else len(line)
+        result.append(line[start_char:end_char])
+
+    return "".join(result)

sqlmesh/core/linter/rule.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import abc
+from dataclasses import dataclass
 
 from sqlmesh.core.model import Model
 
@@ -22,6 +23,22 @@ class RuleLocation(PydanticModel):
     start_line: t.Optional[int] = None
 
 
+@dataclass(frozen=True)
+class Position:
+    """The position of a rule violation in a file, the position follows the LSP standard."""
+
+    line: int
+    character: int
+
+
+@dataclass(frozen=True)
+class Range:
+    """The range of a rule violation in a file. The range follows the LSP standard."""
+
+    start: Position
+    end: Position
+
+
 class _Rule(abc.ABCMeta):
     def __new__(cls: Type[_Rule], clsname: str, bases: t.Tuple, attrs: t.Dict) -> _Rule:
         attrs["name"] = clsname.lower()
@@ -45,9 +62,15 @@ class Rule(abc.ABC, metaclass=_Rule):
         """A summary of what this rule checks for."""
         return self.__doc__ or ""
 
-    def violation(self, violation_msg: t.Optional[str] = None) -> RuleViolation:
+    def violation(
+        self,
+        violation_msg: t.Optional[str] = None,
+        violation_range: t.Optional[Range] = None,
+    ) -> RuleViolation:
         """Create a RuleViolation instance for this rule"""
-        return RuleViolation(rule=self, violation_msg=violation_msg or self.summary)
+        return RuleViolation(
+            rule=self, violation_msg=violation_msg or self.summary, violation_range=violation_range
+        )
 
     def get_definition_location(self) -> RuleLocation:
         """Return the file path and position information for this rule.
@@ -79,9 +102,12 @@ class Rule(abc.ABC, metaclass=_Rule):
 
 
 class RuleViolation:
-    def __init__(self, rule: Rule, violation_msg: str) -> None:
+    def __init__(
+        self, rule: Rule, violation_msg: str, violation_range: t.Optional[Range] = None
+    ) -> None:
         self.rule = rule
         self.violation_msg = violation_msg
+        self.violation_range = violation_range
 
     def __repr__(self) -> str:
         return f"{self.rule.name}: {self.violation_msg}"

sqlmesh/core/linter/rules/builtin.py

@@ -4,9 +4,11 @@ from __future__ import annotations
 
 import typing as t
 
+from sqlglot.expressions import Star
 from sqlglot.helper import subclasses
 
-from sqlmesh.core.linter.rule import Rule, RuleViolation
+from sqlmesh.core.linter.helpers import TokenPositionDetails
+from sqlmesh.core.linter.rule import Rule, RuleViolation, Range
 from sqlmesh.core.linter.definition import RuleSet
 from sqlmesh.core.model import Model, SqlModel
 
@@ -15,10 +17,25 @@ class NoSelectStar(Rule):
     """Query should not contain SELECT * on its outer most projections, even if it can be expanded."""
 
     def check_model(self, model: Model) -> t.Optional[RuleViolation]:
+        # Only applies to SQL models, as other model types do not have a query.
         if not isinstance(model, SqlModel):
             return None
-
-        return self.violation() if model.query.is_star else None
+        if model.query.is_star:
+            violation_range = self._get_range(model)
+            return self.violation(violation_range=violation_range)
+        return None
+
+    def _get_range(self, model: SqlModel) -> t.Optional[Range]:
+        """Get the range of the violation if available."""
+        try:
+            if len(model.query.expressions) == 1 and isinstance(model.query.expressions[0], Star):
+                return TokenPositionDetails.from_meta(model.query.expressions[0].meta).to_range(
+                    None
+                )
+        except Exception:
+            pass
+
+        return None
 
 
 class InvalidSelectStarExpansion(Rule):

sqlmesh/core/model/meta.py

@@ -323,10 +323,8 @@ class ModelMeta(_Node):
 
             if prop_name == "query_label":
                 query_label = eq.right
-                if not (
-                    isinstance(query_label, exp.Array)
-                    or isinstance(query_label, exp.Tuple)
-                    or isinstance(query_label, exp.Paren)
+                if not isinstance(
+                    query_label, (exp.Array, exp.Tuple, exp.Paren, d.MacroFunc, d.MacroVar)
                 ):
                     raise ConfigError(
                         "Invalid value for `session_properties.query_label`. Must be an array or tuple."
@@ -349,7 +347,9 @@ class ModelMeta(_Node):
                         )
             elif prop_name == "authorization":
                 authorization = eq.right
-                if not (isinstance(authorization, exp.Literal) and authorization.is_string):
+                if not (
+                    isinstance(authorization, exp.Literal) and authorization.is_string
+                ) and not isinstance(authorization, (d.MacroFunc, d.MacroVar)):
                     raise ConfigError(
                         "Invalid value for `session_properties.authorization`. Must be a string literal."
                     )

sqlmesh/core/plan/explainer.py

@@ -195,7 +195,7 @@ class RichExplainerConsole(ExplainerConsole):
 
                 tree.add(model_tree)
             else:
-                tree.add(f"{display_name} \[standalone audit]")
+                tree.add(f"{display_name} \\[standalone audit]")
         return tree
 
     def visit_migrate_schemas_stage(self, stage: stages.MigrateSchemasStage) -> Tree:

sqlmesh/lsp/completions.py

@@ -7,14 +7,25 @@ from sqlmesh.lsp.uri import URI
 
 
 def get_sql_completions(
-    context: t.Optional[LSPContext], file_uri: t.Optional[URI]
+    context: t.Optional[LSPContext], file_uri: t.Optional[URI], content: t.Optional[str] = None
 ) -> AllModelsResponse:
     """
     Return a list of completions for a given file.
     """
+    # Get SQL keywords for the dialect
+    sql_keywords = get_keywords(context, file_uri)
+
+    # Get keywords from file content if provided
+    file_keywords = set()
+    if content:
+        file_keywords = extract_keywords_from_content(content, get_dialect(context, file_uri))
+
+    # Combine keywords - SQL keywords first, then file keywords
+    all_keywords = list(sql_keywords) + list(file_keywords - sql_keywords)
+
     return AllModelsResponse(
         models=list(get_models(context, file_uri)),
-        keywords=list(get_keywords(context, file_uri)),
+        keywords=all_keywords,
     )
 
 
@@ -97,3 +108,54 @@ def get_keywords_from_tokenizer(dialect: t.Optional[str] = None) -> t.Set[str]:
         parts = keyword.split(" ")
         expanded_keywords.update(parts)
     return expanded_keywords
+
+
+def get_dialect(context: t.Optional[LSPContext], file_uri: t.Optional[URI]) -> t.Optional[str]:
+    """
+    Get the dialect for a given file.
+    """
+    if file_uri is not None and context is not None and file_uri.to_path() in context.map:
+        file_info = context.map[file_uri.to_path()]
+
+        # Handle ModelInfo objects
+        if isinstance(file_info, ModelTarget) and file_info.names:
+            model_name = file_info.names[0]
+            model_from_context = context.context.get_model(model_name)
+            return model_from_context.dialect
+
+        # Handle AuditInfo objects
+        if isinstance(file_info, AuditTarget) and file_info.name:
+            audit = context.context.standalone_audits.get(file_info.name)
+            if audit is not None and audit.dialect:
+                return audit.dialect
+
+    if context is not None:
+        return context.context.default_dialect
+
+    return None
+
+
+def extract_keywords_from_content(content: str, dialect: t.Optional[str] = None) -> t.Set[str]:
+    """
+    Extract identifiers from SQL content using the tokenizer.
+    Only extracts identifiers (variable names, table names, column names, etc.)
+    that are not SQL keywords.
+    """
+    if not content:
+        return set()
+
+    tokenizer_class = Dialect.get_or_raise(dialect).tokenizer_class
+    keywords = set()
+    try:
+        tokenizer = tokenizer_class()
+        tokens = tokenizer.tokenize(content)
+        for token in tokens:
+            # Don't include keywords in the set
+            if token.text.upper() not in tokenizer_class.KEYWORDS:
+                keywords.add(token.text)
+
+    except Exception:
+        # If tokenization fails, return empty set
+        pass
+
+    return keywords

sqlmesh/lsp/context.py

@@ -5,7 +5,7 @@ import typing as t
 
 from sqlmesh.core.model.definition import SqlModel
 from sqlmesh.core.linter.definition import AnnotatedRuleViolation
-from sqlmesh.lsp.custom import RenderModelEntry, ModelForRendering
+from sqlmesh.lsp.custom import ModelForRendering
 from sqlmesh.lsp.custom import AllModelsResponse, RenderModelEntry
 from sqlmesh.lsp.uri import URI
 
@@ -176,15 +176,18 @@ class LSPContext:
             if audit._path is not None
         ]
 
-    def get_autocomplete(self, uri: t.Optional[URI]) -> AllModelsResponse:
+    def get_autocomplete(
+        self, uri: t.Optional[URI], content: t.Optional[str] = None
+    ) -> AllModelsResponse:
         """Get autocomplete suggestions for a file.
 
         Args:
             uri: The URI of the file to get autocomplete suggestions for.
+            content: The content of the file (optional).
 
         Returns:
             AllModelsResponse containing models and keywords.
         """
         from sqlmesh.lsp.completions import get_sql_completions
 
-        return get_sql_completions(self, uri)
+        return get_sql_completions(self, uri, content)

sqlmesh/lsp/main.py

@@ -36,9 +36,7 @@ from sqlmesh.lsp.custom import (
     RenderModelRequest,
     RenderModelResponse,
 )
-from sqlmesh.lsp.reference import (
-    get_references,
-)
+from sqlmesh.lsp.reference import get_references, get_cte_references
 from sqlmesh.lsp.uri import URI
 from web.server.api.endpoints.lineage import column_lineage, model_lineage
 from web.server.api.endpoints.models import get_models
@@ -114,13 +112,22 @@ class SQLMeshLanguageServer:
         @self.server.feature(ALL_MODELS_FEATURE)
         def all_models(ls: LanguageServer, params: AllModelsRequest) -> AllModelsResponse:
             uri = URI(params.textDocument.uri)
+
+            # Get the document content
+            content = None
+            try:
+                document = ls.workspace.get_text_document(params.textDocument.uri)
+                content = document.source
+            except Exception:
+                pass
+
             try:
                 context = self._context_get_or_load(uri)
-                return context.get_autocomplete(uri)
+                return context.get_autocomplete(uri, content)
             except Exception as e:
                 from sqlmesh.lsp.completions import get_sql_completions
 
-                return get_sql_completions(None, URI(params.textDocument.uri))
+                return get_sql_completions(None, URI(params.textDocument.uri), content)
 
         @self.server.feature(RENDER_MODEL_FEATURE)
         def render_model(ls: LanguageServer, params: RenderModelRequest) -> RenderModelResponse:
@@ -369,6 +376,28 @@ class SQLMeshLanguageServer:
                 ls.show_message(f"Error getting references: {e}", types.MessageType.Error)
                 return []
 
+        @self.server.feature(types.TEXT_DOCUMENT_REFERENCES)
+        def find_references(
+            ls: LanguageServer, params: types.ReferenceParams
+        ) -> t.Optional[t.List[types.Location]]:
+            """Find all references of a symbol (currently supporting CTEs)"""
+            try:
+                uri = URI(params.text_document.uri)
+                self._ensure_context_for_document(uri)
+                document = ls.workspace.get_text_document(params.text_document.uri)
+                if self.lsp_context is None:
+                    raise RuntimeError(f"No context found for document: {document.path}")
+
+                cte_references = get_cte_references(self.lsp_context, uri, params.position)
+
+                # Convert references to Location objects
+                locations = [types.Location(uri=ref.uri, range=ref.range) for ref in cte_references]
+
+                return locations if locations else None
+            except Exception as e:
+                ls.show_message(f"Error getting locations: {e}", types.MessageType.Error)
+                return None
+
         @self.server.feature(types.TEXT_DOCUMENT_DIAGNOSTIC)
         def diagnostic(
             ls: LanguageServer, params: types.DocumentDiagnosticParams
@@ -471,8 +500,16 @@ class SQLMeshLanguageServer:
                 uri = URI(params.text_document.uri)
                 context = self._context_get_or_load(uri)
 
+                # Get the document content
+                content = None
+                try:
+                    document = ls.workspace.get_text_document(params.text_document.uri)
+                    content = document.source
+                except Exception:
+                    pass
+
                 # Get completions using the existing completions module
-                completion_response = context.get_autocomplete(uri)
+                completion_response = context.get_autocomplete(uri, content)
 
                 completion_items = []
                 # Add model completions
@@ -618,8 +655,24 @@ class SQLMeshLanguageServer:
     ) -> t.Optional[types.Diagnostic]:
         if diagnostic.model._path is None:
             return None
-        with open(diagnostic.model._path, "r", encoding="utf-8") as file:
-            lines = file.readlines()
+        if not diagnostic.violation_range:
+            with open(diagnostic.model._path, "r", encoding="utf-8") as file:
+                lines = file.readlines()
+            range = types.Range(
+                start=types.Position(line=0, character=0),
+                end=types.Position(line=len(lines) - 1, character=len(lines[-1])),
+            )
+        else:
+            range = types.Range(
+                start=types.Position(
+                    line=diagnostic.violation_range.start.line,
+                    character=diagnostic.violation_range.start.character,
+                ),
+                end=types.Position(
+                    line=diagnostic.violation_range.end.line,
+                    character=diagnostic.violation_range.end.character,
+                ),
+            )
 
         # Get rule definition location for diagnostics link
         rule_location = diagnostic.rule.get_definition_location()
@@ -628,10 +681,7 @@ class SQLMeshLanguageServer:
 
         # Use URI format to create a link for "related information"
         return types.Diagnostic(
-            range=types.Range(
-                start=types.Position(line=0, character=0),
-                end=types.Position(line=len(lines), character=len(lines[-1])),
-            ),
+            range=range,
             message=diagnostic.violation_msg,
             severity=types.DiagnosticSeverity.Error
             if diagnostic.violation_type == "error"

sqlmesh/lsp/reference.py

@@ -4,6 +4,11 @@ from pathlib import Path
 
 from sqlmesh.core.audit import StandaloneAudit
 from sqlmesh.core.dialect import normalize_model_name
+from sqlmesh.core.linter.helpers import (
+    TokenPositionDetails,
+    Range as SQLMeshRange,
+    Position as SQLMeshPosition,
+)
 from sqlmesh.core.model.definition import SqlModel
 from sqlmesh.lsp.context import LSPContext, ModelTarget, AuditTarget
 from sqlglot import exp
@@ -47,16 +52,7 @@ def by_position(position: Position) -> t.Callable[[Reference], bool]:
     """
 
     def contains_position(r: Reference) -> bool:
-        return (
-            r.range.start.line < position.line
-            or (
-                r.range.start.line == position.line
-                and r.range.start.character <= position.character
-            )
-        ) and (
-            r.range.end.line > position.line
-            or (r.range.end.line == position.line and r.range.end.character >= position.character)
-        )
+        return _position_within_range(position, r.range)
 
     return contains_position
 
@@ -165,12 +161,17 @@ def get_model_definitions_for_a_path(
                     if isinstance(alias, exp.TableAlias):
                         identifier = alias.this
                         if isinstance(identifier, exp.Identifier):
-                            target_range = _range_from_token_position_details(
-                                TokenPositionDetails.from_meta(identifier.meta), read_file
-                            )
-                            table_range = _range_from_token_position_details(
-                                TokenPositionDetails.from_meta(table.this.meta), read_file
-                            )
+                            target_range_sqlmesh = TokenPositionDetails.from_meta(
+                                identifier.meta
+                            ).to_range(read_file)
+                            table_range_sqlmesh = TokenPositionDetails.from_meta(
+                                table.this.meta
+                            ).to_range(read_file)
+
+                            # Convert SQLMesh Range to LSP Range
+                            target_range = to_lsp_range(target_range_sqlmesh)
+                            table_range = to_lsp_range(table_range_sqlmesh)
+
                             references.append(
                                 Reference(
                                     uri=document_uri.value,  # Same file
@@ -212,25 +213,26 @@ def get_model_definitions_for_a_path(
 
                 # Extract metadata for positioning
                 table_meta = TokenPositionDetails.from_meta(table.this.meta)
-                table_range = _range_from_token_position_details(table_meta, read_file)
-                start_pos = table_range.start
-                end_pos = table_range.end
+                table_range_sqlmesh = table_meta.to_range(read_file)
+                start_pos_sqlmesh = table_range_sqlmesh.start
+                end_pos_sqlmesh = table_range_sqlmesh.end
 
                 # If there's a catalog or database qualifier, adjust the start position
                 catalog_or_db = table.args.get("catalog") or table.args.get("db")
                 if catalog_or_db is not None:
                     catalog_or_db_meta = TokenPositionDetails.from_meta(catalog_or_db.meta)
-                    catalog_or_db_range = _range_from_token_position_details(
-                        catalog_or_db_meta, read_file
-                    )
-                    start_pos = catalog_or_db_range.start
+                    catalog_or_db_range_sqlmesh = catalog_or_db_meta.to_range(read_file)
+                    start_pos_sqlmesh = catalog_or_db_range_sqlmesh.start
 
                 description = generate_markdown_description(referenced_model)
 
                 references.append(
                     Reference(
                         uri=referenced_model_uri.value,
-                        range=Range(start=start_pos, end=end_pos),
+                        range=Range(
+                            start=to_lsp_position(start_pos_sqlmesh),
+                            end=to_lsp_position(end_pos_sqlmesh),
+                        ),
                         markdown_description=description,
                     )
                 )
@@ -238,71 +240,6 @@ def get_model_definitions_for_a_path(
     return references
 
 
-class TokenPositionDetails(PydanticModel):
-    """
-    Details about a token's position in the source code.
-
-    Attributes:
-        line (int): The line that the token ends on.
-        col (int): The column that the token ends on.
-        start (int): The start index of the token.
-        end (int): The ending index of the token.
-    """
-
-    line: int
-    col: int
-    start: int
-    end: int
-
-    @staticmethod
-    def from_meta(meta: t.Dict[str, int]) -> "TokenPositionDetails":
-        return TokenPositionDetails(
-            line=meta["line"],
-            col=meta["col"],
-            start=meta["start"],
-            end=meta["end"],
-        )
-
-
-def _range_from_token_position_details(
-    token_position_details: TokenPositionDetails, read_file: t.List[str]
-) -> Range:
-    """
-    Convert a TokenPositionDetails object to a Range object.
-
-    :param token_position_details: Details about a token's position
-    :param read_file: List of lines from the file
-    :return: A Range object representing the token's position
-    """
-    # Convert from 1-indexed to 0-indexed for line only
-    end_line_0 = token_position_details.line - 1
-    end_col_0 = token_position_details.col
-
-    # Find the start line and column by counting backwards from the end position
-    start_pos = token_position_details.start
-    end_pos = token_position_details.end
-
-    # Initialize with the end position
-    start_line_0 = end_line_0
-    start_col_0 = end_col_0 - (end_pos - start_pos + 1)
-
-    # If start_col_0 is negative, we need to go back to previous lines
-    while start_col_0 < 0 and start_line_0 > 0:
-        start_line_0 -= 1
-        start_col_0 += len(read_file[start_line_0])
-        # Account for newline character
-        if start_col_0 >= 0:
-            break
-        start_col_0 += 1  # For the newline character
-
-    # Ensure we don't have negative values
-    start_col_0 = max(0, start_col_0)
-    return Range(
-        start=Position(line=start_line_0, character=start_col_0),
-        end=Position(line=end_line_0, character=end_col_0),
-    )
-
-
 def get_macro_definitions_for_a_path(
     lsp_context: LSPContext, document_uri: URI
 ) -> t.List[Reference]:
@@ -382,11 +319,10 @@ def get_macro_reference(
     try:
         # Get the position of the macro invocation in the source file first
         if hasattr(node, "meta") and node.meta:
-            token_details = TokenPositionDetails.from_meta(node.meta)
-            macro_range = _range_from_token_position_details(token_details, read_file)
+            macro_range = TokenPositionDetails.from_meta(node.meta).to_range(read_file)
 
             # Check if it's a built-in method
-            if builtin := get_built_in_macro_reference(macro_name, macro_range):
+            if builtin := get_built_in_macro_reference(macro_name, to_lsp_range(macro_range)):
                 return builtin
         else:
             # Skip if we can't get the position
@@ -438,7 +374,7 @@ def get_macro_reference(
 
         return Reference(
             uri=macro_uri.value,
-            range=macro_range,
+            range=to_lsp_range(macro_range),
             target_range=Range(
                 start=Position(line=start_line - 1, character=0),
                 end=Position(line=end_line - 1, character=get_length_of_end_line),
@@ -478,3 +414,99 @@ def get_built_in_macro_reference(macro_name: str, macro_range: Range) -> t.Optio
         ),
         markdown_description=func.__doc__ if func.__doc__ else None,
     )
+
+
+def get_cte_references(
+    lint_context: LSPContext, document_uri: URI, position: Position
+) -> t.List[Reference]:
+    """
+    Get all references to a CTE at a specific position in a document.
+
+    This function finds both the definition and all usages of a CTE within the same file.
+
+    Args:
+        lint_context: The LSP context
+        document_uri: The URI of the document
+        position: The position to check for CTE references
+
+    Returns:
+        A list of references to the CTE (including its definition and all usages)
+    """
+    references = get_model_definitions_for_a_path(lint_context, document_uri)
+
+    # Filter for CTE references (those with target_range set and same URI)
+    # TODO: Consider extending Reference class to explicitly indicate reference type instead
+    cte_references = [
+        ref for ref in references if ref.target_range is not None and ref.uri == document_uri.value
+    ]
+
+    if not cte_references:
+        return []
+
+    target_cte_definition_range = None
+    for ref in cte_references:
+        # Check if cursor is on a CTE usage
+        if _position_within_range(position, ref.range):
+            target_cte_definition_range = ref.target_range
+            break
+        # Check if cursor is on the CTE definition
+        elif ref.target_range and _position_within_range(position, ref.target_range):
+            target_cte_definition_range = ref.target_range
+            break
+
+    if target_cte_definition_range is None:
+        return []
+
+    # Add the CTE definition
+    matching_references = [
+        Reference(
+            uri=document_uri.value,
+            range=target_cte_definition_range,
+            markdown_description="CTE definition",
+        )
+    ]
+
+    # Add all usages
+    for ref in cte_references:
+        if ref.target_range == target_cte_definition_range:
+            matching_references.append(
+                Reference(
+                    uri=document_uri.value,
+                    range=ref.range,
+                    markdown_description="CTE usage",
+                )
+            )
+
+    return matching_references
+
+
+def _position_within_range(position: Position, range: Range) -> bool:
+    """Check if a position is within a given range."""
+    return (
+        range.start.line < position.line
+        or (range.start.line == position.line and range.start.character <= position.character)
+    ) and (
+        range.end.line > position.line
+        or (range.end.line == position.line and range.end.character >= position.character)
+    )
+
+
+def to_lsp_range(
+    range: SQLMeshRange,
+) -> Range:
+    """
+    Converts a SQLMesh Range to an LSP Range.
+    """
+    return Range(
+        start=Position(line=range.start.line, character=range.start.character),
+        end=Position(line=range.end.line, character=range.end.character),
+    )
+
+
+def to_lsp_position(
+    position: SQLMeshPosition,
+) -> Position:
+    """
+    Converts a SQLMesh Position to an LSP Position.
+    """
+    return Position(line=position.line, character=position.character)

{sqlmesh-0.189.1.dev2.dist-info → sqlmesh-0.189.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.189.1.dev2
+Version: 0.189.2
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.189.1.dev2.dist-info → sqlmesh-0.189.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 sqlmesh/__init__.py,sha256=QjwaamJIdW7voXoS880yAx7tHm-Im4_mqGA-XJgafos,7631
-sqlmesh/_version.py,sha256=WRGFpactk3aY9TjStKBfERG2oCJQD2qAYC0_jGZurpQ,528
+sqlmesh/_version.py,sha256=kra5ta__MYnZcxN-ELkhfg1WzR3g3TjVwihb3Azv-3w,515
 sqlmesh/magics.py,sha256=fu7-OeT_0_TAkWZOLoiioE3-3iFpvTRxFCbQUlRnfuw,39944
 sqlmesh/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/cicd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -61,7 +61,7 @@ sqlmesh/core/engine_adapter/_typing.py,sha256=_63pYCThfC39UtPVHY3N0H6qJ1YBT32Oqw
 sqlmesh/core/engine_adapter/athena.py,sha256=WBVAB_YzBJXdiqq51LTd2jmYoMtGrLmtsA8IrIFVnQ0,26199
 sqlmesh/core/engine_adapter/base.py,sha256=2W3dPeO7iqaA3byEDziB3lBh7pjgaq4_J8IKkcX4urg,101348
 sqlmesh/core/engine_adapter/base_postgres.py,sha256=DOsOdCJyQAVfA9S0GznuH0J1bonMqYVP_yJLDYcxFYM,6772
-sqlmesh/core/engine_adapter/bigquery.py,sha256=lU2zUFuD11qVxrGXX82oUSLMkUZAs-1lWk1XdJFofXo,50234
+sqlmesh/core/engine_adapter/bigquery.py,sha256=qJE8vHLKKAeWMvltmYaUvWS95jM_UEZ6UzYLlr58sGo,50424
 sqlmesh/core/engine_adapter/clickhouse.py,sha256=LoPdm_s_s-ZxS1XJPA3Et0iOHeJ1LgqTAFbwBdiqE7A,34912
 sqlmesh/core/engine_adapter/databricks.py,sha256=8ZExPIeT3dDh9MTJW8udvmh9LiY-f9HkRAN1Q5Qebhs,14541
 sqlmesh/core/engine_adapter/duckdb.py,sha256=rFv27sF1KXhJcrIuM9Zdfl2cyZNRXEF9qQczgODdK0M,4614
@@ -74,12 +74,13 @@ sqlmesh/core/engine_adapter/risingwave.py,sha256=YYCQ0EJaSrR9_P1_2_LmElQ6zSxqkZz
 sqlmesh/core/engine_adapter/shared.py,sha256=NyF2osSJDWPp7KlJUBR4GZcS_cJFr4daUPvhGyp4XcQ,12909
 sqlmesh/core/engine_adapter/snowflake.py,sha256=oaZxKPmPXxmr46NQfw6OI5vPwvaYJ3Ym8OnnhDiUXNw,27234
 sqlmesh/core/engine_adapter/spark.py,sha256=sYkVOPS0X43UPbI0z7Hh_EpKlI36qkOcr4NNFOTQlLs,21045
-sqlmesh/core/engine_adapter/trino.py,sha256=AefxwlgE-lw9OgzWa0lHsyL7WTqRMBZwymtNakEZSOo,15567
+sqlmesh/core/engine_adapter/trino.py,sha256=7WdLFlT0AyD5NF0EDP7GqX0SHF8sTm7cafBZxk84cmY,15798
 sqlmesh/core/linter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlmesh/core/linter/definition.py,sha256=UL05OjFBfoLSYGWXNf4zjZYzIKr-OyFIMIcIh7RhR8s,5237
-sqlmesh/core/linter/rule.py,sha256=p8rbMbf2Z18ZJ6ZcZyoCk-3Lvo7d_Gvc35tiwWXvuQs,2579
+sqlmesh/core/linter/definition.py,sha256=Rjqvto7VvVEnMXXOH4q3Jol1HnPe6I6BCHK1sEJm50I,5430
+sqlmesh/core/linter/helpers.py,sha256=VF4hsdzGZ8srpbtCjdRN_Hd8S_er5KTAaLXLde27Yxo,4032
+sqlmesh/core/linter/rule.py,sha256=iCmFUw6Qx7GuUwLKIpHrHdq3kgtgm5JC2t9VFtMY3BQ,3180
 sqlmesh/core/linter/rules/__init__.py,sha256=gevzfb67vFqckTCoVAe_TBGf6hQ-YtE1_YuGuXyh1L0,77
-sqlmesh/core/linter/rules/builtin.py,sha256=RXns3e042q8aM-3wDUNDc7dcX5hDiOO7qel1YnjeqUk,1950
+sqlmesh/core/linter/rules/builtin.py,sha256=EHTd4sgHT6oT93onK7t5pLmv2KgzZ81twkTnOrMi9tI,2681
 sqlmesh/core/metric/__init__.py,sha256=H1HmoD5IwN4YWe9iJXyueLYNmTQFZwok5nSWNJcZIBQ,237
 sqlmesh/core/metric/definition.py,sha256=Yd5aVgsZCDPJ43aGP7WqtzZOuuSUtB8uJGVA6Jw9x9M,7201
 sqlmesh/core/metric/rewriter.py,sha256=GiSTHfn2kinqCfNPYgZPRk93JFLzVaaejHtHDQ0yXZI,7326
@@ -89,14 +90,14 @@ sqlmesh/core/model/common.py,sha256=vbcXFhWE22-FeKYAVIlKWvTb-wkeC8XISjU_TIlak0c,
 sqlmesh/core/model/decorator.py,sha256=v_sVudNROGrtj5cZ3vgcOFnwPdzwoUGY6REAkQpIMQc,8927
 sqlmesh/core/model/definition.py,sha256=G2FHqCsJaDOzRcJCdTlfe6Ygl55rh9RAEXC1Zaka8uA,108470
 sqlmesh/core/model/kind.py,sha256=i6_AMBarXPGPoMdF9kzBkyqS9tu__a2339-BoX7TgCM,36010
-sqlmesh/core/model/meta.py,sha256=TRsCztBea2gSknPQxoY1ct13hdWgD0mM9XTHqu5KDgs,21167
+sqlmesh/core/model/meta.py,sha256=D9InI9M2-IXeb34vkXNQSLALL8xVXjZ_LXwI-Tqxm7I,21197
 sqlmesh/core/model/schema.py,sha256=OClbAeA8LpW-IiSiLT_TlDWkEqmIIvSk0GXq8SWI-GQ,3443
 sqlmesh/core/model/seed.py,sha256=a0M-1zY1gOkN5ph2GQyataEdBSCtq50YjeFk2LyvInI,5058
 sqlmesh/core/plan/__init__.py,sha256=aieod5xxcJJl0m7Xp9BXCwwrYnhMbeltGoNZGjwoVTA,521
 sqlmesh/core/plan/builder.py,sha256=mZ64P0m4LDtkyy4NoPsz8gqhtezF8Piaw5aj0_YuTjA,38496
 sqlmesh/core/plan/definition.py,sha256=pBjQu1P5U-XheWOe9WkSNAZeLzYE7LFgYtq6-4Fx67g,13236
 sqlmesh/core/plan/evaluator.py,sha256=7dPtjxc4SuKf9fHsMDwaGsprlXmhcoKi0N6Q1N8eFY4,27009
-sqlmesh/core/plan/explainer.py,sha256=-12__YFHEeKfvcggquZVMFq-Q3DBIy-kMvdyU5j8K5U,11237
+sqlmesh/core/plan/explainer.py,sha256=LAeboOuHc-gug-9C34rHn9yrsyCyNTeCJHU95WftAxc,11238
 sqlmesh/core/plan/stages.py,sha256=AIBzEji7OorFx9B0Hm50E6h8zWIGSuLkoVWqIhq9AVw,10911
 sqlmesh/core/snapshot/__init__.py,sha256=Z5HTetNCZGoKF1WAKXk4LWL9dc8EC8lwS2O4TtoBmt4,1317
 sqlmesh/core/snapshot/cache.py,sha256=bgqCR2hyf6r2A_8QP1EnXFK25gDX37-Zg0YeMuETWxg,3934
@@ -158,12 +159,12 @@ sqlmesh/integrations/github/cicd/command.py,sha256=rNWb-aMOA9R23YumD5vPwR0PgPGGj
 sqlmesh/integrations/github/cicd/config.py,sha256=tRhMZaLf1p6AWXvi67n85Q-lptJNGt1Wk_Jr61ytpiM,2104
 sqlmesh/integrations/github/cicd/controller.py,sha256=IgUWK9orYSMiElO3GaL6Ja-osFgA7je3RDcLChWUi5s,43769
 sqlmesh/lsp/api.py,sha256=LJdECSaEZoPbu_Xl4KscVG-WLt7_g4dY-zKGO68dH14,2162
-sqlmesh/lsp/completions.py,sha256=Ufe5XyqmT8ttXqQDbhH2RtuGC0cVuVfSnGqDMl6KmB4,3601
-sqlmesh/lsp/context.py,sha256=ozkrw-897_Scbbn4AnKdeTQhrUb0CI0e34vcV-5U2DA,6158
+sqlmesh/lsp/completions.py,sha256=Y6zNKNne91tzRm5vRk82JmhIpo7dIBUoK8GGQesGlT8,5746
+sqlmesh/lsp/context.py,sha256=36bUTiMSyfX91bri_F1aivDvSllq0rKidIM_RGAtirs,6253
 sqlmesh/lsp/custom.py,sha256=Mml6V1nYAHdP4Zt8gxly1ZLKYALtxGeAVzPrrYpc7m8,1426
 sqlmesh/lsp/description.py,sha256=4QIGC9ix8IzmWF6DVUNhY4m1Crk3sNQA6hZ1RbyqU78,827
-sqlmesh/lsp/main.py,sha256=Y1ISd75Ax09cNkSHw-Z0w_56IQXmmGxoGDWFT6KLs6g,30564
-sqlmesh/lsp/reference.py,sha256=-HkMMzRzq4ike5mSkoWajanYNMAwhQhlPaqw62451ac,16887
+sqlmesh/lsp/main.py,sha256=fu274od-9qfStr1BEiC4lnxN9mPxSdEm69CIm5Nmxeo,32763
+sqlmesh/lsp/reference.py,sha256=dyeacD_MHATGRIrl8Ax86nDK9EC_dh3TaaVNAepPce0,17902
 sqlmesh/lsp/uri.py,sha256=mvSLbZGmMTHPpliThOtVWiFcHnfJzp1w39q9l-xD2SI,802
 sqlmesh/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/migrations/v0001_init.py,sha256=h8FwMYJj9_O8yGpk12guaSaGwX5A3we2GiKeHrXi15o,2048
@@ -272,7 +273,7 @@ sqlmesh/utils/pydantic.py,sha256=I898jAFqa3qU6lG2uPpRebVFncOUo8ZrLWM_R3K3DHU,116
 sqlmesh/utils/rich.py,sha256=xNZyPCqEc4TAlJlsEthg-5eYUWpaizz0QjBzO7a1Yv4,1509
 sqlmesh/utils/windows.py,sha256=r7Yin4WEwbvH7sKA3hOJtRsclmscNuBeCklCfVPvtQs,611
 sqlmesh/utils/yaml.py,sha256=np-WVcwmwsKghCgAj1OBBMsK1SXSRn4wR-H37cGiFr8,2282
-sqlmesh-0.189.1.dev2.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
+sqlmesh-0.189.2.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
 web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web/client/dist/index.html,sha256=LbR9XrOXE77otBPoDnaomssYz6h2TBwLANs6hUJ0p2M,5472
 web/client/dist/assets/Audits-DB1HcP9M.js,sha256=eGI_Soj69Jntsixw1NqQpdwG94N5jipQZv7T1Y7WUSs,1041
@@ -390,8 +391,8 @@ web/server/api/endpoints/models.py,sha256=ud-lRwriyI_OYg9tZchrBgeiXELiRTLNEodraf
 web/server/api/endpoints/modules.py,sha256=8hqqgonGay_mJmpCw0IdbjsPhWlQH2VLdKAqha-myac,468
 web/server/api/endpoints/plan.py,sha256=OYuQ_4dgbhG9ibTcX1a8mvYgH3ANxw9Fhbb4wg6QWqc,9222
 web/server/api/endpoints/table_diff.py,sha256=SCy3-pr5x6bEEiOaZGCDbiHQhpgxwmnz3Acqa2Ie6jI,2090
-sqlmesh-0.189.1.dev2.dist-info/METADATA,sha256=PZbnj7sOVFzEyv2j9NphOliFN1hh6NWDby5QO-XoM8A,26540
-sqlmesh-0.189.1.dev2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlmesh-0.189.1.dev2.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
-sqlmesh-0.189.1.dev2.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
-sqlmesh-0.189.1.dev2.dist-info/RECORD,,
+sqlmesh-0.189.2.dist-info/METADATA,sha256=ToEJw-gXy6awCbUCrU2v5583s5hO6zLynCm4DiLNFuk,26535
+sqlmesh-0.189.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlmesh-0.189.2.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
+sqlmesh-0.189.2.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
+sqlmesh-0.189.2.dist-info/RECORD,,