sqlmesh 0.189.2.dev4__py3-none-any.whl → 0.189.3.dev1__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.2.dev4'
-__version_tuple__ = version_tuple = (0, 189, 2, 'dev4')
+__version__ = version = '0.189.3.dev1'
+__version_tuple__ = version_tuple = (0, 189, 3, 'dev1')

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/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
 

sqlmesh/lsp/hints.py

@@ -0,0 +1,136 @@
+"""Type hinting on SQLMesh models"""
+
+import typing as t
+
+from lsprotocol import types
+
+from sqlglot import exp
+from sqlglot.expressions import Expression
+from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
+from sqlmesh.core.model.definition import SqlModel
+from sqlmesh.lsp.context import LSPContext, ModelTarget
+from sqlmesh.lsp.uri import URI
+
+
+def get_hints(
+    lsp_context: LSPContext,
+    document_uri: URI,
+    start_line: int,
+    end_line: int,
+) -> t.List[types.InlayHint]:
+    """
+    Get type hints for certain lines in a document
+
+    Args:
+        lint_context: The LSP context
+        document_uri: The URI of the document
+        start_line: the starting line to get hints for
+        end_line: the ending line to get hints for
+
+    Returns:
+        A list of hints to apply to the document
+    """
+    path = document_uri.to_path()
+    if path.suffix != ".sql":
+        return []
+
+    if path not in lsp_context.map:
+        return []
+
+    file_info = lsp_context.map[path]
+
+    # Process based on whether it's a model or standalone audit
+    if not isinstance(file_info, ModelTarget):
+        return []
+
+    # It's a model
+    model = lsp_context.context.get_model(
+        model_or_snapshot=file_info.names[0], raise_if_missing=False
+    )
+    if not isinstance(model, SqlModel):
+        return []
+
+    query = model.query
+    dialect = model.dialect
+    columns_to_types = model.columns_to_types or {}
+
+    return _get_type_hints_for_model_from_query(
+        query, dialect, columns_to_types, start_line, end_line
+    )
+
+
+def _get_type_hints_for_select(
+    expression: exp.Expression,
+    dialect: str,
+    columns_to_types: t.Dict[str, exp.DataType],
+    start_line: int,
+    end_line: int,
+) -> t.List[types.InlayHint]:
+    hints: t.List[types.InlayHint] = []
+
+    for select_exp in expression.expressions:
+        if isinstance(select_exp, exp.Alias):
+            if isinstance(select_exp.this, exp.Cast):
+                continue
+
+            meta = select_exp.args["alias"].meta
+
+        elif isinstance(select_exp, exp.Column):
+            meta = select_exp.parts[-1].meta
+        else:
+            continue
+
+        if "line" not in meta or "col" not in meta:
+            continue
+
+        line = meta["line"]
+        col = meta["col"]
+
+        # Lines from sqlglot are 1 based
+        line -= 1
+
+        if line < start_line or line > end_line:
+            continue
+
+        name = select_exp.alias_or_name
+        data_type = columns_to_types.get(name)
+
+        if not data_type or data_type.is_type(exp.DataType.Type.UNKNOWN):
+            continue
+
+        type_label = data_type.sql(dialect)
+        hints.append(
+            types.InlayHint(
+                label=f"::{type_label}",
+                kind=types.InlayHintKind.Type,
+                padding_left=False,
+                padding_right=True,
+                position=types.Position(line=line, character=col),
+            )
+        )
+
+    return hints
+
+
+def _get_type_hints_for_model_from_query(
+    query: Expression,
+    dialect: str,
+    columns_to_types: t.Dict[str, exp.DataType],
+    start_line: int,
+    end_line: int,
+) -> t.List[types.InlayHint]:
+    hints: t.List[types.InlayHint] = []
+    try:
+        query = normalize_identifiers(query.copy(), dialect=dialect)
+
+        # Return the hints for top level selects (model definition columns only)
+        return [
+            hint
+            for q in query.walk(prune=lambda n: not isinstance(n, exp.SetOperation))
+            if isinstance(select := q.unnest(), exp.Select)
+            for hint in _get_type_hints_for_select(
+                q, dialect, columns_to_types, start_line, end_line
+            )
+        ]
+    except Exception:
+        return []

sqlmesh/lsp/main.py

@@ -36,9 +36,8 @@ from sqlmesh.lsp.custom import (
     RenderModelRequest,
     RenderModelResponse,
 )
-from sqlmesh.lsp.reference import (
-    get_references,
-)
+from sqlmesh.lsp.hints import get_hints
+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
@@ -336,6 +335,25 @@ class SQLMeshLanguageServer:
                 )
                 return None
 
+        @self.server.feature(types.TEXT_DOCUMENT_INLAY_HINT)
+        def inlay_hint(
+            ls: LanguageServer, params: types.InlayHintParams
+        ) -> t.List[types.InlayHint]:
+            """Implement type hints for sql columns as inlay hints"""
+            try:
+                uri = URI(params.text_document.uri)
+                self._ensure_context_for_document(uri)
+                if self.lsp_context is None:
+                    raise RuntimeError(f"No context found for document: {uri}")
+
+                start_line = params.range.start.line
+                end_line = params.range.end.line
+                hints = get_hints(self.lsp_context, uri, start_line, end_line)
+                return hints
+
+            except Exception as e:
+                return []
+
         @self.server.feature(types.TEXT_DOCUMENT_DEFINITION)
         def goto_definition(
             ls: LanguageServer, params: types.DefinitionParams
@@ -378,6 +396,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
@@ -635,8 +675,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()
@@ -645,10 +701,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.2.dev4.dist-info → sqlmesh-0.189.3.dev1.dist-info}/METADATA

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

{sqlmesh-0.189.2.dev4.dist-info → sqlmesh-0.189.3.dev1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 sqlmesh/__init__.py,sha256=QjwaamJIdW7voXoS880yAx7tHm-Im4_mqGA-XJgafos,7631
-sqlmesh/_version.py,sha256=gPn7f-b1_vQBeafN1P-jTVGz6Eyorz0_SbXFkp6VS2Q,528
+sqlmesh/_version.py,sha256=46P0A4hbz6tPxXHU78sPmL24cECOw9bp_3B8jB9kTr8,528
 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
@@ -76,10 +76,11 @@ sqlmesh/core/engine_adapter/snowflake.py,sha256=oaZxKPmPXxmr46NQfw6OI5vPwvaYJ3Ym
 sqlmesh/core/engine_adapter/spark.py,sha256=sYkVOPS0X43UPbI0z7Hh_EpKlI36qkOcr4NNFOTQlLs,21045
 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
@@ -159,11 +160,12 @@ sqlmesh/integrations/github/cicd/config.py,sha256=tRhMZaLf1p6AWXvi67n85Q-lptJNGt
 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=Y6zNKNne91tzRm5vRk82JmhIpo7dIBUoK8GGQesGlT8,5746
-sqlmesh/lsp/context.py,sha256=RVFGjKWv1o509su80izZL-Wqy8vWElqUDnv2XWvBsgs,6271
+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=LwNdy-0m_CldUBlDdZv49cgZQTfjTwZQGBC3U5-Iln4,31141
-sqlmesh/lsp/reference.py,sha256=-HkMMzRzq4ike5mSkoWajanYNMAwhQhlPaqw62451ac,16887
+sqlmesh/lsp/hints.py,sha256=j-blccBUil94yRoDjWfkSM0HqMmsKD6hP2TaWdWWVk4,3734
+sqlmesh/lsp/main.py,sha256=c1h1hWluBixEFZEX2jiBjA_EOgguruaG9cSLjCrEPr8,33581
+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 +274,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.2.dev4.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
+sqlmesh-0.189.3.dev1.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 +392,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.2.dev4.dist-info/METADATA,sha256=btn7l22yJ9q-XFDTTNEUx5o5lpIhqvTef4lXTs6vhDE,26540
-sqlmesh-0.189.2.dev4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlmesh-0.189.2.dev4.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
-sqlmesh-0.189.2.dev4.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
-sqlmesh-0.189.2.dev4.dist-info/RECORD,,
+sqlmesh-0.189.3.dev1.dist-info/METADATA,sha256=S9cWZvOMCb4TkPpsuwJOjHs_Bcbiddm0657q1eWV8jE,26540
+sqlmesh-0.189.3.dev1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlmesh-0.189.3.dev1.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
+sqlmesh-0.189.3.dev1.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
+sqlmesh-0.189.3.dev1.dist-info/RECORD,,