rbtr-lang-sql 2026.9.0.dev1__py3-none-any.whl

rbtr_lang_sql/tests/test_samples.py

@@ -0,0 +1,115 @@
+"""SQL sample extraction: the `samples/sql/` project through the real pipeline.
+
+The snapshots are the golden record of what SQL extraction produces. The
+`dialect` tests document how the single generic grammar handles each major
+dialect. Engine-wide invariants are covered once in core.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pytest
+from tree_sitter import Parser
+
+from rbtr.domain.models import Chunk, ChunkKind, Edge
+from rbtr.git import FileEntry
+from rbtr.languages.edges import build_resolution_map, infer_import_edges
+from rbtr.languages.extract import extract_file
+from rbtr.languages.manager import get_manager
+from rbtr.testing import render_edges
+
+if TYPE_CHECKING:
+    from syrupy.assertion import SnapshotAssertion
+
+
+@pytest.fixture
+def project() -> list[tuple[str, str]]:
+    """The `(relative path, text)` files of the `samples/sql/` project."""
+    root = Path(__file__).parent / "samples" / "sql"
+    return [
+        (str(p.relative_to(root)), p.read_text()) for p in sorted(root.rglob("*")) if p.is_file()
+    ]
+
+
+@pytest.fixture
+def chunks(project: list[tuple[str, str]]) -> list[Chunk]:
+    """Chunks from every project file, each via the real `extract_file`."""
+    manager = get_manager()
+    out: list[Chunk] = []
+    for path, text in project:
+        lang = manager.detect_language(path) or "sql"
+        out.extend(extract_file(FileEntry(path, "sha1", text.encode()), lang))
+    return out
+
+
+@pytest.fixture
+def edges(project: list[tuple[str, str]], chunks: list[Chunk]) -> list[Edge]:
+    """Import edges inferred across the project's files."""
+    manager = get_manager()
+    repo_files = {path for path, _ in project}
+    return infer_import_edges(chunks, repo_files, build_resolution_map(manager))
+
+
+def test_emits_expected_kinds(chunks: list[Chunk]) -> None:
+    """The sample exercises SQL's class, function, and variable chunks."""
+    kinds = {c.kind for c in chunks}
+    assert {
+        ChunkKind.CLASS,
+        ChunkKind.FUNCTION,
+        ChunkKind.VARIABLE,
+        ChunkKind.COMMENT,
+    } <= kinds
+
+
+def test_parses_cleanly(project: list[tuple[str, str]]) -> None:
+    """Every project file is valid source — no tree-sitter ERROR/MISSING nodes."""
+    manager = get_manager()
+    for path, text in project:
+        grammar = manager.grammar(manager.detect_language(path) or "sql")
+        assert grammar is not None
+        assert not Parser(grammar).parse(text.encode()).root_node.has_error, path
+
+
+def test_extraction_matches_snapshot(chunks: list[Chunk], snapshot_json: SnapshotAssertion) -> None:
+    assert chunks == snapshot_json
+
+
+def test_edges_match_snapshot(
+    chunks: list[Chunk], edges: list[Edge], snapshot_json: SnapshotAssertion
+) -> None:
+    assert render_edges(edges, chunks) == snapshot_json
+
+
+# ── SQL dialects ─────────────────────────────────────────────────────
+# rbtr ships one generic SQL grammar for all `.sql` files. These pin
+# current extraction per dialect; the parse-clean test is a strict-xfail
+# sentinel that fires when the grammar gains full support for a dialect.
+
+
+@pytest.mark.parametrize(
+    "dialect", ["sql_postgres", "sql_mysql", "sql_sqlite", "sql_duckdb", "sql_clickhouse"]
+)
+def test_sql_dialect_extraction_matches_snapshot(
+    dialect: str, snapshot_json: SnapshotAssertion
+) -> None:
+    """Current extraction for each SQL dialect under the generic grammar."""
+    source = (Path(__file__).parent / "samples" / f"{dialect}.sql").read_text()
+    chunks = list(extract_file(FileEntry(f"{dialect}.sql", "sha1", source.encode()), "sql"))
+    assert chunks == snapshot_json
+
+
+@pytest.mark.xfail(
+    reason="generic SQL grammar does not fully parse dialect-specific syntax",
+    strict=True,
+)
+@pytest.mark.parametrize(
+    "dialect", ["sql_postgres", "sql_mysql", "sql_sqlite", "sql_duckdb", "sql_clickhouse"]
+)
+def test_sql_dialect_parses_cleanly(dialect: str) -> None:
+    """Sentinel: flips to XPASS (failing) when a dialect parses cleanly."""
+    source = (Path(__file__).parent / "samples" / f"{dialect}.sql").read_text()
+    grammar = get_manager().grammar("sql")
+    assert grammar is not None
+    assert not Parser(grammar).parse(source.encode()).root_node.has_error

rbtr_lang_sql-2026.9.0.dev1.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: rbtr-lang-sql
+Version: 2026.9.0.dev1
+Summary: rbtr — SQL language plugin
+Keywords: code-search,code-index,tree-sitter,static-analysis,semantic-search,developer-tools,sql
+Author: Alejandro Giacometti
+Author-email: Alejandro Giacometti <alejandro.giacometti@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: SQL
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing :: Indexing
+Classifier: Typing :: Typed
+Requires-Dist: rbtr==2026.9.0.dev1
+Requires-Dist: tree-sitter-sql
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/janrito/rbtr
+Project-URL: Repository, https://github.com/janrito/rbtr
+Project-URL: Documentation, https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-sql#readme
+Project-URL: Issues, https://github.com/janrito/rbtr/issues
+Project-URL: Changelog, https://github.com/janrito/rbtr/releases
+Description-Content-Type: text/markdown
+
+# rbtr-lang-sql
+
+SQL support for [rbtr]. Optional plugin — install with
+`pip install rbtr[sql]`.
+
+[rbtr]: https://github.com/janrito/rbtr/tree/main/packages/rbtr#readme
+
+## What it ingests
+
+One chunk per top-level SQL statement (plus one per CTE). SQL has no
+classes or functions in the object-oriented sense and no native import
+mechanism, so statements map onto rbtr's capture conventions by shape:
+structural definitions become classes, routines and executable
+statements become functions, and standalone named objects become
+variables.
+
+- **Structural definitions** — `CREATE TABLE`, `CREATE VIEW` /
+  `MATERIALIZED VIEW`, `CREATE TYPE ... AS ENUM` / composite types.
+- **Routines & statements** — `CREATE FUNCTION`, `SELECT`, `INSERT`,
+  `UPDATE`, `DELETE`, `WITH ... AS` (CTEs), `ALTER` / `DROP`.
+- **Named objects** — `CREATE INDEX` / `SEQUENCE` / `SCHEMA` / `ROLE` /
+  `TRIGGER`.
+
+`CREATE PROCEDURE` and `PRAGMA` are not extracted — the generic grammar
+has no node for them.
+
+## Chunks produced
+
+`name` is the statement's target object; `scope` is always empty (SQL
+has no nesting). A statement with no nameable target (`SELECT 1`, a
+`UNION`) carries no name.
+
+```sql
+CREATE TABLE users (id INT, name TEXT);   -- class    "users"
+CREATE VIEW active AS SELECT * FROM users; -- class    "active"
+CREATE TYPE mood AS ENUM ('sad','happy');  -- class    "mood"
+CREATE FUNCTION add(a INT) ...             -- function "add"
+SELECT id, name FROM users;                -- function "users"
+INSERT INTO logs (msg) VALUES ('hi');      -- function "logs"
+WITH ranked AS (...) SELECT ...            -- function "ranked" (per CTE)
+CREATE INDEX idx_name ON users (name);     -- variable "idx_name"
+CREATE SEQUENCE order_id START 1;          -- variable "order_id"
+```
+
+## Embedded / injected chunks
+
+None. SQL does not embed other languages.
+
+## Grammar & dependencies
+
+Uses the `tree-sitter-sql` grammar (one generic grammar for all
+dialects). No dependency on other language plugins.

rbtr_lang_sql-2026.9.0.dev1.dist-info/RECORD

@@ -0,0 +1,26 @@
+rbtr_lang_sql/__init__.py,sha256=lk7BbykaSTxBqCgPjOZN4evgeGLZJPX8uPtsrCduXfs,35
+rbtr_lang_sql/plugin.py,sha256=0_TYkY2B5aCc_Yljq1xLL5fVvWCj2SnyoeAf4WGZmWU,2179
+rbtr_lang_sql/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rbtr_lang_sql/sql.scm,sha256=JsdNrr8ypnfHD4BEA1rkNcyYnmUMpBnbof3gkDtUd-w,3154
+rbtr_lang_sql/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rbtr_lang_sql/tests/__snapshots__/test_samples/test_edges_match_snapshot.json,sha256=N1F-Xz3GaBn2H1p7uKzhkhKCQV8QVR0t76XD6wmFtXA,3
+rbtr_lang_sql/tests/__snapshots__/test_samples/test_extraction_matches_snapshot.json,sha256=VKmqnSzsxCFz8hX4Bji5iMGa0LmrJoD1Ywyek4rbSUY,6341
+rbtr_lang_sql/tests/__snapshots__/test_samples/test_sql_dialect_extraction_matches_snapshot[sql_clickhouse].json,sha256=LEsLWNot58JZbTUqhraWm25GBU7IE19duZ3bB5deBL4,1569
+rbtr_lang_sql/tests/__snapshots__/test_samples/test_sql_dialect_extraction_matches_snapshot[sql_duckdb].json,sha256=KHoek1UegfNStjhuYmpRg041onimWVf_Zz-r-nIwnjQ,1810
+rbtr_lang_sql/tests/__snapshots__/test_samples/test_sql_dialect_extraction_matches_snapshot[sql_mysql].json,sha256=vddNvRNwdgAdalXU5ojdWEgW2f5Wb5rXAjWoJnujvTU,1551
+rbtr_lang_sql/tests/__snapshots__/test_samples/test_sql_dialect_extraction_matches_snapshot[sql_postgres].json,sha256=CS3RXHJNMBY-udPLiEphoPABhDIHNQ50NFflsynW-Zk,2775
+rbtr_lang_sql/tests/__snapshots__/test_samples/test_sql_dialect_extraction_matches_snapshot[sql_sqlite].json,sha256=ywxE3JJUwKlSJVDPcLJppVwM2vTQzXt7kL3lbVNum9k,1851
+rbtr_lang_sql/tests/cases_extraction.py,sha256=hEbvK8JkOVumPyiOa8md-XpVETe-bXkZFOPmyzV5oLs,8729
+rbtr_lang_sql/tests/samples/sql/sql.sql,sha256=JdYD1xdfnKiR4phd4oXQeWLv55tTRy-lS6EYIOngkEc,1088
+rbtr_lang_sql/tests/samples/sql_clickhouse.sql,sha256=pXE4bD0rWM9i8ACXiF_QxOCS0YGm9gBinlu-NWOBy1Y,454
+rbtr_lang_sql/tests/samples/sql_duckdb.sql,sha256=TLNCUdLndjwcMbK8HXLmAOV67fOFdkRSaeskcGk2yLM,351
+rbtr_lang_sql/tests/samples/sql_mysql.sql,sha256=3QFvmvkdc-VoRkRL25_6MTcCjI7js9Z4uzvasdXXass,420
+rbtr_lang_sql/tests/samples/sql_postgres.sql,sha256=beefCKnUj6pU9GEL5jaW4rEtRWbhtDyrDrWhO-6KFl4,495
+rbtr_lang_sql/tests/samples/sql_sqlite.sql,sha256=1Zbqd8uF461e9VAmoWTTEu23bj_zN68qm4GAfZzNm8M,353
+rbtr_lang_sql/tests/test_extraction.py,sha256=ZCSd8Afy3uiz39m8vfJ1f3N2oY1OTcZJa26AomaWTuI,3323
+rbtr_lang_sql/tests/test_samples.py,sha256=JEjhm0MdZmSsTZqYQKxWojfVcx-8GgDVzweXaY0ADAU,4342
+rbtr_lang_sql-2026.9.0.dev1.dist-info/licenses/LICENSE,sha256=3LvNTMhogXUXkHsDvTWaXdtGd9C-uuoIVD1ey8w9ITs,1077
+rbtr_lang_sql-2026.9.0.dev1.dist-info/WHEEL,sha256=-i9oRNYVXXZJUIYl5zclLIg6onEb0NLibTX34uln84w,81
+rbtr_lang_sql-2026.9.0.dev1.dist-info/entry_points.txt,sha256=NRu3FcuWbK-k-HpN9LBJmcK5YgElqiMD2zYXaVWMFnU,49
+rbtr_lang_sql-2026.9.0.dev1.dist-info/METADATA,sha256=3DbFQmF4nN60K-dEy2PTDx0uMlxPqz-Drouey7dU7PQ,3165
+rbtr_lang_sql-2026.9.0.dev1.dist-info/RECORD,,

rbtr_lang_sql-2026.9.0.dev1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.13
+Root-Is-Purelib: true
+Tag: py3-none-any

rbtr_lang_sql-2026.9.0.dev1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[rbtr.languages]
+sql = rbtr_lang_sql.plugin:sql
+

rbtr_lang_sql-2026.9.0.dev1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alejandro Giacometti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.