flyql 0.0.31__py3-none-any.whl

e2e/conftest.py

@@ -0,0 +1,48 @@
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+
+def pytest_sessionfinish(session: Any, exitstatus: int) -> None:
+    """Write JSON report if E2E_REPORT_JSON is set."""
+    report_path = os.environ.get("E2E_REPORT_JSON", "")
+    if not report_path:
+        return
+
+    all_results: list[dict[str, Any]] = []
+
+    try:
+        from test_clickhouse_e2e import _results as ch_results
+
+        all_results.extend(ch_results)
+    except ImportError:
+        pass
+
+    try:
+        from test_starrocks_e2e import _results as sr_results
+
+        all_results.extend(sr_results)
+    except ImportError:
+        pass
+
+    try:
+        from test_postgresql_e2e import _results as pg_results
+
+        all_results.extend(pg_results)
+    except ImportError:
+        pass
+
+    try:
+        from test_matcher_e2e import _results as matcher_results
+
+        all_results.extend(matcher_results)
+    except ImportError:
+        pass
+
+    if all_results:
+        report = {"language": "python", "results": all_results}
+        try:
+            Path(report_path).write_text(json.dumps(report, indent=2))
+        except OSError as e:
+            print(f"warn: could not write e2e report {report_path}: {e}")

e2e/test_clickhouse_e2e.py

@@ -0,0 +1,347 @@
+"""ClickHouse E2E tests for Python FlyQL generator.
+
+Connects to a real ClickHouse instance, generates SQL from FlyQL queries
+using the Python generator, executes the SQL, and validates returned IDs
+match expected results from the shared test cases.
+
+Outputs a JSON report compatible with the e2e runner when E2E_REPORT_JSON is set.
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+# Add python/ to path so we can import flyql
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from flyql.core.parser import parse  # noqa: E402
+from flyql.generators.clickhouse.column import Column  # noqa: E402
+from flyql.generators.clickhouse.generator import (
+    to_sql_where,
+    to_sql_select,
+)  # noqa: E402
+
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+TEST_DATA_DIR = REPO_ROOT / "tests-data" / "e2e"
+
+CH_HOST = os.environ.get("CLICKHOUSE_HOST", "localhost")
+CH_HTTP_PORT = os.environ.get("CLICKHOUSE_HTTP_PORT", "18123")
+CH_USER = os.environ.get("CLICKHOUSE_USER", "flyql")
+CH_PASS = os.environ.get("CLICKHOUSE_PASSWORD", "flyql")
+
+_results: list[dict[str, Any]] = []
+
+
+def ch_query(sql: str) -> list[dict[str, Any]]:
+    """Execute a query against ClickHouse via HTTP interface."""
+    import urllib.request
+    import urllib.parse
+
+    params = urllib.parse.urlencode(
+        {
+            "user": CH_USER,
+            "password": CH_PASS,
+            "default_format": "JSONEachRow",
+        }
+    )
+    url = f"http://{CH_HOST}:{CH_HTTP_PORT}/?{params}"
+
+    req = urllib.request.Request(url, data=sql.encode("utf-8"), method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            text = resp.read().decode("utf-8").strip()
+    except Exception as e:
+        raise RuntimeError(f"ClickHouse error: {e}") from e
+
+    if not text:
+        return []
+    return [json.loads(line) for line in text.split("\n")]
+
+
+def load_json(path: Path) -> Any:
+    return json.loads(path.read_text())
+
+
+def build_columns() -> dict[str, Column]:
+    col_data = load_json(TEST_DATA_DIR / "clickhouse" / "columns.json")
+    columns: dict[str, Column] = {}
+    for key, col in col_data["columns"].items():
+        columns[key] = Column(
+            name=col["name"],
+            jsonstring=col["jsonstring"],
+            _type=col["type"],
+            values=col.get("values"),
+        )
+    return columns
+
+
+def build_join_columns() -> dict[str, Column]:
+    col_data = load_json(TEST_DATA_DIR / "clickhouse" / "join_columns.json")
+    columns: dict[str, Column] = {}
+    for key, col in col_data["columns"].items():
+        c = Column(
+            name=col["name"],
+            jsonstring=col.get("jsonstring", False),
+            _type=col["type"],
+            values=col.get("values"),
+        )
+        if col.get("raw_identifier"):
+            c.with_raw_identifier(col["raw_identifier"])
+        columns[key] = c
+    return columns
+
+
+def load_test_cases() -> list[dict[str, Any]]:
+    data = load_json(TEST_DATA_DIR / "test_cases.json")
+    return [tc for tc in data["tests"] if "clickhouse" in tc["databases"]]
+
+
+def load_join_test_cases() -> list[dict[str, Any]]:
+    data = load_json(TEST_DATA_DIR / "join_test_cases.json")
+    return [tc for tc in data["tests"] if "clickhouse" in tc["databases"]]
+
+
+@pytest.fixture(scope="module")
+def ch_available() -> bool:
+    try:
+        rows = ch_query("SELECT 1 AS ok")
+        return len(rows) > 0 and rows[0]["ok"] == 1
+    except Exception:
+        return False
+
+
+@pytest.fixture(scope="module")
+def columns() -> dict[str, Column]:
+    return build_columns()
+
+
+def ids_match(expected: list[int], got: list[int]) -> bool:
+    return sorted(expected) == sorted(got)
+
+
+@pytest.mark.parametrize(
+    "name,flyql,expected_ids",
+    [(tc["name"], tc["flyql"], tc["expected_ids"]) for tc in load_test_cases()],
+    ids=[tc["name"] for tc in load_test_cases()],
+)
+def test_clickhouse_where(
+    ch_available: bool,
+    columns: dict[str, Column],
+    name: str,
+    flyql: str,
+    expected_ids: list[int],
+) -> None:
+    result: dict[str, Any] = {
+        "kind": "where",
+        "database": "clickhouse",
+        "name": name,
+        "flyql": flyql,
+        "sql": "",
+        "expected_ids": expected_ids,
+        "returned_ids": [],
+        "passed": False,
+        "error": "",
+    }
+
+    if not ch_available:
+        result["error"] = "ClickHouse not available"
+        _results.append(result)
+        pytest.skip("ClickHouse not available")
+        return
+
+    try:
+        parsed = parse(flyql)
+        sql_where = to_sql_where(parsed.current_node, columns)
+        result["sql"] = sql_where
+
+        query = f"SELECT id FROM flyql_e2e_test WHERE {sql_where} ORDER BY id"
+        rows = ch_query(query)
+        returned_ids = [r["id"] for r in rows]
+        result["returned_ids"] = returned_ids
+        result["passed"] = ids_match(expected_ids, returned_ids)
+
+        _results.append(result)
+        assert result["passed"], f"expected {expected_ids}, got {returned_ids}"
+    except Exception as e:
+        result["error"] = str(e)
+        _results.append(result)
+        raise
+
+
+def load_select_test_cases() -> list[dict[str, Any]]:
+    data = load_json(TEST_DATA_DIR / "clickhouse" / "select_test_cases.json")
+    return data["tests"]
+
+
+def load_join_select_test_cases() -> list[dict[str, Any]]:
+    data = load_json(TEST_DATA_DIR / "clickhouse" / "join_select_test_cases.json")
+    return data["tests"]
+
+
+@pytest.mark.parametrize(
+    "name,select_columns,expected_rows",
+    [
+        (tc["name"], tc["select_columns"], tc["expected_rows"])
+        for tc in load_select_test_cases()
+    ],
+    ids=[tc["name"] for tc in load_select_test_cases()],
+)
+def test_clickhouse_select(
+    ch_available: bool,
+    columns: dict[str, Column],
+    name: str,
+    select_columns: str,
+    expected_rows: list[list[str]],
+) -> None:
+    result: dict[str, Any] = {
+        "kind": "select",
+        "database": "clickhouse",
+        "name": name,
+        "select_columns": select_columns,
+        "sql": "",
+        "expected_rows": expected_rows,
+        "returned_rows": [],
+        "passed": False,
+        "error": "",
+    }
+
+    if not ch_available:
+        result["error"] = "ClickHouse not available"
+        _results.append(result)
+        pytest.skip("ClickHouse not available")
+        return
+
+    try:
+        select_result = to_sql_select(select_columns, columns)
+        result["sql"] = select_result.sql
+
+        query = f"SELECT {select_result.sql} FROM flyql_e2e_test ORDER BY id"
+        rows = ch_query(query)
+        returned_rows = [
+            [str(v) if v is not None else "null" for v in row.values()] for row in rows
+        ]
+        result["returned_rows"] = returned_rows
+        result["passed"] = returned_rows == expected_rows
+
+        _results.append(result)
+        assert result["passed"], f"expected {expected_rows}, got {returned_rows}"
+    except Exception as e:
+        result["error"] = str(e)
+        _results.append(result)
+        raise
+
+
+@pytest.fixture(scope="module")
+def join_columns() -> dict[str, Column]:
+    return build_join_columns()
+
+
+@pytest.mark.parametrize(
+    "name,flyql,expected_ids",
+    [(tc["name"], tc["flyql"], tc["expected_ids"]) for tc in load_join_test_cases()],
+    ids=[tc["name"] for tc in load_join_test_cases()],
+)
+def test_clickhouse_join(
+    ch_available: bool,
+    join_columns: dict[str, Column],
+    name: str,
+    flyql: str,
+    expected_ids: list[int],
+) -> None:
+    result: dict[str, Any] = {
+        "kind": "where",
+        "database": "clickhouse",
+        "name": name,
+        "flyql": flyql,
+        "sql": "",
+        "expected_ids": expected_ids,
+        "returned_ids": [],
+        "passed": False,
+        "error": "",
+    }
+
+    if not ch_available:
+        result["error"] = "ClickHouse not available"
+        _results.append(result)
+        pytest.skip("ClickHouse not available")
+        return
+
+    try:
+        parsed = parse(flyql)
+        sql_where = to_sql_where(parsed.current_node, join_columns)
+        result["sql"] = sql_where
+
+        query = f"SELECT t.id FROM flyql_e2e_test t INNER JOIN flyql_e2e_related r ON t.id = r.test_id WHERE {sql_where} ORDER BY t.id"
+        rows = ch_query(query)
+        returned_ids = [r["id"] for r in rows]
+        result["returned_ids"] = returned_ids
+        result["passed"] = ids_match(expected_ids, returned_ids)
+
+        _results.append(result)
+        assert result["passed"], f"expected {expected_ids}, got {returned_ids}"
+    except Exception as e:
+        result["error"] = str(e)
+        _results.append(result)
+        raise
+
+
+@pytest.fixture(scope="module")
+def join_select_columns() -> dict[str, Column]:
+    return build_join_columns()
+
+
+@pytest.mark.parametrize(
+    "name,select_columns,expected_rows",
+    [
+        (tc["name"], tc["select_columns"], tc["expected_rows"])
+        for tc in load_join_select_test_cases()
+    ],
+    ids=[tc["name"] for tc in load_join_select_test_cases()],
+)
+def test_clickhouse_join_select(
+    ch_available: bool,
+    join_select_columns: dict[str, Column],
+    name: str,
+    select_columns: str,
+    expected_rows: list[list[str]],
+) -> None:
+    result: dict[str, Any] = {
+        "kind": "select",
+        "database": "clickhouse",
+        "name": name,
+        "select_columns": select_columns,
+        "sql": "",
+        "expected_rows": expected_rows,
+        "returned_rows": [],
+        "passed": False,
+        "error": "",
+    }
+
+    if not ch_available:
+        result["error"] = "ClickHouse not available"
+        _results.append(result)
+        pytest.skip("ClickHouse not available")
+        return
+
+    try:
+        select_result = to_sql_select(select_columns, join_select_columns)
+        result["sql"] = select_result.sql
+
+        query = f"SELECT {select_result.sql} FROM flyql_e2e_test t INNER JOIN flyql_e2e_related r ON t.id = r.test_id ORDER BY t.id"
+        rows = ch_query(query)
+        returned_rows = [
+            [str(v) if v is not None else "null" for v in row.values()] for row in rows
+        ]
+        result["returned_rows"] = returned_rows
+        result["passed"] = returned_rows == expected_rows
+
+        _results.append(result)
+        assert result["passed"], f"expected {expected_rows}, got {returned_rows}"
+    except Exception as e:
+        result["error"] = str(e)
+        _results.append(result)
+        raise

e2e/test_matcher_e2e.py

@@ -0,0 +1,86 @@
+"""Matcher E2E tests for Python FlyQL — in-memory evaluation parity with database results."""
+
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from flyql.matcher.evaluator import Evaluator  # noqa: E402
+from flyql.matcher.record import Record  # noqa: E402
+from flyql.core.parser import parse  # noqa: E402
+
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+TEST_DATA_DIR = REPO_ROOT / "tests-data" / "e2e"
+
+_results: list[dict[str, Any]] = []
+
+
+def load_json(path: Path) -> Any:
+    return json.loads(path.read_text())
+
+
+ROWS = load_json(TEST_DATA_DIR / "rows.json")["rows"]
+
+
+def load_test_cases() -> list[dict[str, Any]]:
+    data = load_json(TEST_DATA_DIR / "test_cases.json")
+    return [
+        tc
+        for tc in data["tests"]
+        if not any(
+            x in tc["flyql"]
+            for x in [
+                "tags.",
+                "metadata.",
+                "meta_json.",
+                "hello*'",
+                "'*@",
+                "created_at<=",
+            ]
+        )
+    ]
+
+
+def match_row(query: str, data: dict[str, Any]) -> bool:
+    result = parse(query)
+    evaluator = Evaluator()
+    record = Record(data)
+    return evaluator.evaluate(result.current_node, record)
+
+
+def ids_match(expected: list[int], got: list[int]) -> bool:
+    return sorted(expected) == sorted(got)
+
+
+@pytest.mark.parametrize(
+    "name,flyql,expected_ids",
+    [(tc["name"], tc["flyql"], tc["expected_ids"]) for tc in load_test_cases()],
+    ids=[tc["name"] for tc in load_test_cases()],
+)
+def test_matcher_where(name: str, flyql: str, expected_ids: list[int]) -> None:
+    result: dict[str, Any] = {
+        "kind": "where",
+        "database": "matcher",
+        "name": name,
+        "flyql": flyql,
+        "sql": "(in-memory)",
+        "expected_ids": expected_ids,
+        "returned_ids": [],
+        "passed": False,
+        "error": "",
+    }
+
+    try:
+        matched_ids = [row["id"] for row in ROWS if match_row(flyql, row)]
+        result["returned_ids"] = matched_ids
+        result["passed"] = ids_match(expected_ids, matched_ids)
+        _results.append(result)
+        assert result["passed"], f"expected {expected_ids}, got {matched_ids}"
+    except Exception as e:
+        result["error"] = str(e)
+        _results.append(result)
+        raise