sql-error-categorizer 0.1.9__tar.gz → 0.1.11__tar.gz

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/Makefile

@@ -34,7 +34,7 @@ uninstall: $(VENV)
 	$(VENV_BIN)/python -m pip uninstall -y $(NAME)
 
 documentation:
-	make html -C docs/
+	make html SPHINXBUILD="../$(VENV_BIN)/sphinx-build" -C docs/
 
 test: install
 	$(VENV_BIN)/python -m pytest

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql_error_categorizer
-Version: 0.1.9
+Version: 0.1.11
 Summary: This project analyses SQL statements and labels possible errors or complications.
 Project-URL: Repository, https://github.com/DavidePonzini/sql_error_categorizer
 Project-URL: Documentation, https://sql-error-categorizer.readthedocs.io/en/latest/index.html

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/docs/conf.py

@@ -29,7 +29,9 @@ exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
 
 html_theme = 'alabaster'
-html_static_path = ['_static']
+html_static_path = [
+    # '_static',
+]
 
 
 # -- Autoapi -----------------------------------------------------------------

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sql_error_categorizer"
-version = "0.1.9"
+version = "0.1.11"
 authors = [
   { name="Davide Ponzini", email="davide.ponzini95@gmail.com" },
 ]

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/__init__.py

@@ -5,7 +5,7 @@ from .detectors import BaseDetector as _BaseDetector, Detector as _Detector
 
 # Public API
 from .sql_errors import SqlErrors
-from .catalog import Catalog, build_catalog, load_catalog, build_catalog_from_postgres
+from .catalog import Catalog, build_catalog, load_catalog, build_catalog_from_postgres, build_catalog_from_sql
 from .detectors import SyntaxErrorDetector, SemanticErrorDetector, LogicalErrorDetector, ComplicationDetector, DetectedError
 
 def get_errors(query_str: str,

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/catalog/__init__.py

@@ -6,7 +6,7 @@ from .column import Column
 from .table import Table
 from .schema import Schema
 from .catalog import Catalog
-from .builder import CatalogColumnInfo, CatalogUniqueConstraintInfo, build_catalog, build_catalog_from_postgres, load_catalog
+from .builder import CatalogColumnInfo, CatalogUniqueConstraintInfo, build_catalog, build_catalog_from_postgres, load_catalog, build_catalog_from_sql
 
 
 

sql_error_categorizer-0.1.11/src/sql_error_categorizer/catalog/builder/__init__.py

@@ -0,0 +1,8 @@
+from ..catalog import Catalog
+from .postgres import build_catalog, build_catalog_from_postgres, CatalogColumnInfo, CatalogUniqueConstraintInfo
+from .sql import build_catalog_from_sql
+
+def load_catalog(path: str) -> Catalog:
+    '''Loads a catalog from a JSON file.'''
+    return Catalog.load_json(path)
+

sql_error_categorizer-0.1.9/src/sql_error_categorizer/catalog/builder/__init__.py → sql_error_categorizer-0.1.11/src/sql_error_categorizer/catalog/builder/postgres.py

@@ -1,10 +1,11 @@
-from dataclasses import dataclass
-from . import queries
 from ..catalog import Catalog
 from ..constraint import ConstraintType
+
 import psycopg2
 import time
+from dataclasses import dataclass
 
+# region Data Classes
 @dataclass(frozen=True)
 class CatalogColumnInfo:
     '''Holds information about a database column.'''
@@ -48,7 +49,9 @@ class CatalogUniqueConstraintInfo:
             'constraint_type': self.constraint_type,
             'columns': self.columns,
         }
-
+# endregion
+    
+# region Catalog Builder
 def build_catalog(columns_info: list[CatalogColumnInfo], unique_constraints_info: list[CatalogUniqueConstraintInfo]) -> Catalog:
     '''Builds a catalog from the provided column and unique constraint information.'''
     result = Catalog()
@@ -75,6 +78,7 @@ def build_catalog(columns_info: list[CatalogColumnInfo], unique_constraints_info
 
     return result
 
+
 def build_catalog_from_postgres(sql_string: str, *, hostname: str, port: int, user: str, password: str, schema: str | None = None, create_temp_schema: bool = False) -> Catalog:
     '''Builds a catalog by executing the provided SQL string in a temporary PostgreSQL database.'''
     if sql_string.strip() == '':
@@ -98,7 +102,7 @@ def build_catalog_from_postgres(sql_string: str, *, hostname: str, port: int, us
     cur.execute(sql_string)
 
     # Fetch the catalog information
-    cur.execute(queries.COLUMNS(schema_name))
+    cur.execute(COLUMNS(schema_name))
     columns_info = cur.fetchall()
 
     columns_data = [
@@ -118,7 +122,7 @@ def build_catalog_from_postgres(sql_string: str, *, hostname: str, port: int, us
     ]
 
     # Fetch unique constraints (including primary keys)
-    cur.execute(queries.UNIQUE_COLUMNS(schema_name))
+    cur.execute(UNIQUE_COLUMNS(schema_name))
     unique_constraints_info = cur.fetchall()
 
     unique_constraints_data = [
@@ -137,7 +141,67 @@ def build_catalog_from_postgres(sql_string: str, *, hostname: str, port: int, us
     conn.rollback()     # no need to save anything
 
     return build_catalog(columns_data, unique_constraints_data)
-
-def load_catalog(path: str) -> Catalog:
-    '''Loads a catalog from a JSON file.'''
-    return Catalog.load_json(path)
+# endregion
+
+# region SQL Queries
+def UNIQUE_COLUMNS(schema_name: str = '%') -> str:
+    return f'''
+    SELECT
+        kcu.table_schema AS schema_name,
+        kcu.table_name,
+        tc.constraint_type,
+        array_agg(kcu.column_name ORDER BY kcu.ordinal_position) AS columns
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.key_column_usage kcu
+    ON tc.constraint_name = kcu.constraint_name
+    AND tc.constraint_schema = kcu.constraint_schema
+    WHERE tc.constraint_type IN ('UNIQUE', 'PRIMARY KEY')
+    AND kcu.table_schema LIKE '{schema_name}'
+    GROUP BY
+        kcu.table_schema,
+        kcu.table_name,
+        kcu.constraint_name,
+        tc.constraint_type;
+'''
+
+def COLUMNS(schema_name: str = '%') -> str:
+    return f'''
+    SELECT
+        cols.table_schema AS schema_name,
+        cols.table_name,
+        cols.column_name,
+        cols.data_type AS column_type,
+        cols.numeric_precision,
+        cols.numeric_scale,
+        (cols.is_nullable = 'YES') AS is_nullable,
+        fk.foreign_table_schema AS foreign_key_schema,
+        fk.foreign_table_name AS foreign_key_table,
+        fk.foreign_column_name AS foreign_key_column
+    FROM information_schema.columns AS cols
+
+    -- Foreign Key
+    LEFT JOIN (
+        SELECT
+            kcu.table_schema,
+            kcu.table_name,
+            kcu.column_name,
+            ccu.table_schema AS foreign_table_schema,
+            ccu.table_name   AS foreign_table_name,
+            ccu.column_name  AS foreign_column_name
+        FROM information_schema.table_constraints AS tc
+            JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.constraint_schema = kcu.constraint_schema
+            AND tc.table_schema = kcu.table_schema
+            AND tc.table_name = kcu.table_name
+            JOIN information_schema.constraint_column_usage AS ccu
+            ON tc.constraint_name = ccu.constraint_name
+            AND tc.constraint_schema = ccu.constraint_schema
+        WHERE tc.constraint_type = 'FOREIGN KEY'
+    ) fk ON fk.table_schema = cols.table_schema
+        AND fk.table_name = cols.table_name
+        AND fk.column_name = cols.column_name
+
+    WHERE cols.table_schema LIKE '{schema_name}'
+'''
+# endregion

sql_error_categorizer-0.1.11/src/sql_error_categorizer/catalog/builder/sql.py

@@ -0,0 +1,219 @@
+import sqlglot
+from sqlglot import exp
+from ..catalog import Catalog
+from ..constraint import ConstraintType
+
+def _get_identifier_name(identifier_exp: exp.Identifier) -> str:
+    '''Returns the normalized name from an Identifier expression.'''
+
+    if identifier_exp.quoted:
+        return identifier_exp.name
+    return identifier_exp.name.lower()
+
+def _get_table_name(table_exp: exp.Table) -> str:
+    '''Returns the normalized table name from a Table expression.'''
+
+    if isinstance(table_exp.this, exp.Identifier):
+        return _get_identifier_name(table_exp.this)
+    return str(table_exp.this).lower()
+
+def _get_schema_name(table_exp: exp.Table, default_schema: str) -> str:
+    '''Returns the normalized schema name from a Table expression, or the default schema if not specified.'''
+
+    if table_exp.db:
+        if isinstance(table_exp.db, exp.Identifier):
+            return _get_identifier_name(table_exp.db)
+        return str(table_exp.db).lower()
+    return default_schema
+
+def _get_column_name(column_exp: exp.ColumnDef) -> str:
+    '''Returns the normalized column name from a ColumnDef expression.'''
+
+    if isinstance(column_exp.this, exp.Identifier):
+        return _get_identifier_name(column_exp.this)
+    return str(column_exp.this).lower()
+
+def _extract_datatype(column_exp: exp.ColumnDef) -> tuple[str, int | None, int | None]:
+    '''Extracts datatype information from a ColumnDef expression.'''
+
+    datatype_exp = column_exp.kind
+    assert isinstance(datatype_exp, exp.DataType), 'Expected DataType expression in ColumnDef'
+
+    datatype = datatype_exp.this.value
+
+    numeric_precision = None
+    numeric_scale = None
+
+    if datatype_exp.expressions:
+        if datatype in {'DECIMAL', 'NUMERIC', 'NUMBER', 'FLOAT'}:
+            if len(datatype_exp.expressions) >= 1:
+                precision_exp = datatype_exp.expressions[0]
+                if isinstance(precision_exp, exp.Literal) and precision_exp.is_int:
+                    numeric_precision = int(precision_exp.name)
+            if len(datatype_exp.expressions) == 2:
+                scale_exp = datatype_exp.expressions[1]
+                if isinstance(scale_exp, exp.Literal) and scale_exp.is_int:
+                    numeric_scale = int(scale_exp.name)
+
+    return datatype, numeric_precision, numeric_scale
+
+def build_catalog_from_sql(sql_string: str, search_path: str = 'public') -> Catalog:
+    '''Builds a catalog from the provided SQL string without executing it in a database.'''
+
+    statements = sqlglot.parse(sql_string)
+
+    # Filter to only CREATE TABLE statements
+    statements = [stmt for stmt in statements if isinstance(stmt, exp.Create) and stmt.kind and stmt.kind.upper() == 'TABLE']
+
+    catalog = Catalog()
+
+    for statement in statements:
+        table_exp = statement.find(exp.Table)
+
+        assert table_exp is not None, 'Expected Table expression in CREATE TABLE statement'
+
+        # "CREATE TABLE <schema_name>.<table_name>" handling
+        table_name = _get_table_name(table_exp)
+        schema_name = _get_schema_name(table_exp, search_path)
+
+        # Extract other relevant information
+        column_exps: list[exp.ColumnDef] = list(statement.find_all(exp.ColumnDef))
+        '''Column definitions'''
+
+        pk_exp: exp.PrimaryKey | None = statement.find(exp.PrimaryKey)
+        '''PRIMARY KEY defined at table level, e.g., PRIMARY KEY (col1, col2)'''
+
+        fk_exps: list[exp.ForeignKey] = list(statement.find_all(exp.ForeignKey))
+        '''FOREIGN KEY defined at table level, e.g., FOREIGN KEY (col1) REFERENCES other_table(other_col)'''
+
+        fks: dict[str, tuple[str, str, str]] = {}
+        '''Mapping of foreign key column names to (schema, table, column) tuples'''
+        # NOTE: this needs to be filled in before adding columns to the catalog
+        
+        unique_exps: list[exp.UniqueColumnConstraint] = list(statement.find_all(exp.UniqueColumnConstraint))
+        '''UNIQUE constraints defined at table level, e.g., UNIQUE (col1, col2)'''
+
+        pk_col_names: set[str] = set()
+        '''Set to keep track of primary key column names'''
+
+        unique_col_names: list[set[str]] = []
+        '''List to keep track of unique constraint column name sets'''
+
+        # Process table-level Foreign Key constraints
+        for fk_exp in fk_exps:
+            fk_id_exps = fk_exp.expressions
+            fk_column_names = [_get_identifier_name(col_exp) for col_exp in fk_id_exps]
+
+            ref_exp = fk_exp.find(exp.Reference)
+            assert ref_exp is not None, 'Expected Reference expression in Foreign Key definition'
+
+            ref_schema_exp = ref_exp.this
+            assert isinstance(ref_schema_exp, exp.Schema), 'Expected Schema expression in Foreign Key reference'
+
+            ref_table_exp = ref_schema_exp.this
+            assert isinstance(ref_table_exp, exp.Table), 'Expected Table expression in Foreign Key reference'
+
+            ref_schema_name = _get_schema_name(ref_table_exp, search_path)
+            ref_table_name = _get_table_name(ref_table_exp)
+
+            ref_id_exps = ref_schema_exp.expressions
+            ref_column_names = [_get_identifier_name(col_exp) for col_exp in ref_id_exps]
+
+            # e.g. "FOREIGN KEY (tenant_id, order_id) REFERENCES orders (tenant_id, order_id)"
+            for fk_col_name, ref_col_name in zip(fk_column_names, ref_column_names):
+                fks[fk_col_name] = (ref_schema_name, ref_table_name, ref_col_name)
+
+        # Process columns
+        for column_exp in column_exps:
+            column_name = _get_column_name(column_exp)
+
+            # Primary Key handling            
+            is_pk = any(isinstance(c.kind, exp.PrimaryKeyColumnConstraint) for c in column_exp.constraints)
+            if is_pk:
+                pk_col_names.add(column_name)
+
+            # Unique handling
+            is_unique = any(isinstance(c.kind, exp.UniqueColumnConstraint) for c in column_exp.constraints)
+            if is_unique:
+                unique_col_names.append({column_name})
+
+            # Not Null handling
+            is_not_null = any(isinstance(c.kind, exp.NotNullColumnConstraint) for c in column_exp.constraints)
+
+            # Foreign Key handling
+            fk_constraint = next((c for c in column_exp.constraints if isinstance(c.kind, exp.Reference)), None)
+
+            if fk_constraint:
+                fk_reference = fk_constraint.kind
+                assert isinstance(fk_reference, exp.Reference), 'Expected Reference expression in Foreign Key constraint'
+
+                fk_schema_exp = fk_reference.this
+                assert isinstance(fk_schema_exp, exp.Schema), 'Expected Schema expression in Foreign Key constraint'
+                
+                fk_table_exp = fk_schema_exp.this
+                assert isinstance(fk_table_exp, exp.Table), 'Expected Table expression in Foreign Key constraint'
+
+                fk_schema_name = _get_schema_name(fk_table_exp, search_path)
+                fk_table_name = _get_table_name(fk_table_exp)
+
+                fk_column_exp = fk_schema_exp.expressions[0]
+                assert isinstance(fk_column_exp, exp.Identifier), 'Expected Identifier expression in Foreign Key column'
+                fk_column_name = _get_identifier_name(fk_column_exp)
+            elif column_name in fks:
+                fk_schema_name, fk_table_name, fk_column_name = fks[column_name]
+            else:
+                fk_schema_name = None
+                fk_table_name = None
+                fk_column_name = None
+
+            # Datatype handling
+            column_type, numeric_precision, numeric_scale = _extract_datatype(column_exp)
+
+            # Add column to catalog
+            catalog[schema_name][table_name].add_column(
+                name=column_name,
+                column_type=column_type,
+                real_name=column_name,
+                numeric_precision=numeric_precision,
+                numeric_scale=numeric_scale,
+                is_nullable=not is_not_null,
+                fk_schema=fk_schema_name,
+                fk_table=fk_table_name,
+                fk_column=fk_column_name)
+        
+        # Process table-level Primary Key constraint
+        if pk_exp:
+            for ordered_exp in pk_exp.expressions:
+                col_exp = ordered_exp.find(exp.Column)
+                assert col_exp is not None, 'Expected Column expression in Primary Key definition'
+                col_name = _get_column_name(col_exp)
+                pk_col_names.add(col_name)
+
+        # Process table-level Unique constraints
+        for unique_exp in unique_exps:
+            unique_schema_exp = unique_exp.this
+            assert isinstance(unique_schema_exp, exp.Schema), 'Expected Schema expression in Unique constraint'
+
+            unique_column_names = set()
+            for col_id_exp in unique_exp.expressions:
+                col_name = _get_identifier_name(col_id_exp)
+                unique_column_names.add(col_name)
+            unique_col_names.append(unique_column_names)
+
+        # Add Primary Key constraint to catalog
+        # NOTE: needs to be perfomed after all columns have been added, since PKs can be defined at both column and table level
+        assert len(pk_col_names) > 0, 'Primary Key columns should have been identified'
+        catalog[schema_name][table_name].add_unique_constraint(
+            columns=pk_col_names,
+            constraint_type=ConstraintType.PRIMARY_KEY
+        )
+
+        # Add Unique constraints to catalog
+        # NOTE: needs to be perfomed after all columns have been added, since Unique constraints can be defined at both column and table level
+        for unique_col_name_set in unique_col_names:
+            catalog[schema_name][table_name].add_unique_constraint(
+                columns=unique_col_name_set,
+                constraint_type=ConstraintType.UNIQUE
+            )
+
+    return catalog

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/detectors/complications.py

@@ -7,7 +7,7 @@ import sqlparse.keywords
 from typing import Callable
 from sqlglot import exp
 
-from sql_error_categorizer.catalog import ConstraintType, ConstraintColumn, Constraint
+from ..catalog import ConstraintType, ConstraintColumn, Constraint
 
 from .base import BaseDetector, DetectedError
 from ..query import Query

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/detectors/logical.py

@@ -711,14 +711,14 @@ class LogicalErrorDetector(BaseDetector):
     
     def _selects_star(self, ast: dict) -> bool:
         '''
-        Checks if a 'SELECT *' is used in the query by looking for a 'Star'
+        Checks if a `SELECT *` is used in the query by looking for a 'Star'
         node in the AST's expression list.
 
         Args:
             ast: The Abstract Syntax Tree of the query.
 
         Returns:
-            True if 'SELECT *' is found, otherwise False.
+            True if `SELECT *` is found, otherwise False.
         '''
         if not ast:
             return False

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/detectors/syntax.py

@@ -8,7 +8,7 @@ from sqlglot import exp
 from typing import Callable
 from copy import deepcopy
 
-from sql_error_categorizer.query.set_operations.set_operation import SetOperation
+from ..query.set_operations.set_operation import SetOperation
 from ..query.typechecking import get_type, collect_errors
 
 from .base import BaseDetector, DetectedError

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/query/set_operations/__init__.py

@@ -78,11 +78,9 @@ def create_set_operation_tree(sql: str, catalog: Catalog = Catalog(), search_pat
 def parse_op_token(tok: sqlparse.sql.Token) -> tuple[str, bool | None] | None:
     '''
     Parse "UNION", "INTERSECT", "EXCEPT" with optional inline ALL/DISTINCT.
+
     Returns:
-        tuple: `(op, all_flag)` where all_flag is:
-        - True  if ALL inline (e.g., "UNION ALL")
-        - False if DISTINCT inline (e.g., "EXCEPT DISTINCT")
-        - None  if no modifier inline (so caller may look right).
+        tuple: `(op, all_flag)` where all_flag is: True  if ALL inline (e.g., "UNION ALL"); False if DISTINCT inline (e.g., "EXCEPT DISTINCT"); None  if no modifier inline (so caller may look right).
     '''
     if tok.ttype is not Keyword:
         return None
@@ -106,11 +104,9 @@ def split_on(tokens: list[sqlparse.sql.Token], idx: int, all_in_token: bool | No
     '''
     Splits around the operator at idx. If the modifier wasn't inline,
     consume a single immediate ALL/DISTINCT to the right.
+    
     Returns:
-        tuple: A tuple containing:
-            - left_tokens (list[sqlparse.sql.Token]): Tokens to the left of the operator.
-            - right_tokens (list[sqlparse.sql.Token]): Tokens to the right of the operator
-            - all_flag (bool | None): True if ALL, False if DISTINCT, None if unspecified.
+        tuple: A tuple containing: left_tokens (list[sqlparse.sql.Token]): Tokens to the left of the operator; right_tokens (list[sqlparse.sql.Token]): Tokens to the right of the operator; all_flag (bool | None): True if ALL, False if DISTINCT, None if unspecified.
     '''
     left_tokens = tokens[:idx]
     right_tokens = tokens[idx + 1:]

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/query/set_operations/binary_set_operation.py

@@ -3,6 +3,7 @@ from ...catalog import Table, Constraint, ConstraintType, ConstraintColumn
 
 from abc import ABC
 from copy import deepcopy
+import sqlglot
 from sqlglot import exp
 
 from typing import TYPE_CHECKING
@@ -44,6 +45,18 @@ class BinarySetOperation(SetOperation, ABC):
 
         return result
 
+    @property
+    def trailing_ast(self) -> exp.Expression | None:
+        '''Parses and returns the AST of the trailing SQL clauses (e.g., ORDER BY, LIMIT) if present, with a fake `SELECT 1` prefix.'''
+        if self.trailing_sql is None:
+            return None
+        if self._trailing_ast is None:
+            # Parse trailing SQL with a fake SELECT to get valid AST
+            fake_sql = f'SELECT 1 {self.trailing_sql}'
+            parsed = sqlglot.parse_one(fake_sql)
+            self._trailing_ast = parsed
+        return self._trailing_ast
+
     @property
     def output(self) -> Table:
         # Assume the output schema is the same as the left input

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/query/set_operations/set_operation.py

@@ -40,18 +40,6 @@ class SetOperation(ABC):
     @abstractmethod
     def print_tree(self, pre: str = '') -> None:
         pass
-
-    @property
-    def trailing_ast(self) -> exp.Expression | None:
-        '''Parses and returns the AST of the trailing SQL clauses (e.g., ORDER BY, LIMIT) if present, with a fake `SELECT 1` prefix.'''
-        if self.trailing_sql is None:
-            return None
-        if self._trailing_ast is None:
-            # Parse trailing SQL with a fake SELECT to get valid AST
-            fake_sql = f'SELECT 1 {self.trailing_sql}'
-            parsed = sqlglot.parse_one(fake_sql)
-            self._trailing_ast = parsed
-        return self._trailing_ast
     
     @property
     @abstractmethod

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/query/typechecking/binary_ops.py

@@ -1,7 +1,8 @@
 from .base import get_type
 from ...catalog import Catalog
 from sqlglot import exp
-from .types import ResultType, AtomicType, DataType
+from .types import ResultType, AtomicType
+from sqlglot.expressions import DataType
 from .util import is_number, to_number, to_date, error_message
 
 @get_type.register

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/query/typechecking/functions.py

@@ -1,7 +1,8 @@
 from .base import get_type
 from ...catalog import Catalog
 from sqlglot import exp
-from .types import ResultType, AtomicType, DataType
+from .types import ResultType, AtomicType
+from sqlglot.expressions import DataType
 from .util import is_number, error_message
 
 @get_type.register

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/query/typechecking/predicates.py

@@ -1,7 +1,8 @@
 from .base import get_type
 from ...catalog import Catalog
 from sqlglot import exp
-from .types import ResultType, AtomicType, DataType
+from .types import ResultType, AtomicType
+from sqlglot.expressions import DataType
 from .util import is_string, to_number, to_date, error_message
 
 @get_type.register

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/query/typechecking/primitives.py

@@ -1,7 +1,8 @@
 from .base import get_type
 from ...catalog import Catalog
 from sqlglot import exp
-from .types import ResultType, AtomicType, DataType, TupleType
+from .types import ResultType, AtomicType, TupleType
+from sqlglot.expressions import DataType
 from .util import is_number, is_date, to_number, to_date, error_message
 from ...util.ast.column import get_real_name, get_schema
 

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/query/typechecking/unary_ops.py

@@ -1,7 +1,8 @@
 from .base import get_type
 from ...catalog import Catalog
 from sqlglot import exp
-from .types import ResultType, AtomicType, DataType
+from .types import ResultType, AtomicType
+from sqlglot.expressions import DataType
 from .util import is_number, error_message
 
 @get_type.register

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/query/typechecking/util.py

@@ -1,4 +1,5 @@
-from .types import ResultType, DataType
+from .types import ResultType
+from sqlglot.expressions import DataType
 from dateutil.parser import parse
 from sqlglot import exp
 

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/sql_errors.py

@@ -1,7 +1,7 @@
-from enum import Enum
+from enum import IntEnum
 
 
-class SqlErrors(Enum):
+class SqlErrors(IntEnum):
     '''Enumeration of SQL error types with unique identifiers.'''
     SYN_1_OMITTING_CORRELATION_NAMES                                    = 1
     SYN_2_AMBIGUOUS_COLUMN                                              = 2

{sql_error_categorizer-0.1.9 → sql_error_categorizer-0.1.11}/src/sql_error_categorizer/util/ast/__init__.py

@@ -1,9 +1,6 @@
 '''Utility functions for processing SQL ASTs made with sqlglot.'''
 
-from .column import *
-from .function import *
-from .subquery import *
-from .table import *
+from . import column, function, subquery, table
 
 import sqlglot.optimizer.normalize
 from sqlglot import exp

sql_error_categorizer-0.1.9/src/sql_error_categorizer/catalog/builder/queries.py

@@ -1,60 +0,0 @@
-def UNIQUE_COLUMNS(schema_name: str = '%') -> str:
-    return f'''
-    SELECT
-        kcu.table_schema AS schema_name,
-        kcu.table_name,
-        tc.constraint_type,
-        array_agg(kcu.column_name ORDER BY kcu.ordinal_position) AS columns
-    FROM information_schema.table_constraints tc
-    JOIN information_schema.key_column_usage kcu
-    ON tc.constraint_name = kcu.constraint_name
-    AND tc.constraint_schema = kcu.constraint_schema
-    WHERE tc.constraint_type IN ('UNIQUE', 'PRIMARY KEY')
-    AND kcu.table_schema LIKE '{schema_name}'
-    GROUP BY
-        kcu.table_schema,
-        kcu.table_name,
-        kcu.constraint_name,
-        tc.constraint_type;
-'''
-
-def COLUMNS(schema_name: str = '%') -> str:
-    return f'''
-    SELECT
-        cols.table_schema AS schema_name,
-        cols.table_name,
-        cols.column_name,
-        cols.data_type AS column_type,
-        cols.numeric_precision,
-        cols.numeric_scale,
-        (cols.is_nullable = 'YES') AS is_nullable,
-        fk.foreign_table_schema AS foreign_key_schema,
-        fk.foreign_table_name AS foreign_key_table,
-        fk.foreign_column_name AS foreign_key_column
-    FROM information_schema.columns AS cols
-
-    -- Foreign Key
-    LEFT JOIN (
-        SELECT
-            kcu.table_schema,
-            kcu.table_name,
-            kcu.column_name,
-            ccu.table_schema AS foreign_table_schema,
-            ccu.table_name   AS foreign_table_name,
-            ccu.column_name  AS foreign_column_name
-        FROM information_schema.table_constraints AS tc
-            JOIN information_schema.key_column_usage AS kcu
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.constraint_schema = kcu.constraint_schema
-            AND tc.table_schema = kcu.table_schema
-            AND tc.table_name = kcu.table_name
-            JOIN information_schema.constraint_column_usage AS ccu
-            ON tc.constraint_name = ccu.constraint_name
-            AND tc.constraint_schema = ccu.constraint_schema
-        WHERE tc.constraint_type = 'FOREIGN KEY'
-    ) fk ON fk.table_schema = cols.table_schema
-        AND fk.table_name = cols.table_name
-        AND fk.column_name = cols.column_name
-
-    WHERE cols.table_schema LIKE '{schema_name}'
-'''