sql-error-categorizer 0.1.4__tar.gz → 0.1.6__tar.gz

{sql_error_categorizer-0.1.4 → sql_error_categorizer-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql_error_categorizer
-Version: 0.1.4
+Version: 0.1.6
 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.4 → sql_error_categorizer-0.1.6}/pyproject.toml

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

{sql_error_categorizer-0.1.4 → sql_error_categorizer-0.1.6}/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
+from .catalog import Catalog, build_catalog, load_catalog, build_catalog_from_postgres
 from .detectors import SyntaxErrorDetector, SemanticErrorDetector, LogicalErrorDetector, ComplicationDetector, DetectedError
 
 def get_errors(query_str: str,

{sql_error_categorizer-0.1.4 → sql_error_categorizer-0.1.6}/src/sql_error_categorizer/catalog/builder/__init__.py

@@ -54,12 +54,18 @@ def build_catalog(columns_info: list[CatalogColumnInfo], unique_constraints_info
     result = Catalog()
     
     for column in columns_info:
-        schema_name, table_name, column_name, column_type, numeric_precision, numeric_scale, is_nullable, fk_schema, fk_table, fk_column = column
-
-        result.add_column(schema_name, table_name, column_name,
-                          column_type, numeric_precision, numeric_scale,
-                          is_nullable,
-                          fk_schema, fk_table, fk_column)
+        result.add_column(
+            schema_name=column.schema_name,
+            table_name=column.table_name,
+            column_name=column.column_name,
+            column_type=column.column_type,
+            numeric_precision=column.numeric_precision,
+            numeric_scale=column.numeric_scale,
+            is_nullable=column.is_nullable,
+            fk_schema=column.foreign_key_schema,
+            fk_table=column.foreign_key_table,
+            fk_column=column.foreign_key_column,
+        )
         
     for constraint in unique_constraints_info:
         columns = set(constraint.columns.strip('{}').split(','))  # Postgres returns {col1,col2,...}

{sql_error_categorizer-0.1.4 → sql_error_categorizer-0.1.6}/src/sql_error_categorizer/detectors/logical.py

@@ -27,7 +27,13 @@ class LogicalErrorDetector(BaseDetector):
             update_query=update_query,
         )
 
-    def run(self) -> list[DetectedError]:    
+    def run(self) -> list[DetectedError]:
+
+        # All logical errors require at least one solution to compare against
+        # If no solutions are provided, we cannot perform logical error detection
+        if not self.solutions:
+            return []
+
         results: list[DetectedError] = super().run()
 
         checks = [
@@ -182,9 +188,6 @@ class LogicalErrorDetector(BaseDetector):
             3. Incorrect Join: A table is included, but it is not the correct one needed for the join.
         '''
                 
-        if not self.solutions:
-            return []
-
         @dataclass(frozen=True)
         class TableCol:
             table: str
@@ -434,6 +437,10 @@ class LogicalErrorDetector(BaseDetector):
         return []
 
     def log_73_missing_as_from_select(self) -> list[DetectedError]:
+        '''
+            Flags when AS aliases are missing from required columns in the SELECT clause.
+        '''
+        
         results: list[DetectedError] = []
 
         # ensure we have the correct columns in both amount and source

{sql_error_categorizer-0.1.4 → sql_error_categorizer-0.1.6}/test_detector.py

@@ -1,5 +1,5 @@
 from sql_error_categorizer.detectors import Detector
-from sql_error_categorizer import load_catalog, build_catalog, SyntaxErrorDetector, SemanticErrorDetector, LogicalErrorDetector, ComplicationDetector
+from sql_error_categorizer import load_catalog, build_catalog_from_postgres, SyntaxErrorDetector, SemanticErrorDetector, LogicalErrorDetector, ComplicationDetector
 
 def make_catalog(file: str) -> None:
     '''Utility function to build a catalog from a source file'''
@@ -7,7 +7,7 @@ def make_catalog(file: str) -> None:
     with open(f'datasets/sql/{file}.sql') as f:
         content = f.read()
 
-    cat = build_catalog(content, hostname='localhost', port=5432, user='postgres', password='password', schema=file, create_temp_schema=True)
+    cat = build_catalog_from_postgres(content, hostname='localhost', port=5432, user='postgres', password='password', schema=file, create_temp_schema=True)
 
     cat.save_json(f'datasets/catalogs/{file}.json')
 

{sql_error_categorizer-0.1.4 → sql_error_categorizer-0.1.6}/tests/detectors/3_log/test_058_join_on_incorrect_table.py

@@ -107,6 +107,12 @@ def test_wrong(query: str, solutions: list[str], expected_errors: list[tuple[str
         ],
         None
     ),
+    (
+        # no solutions (return no errors)
+        'SELECT a, b, c FROM table1 JOIN table2 ON table1.id = table2.id;',
+        [],
+        None,
+    ),
     # subqueries
     (
         # expected: table1 table2 table3 table4

{sql_error_categorizer-0.1.4 → sql_error_categorizer-0.1.6}/tests/detectors/3_log/test_059_join_when_join_needs_to_be_omitted.py

@@ -107,7 +107,12 @@ def test_wrong(query: str, solutions: list[str], expected_errors: list[tuple[str
         ],
         None
     ),
-    
+    (
+        # no solutions (return no errors)
+        'SELECT a, b, c FROM table1 JOIN table2 ON table1.id = table2.id;',
+        [],
+        None,
+    ),
     # subqueries
     (
         # expected: table1 table2 table3 table4

{sql_error_categorizer-0.1.4 → sql_error_categorizer-0.1.6}/tests/detectors/3_log/test_062_missing_join.py

@@ -106,6 +106,12 @@ def test_wrong(query: str, solutions: list[str], expected_errors: list[tuple[str
         ],
         None,
     ),
+    (
+        # no solutions (return no errors)
+        'SELECT a, b, c FROM table1 JOIN table2 ON table1.id = table2.id;',
+        [],
+        None,
+    ),
     # subqueries
     (
         # expected: table1 table2 table3 table4

{sql_error_categorizer-0.1.4 → sql_error_categorizer-0.1.6}/tests/detectors/3_log/test_070_extraneous_column_in_select.py

@@ -84,6 +84,12 @@ def test_wrong(query, solutions, schema, search_path, expected_len, expected_col
         ['SELECT cid, cname FROM customer;'],
         'miedema',
     ),
+    (
+        # no solutions (return no errors)
+        'SELECT a, b, c FROM table1;',
+        [],
+        None,
+    ),
     # subqueries
     (
         'SELECT a, (SELECT b FROM table2) as sub_col FROM table1;',

{sql_error_categorizer-0.1.4 → sql_error_categorizer-0.1.6}/tests/detectors/3_log/test_071_missing_column_from_select.py

@@ -84,6 +84,12 @@ def test_wrong(query, solutions, schema, search_path, expected_len, expected_col
         ['SELECT cid FROM customer;'],
         'miedema',
     ),
+    (
+        # no solutions (return no errors)
+        'SELECT a, b, c FROM table1;',
+        [],
+        None,
+    ),
     # subqueries
     (
         'SELECT a, (SELECT b FROM table2) as sub_col FROM table1;',

{sql_error_categorizer-0.1.4 → sql_error_categorizer-0.1.6}/tests/detectors/3_log/test_072_missing_distinct_from_select.py

@@ -59,6 +59,12 @@ def test_wrong(query, solutions, schema):
         ['SELECT DISTINCT street FROM customer;'],
         'miedema'
     ),
+    (
+        # no solutions (return no errors)
+        'SELECT a, b, c FROM table1;',
+        [],
+        None,
+    ),    
     # Subqueries
     (
         'SELECT DISTINCT a, (SELECT b FROM table2) as sub_col FROM table1;',

{sql_error_categorizer-0.1.4 → sql_error_categorizer-0.1.6}/tests/detectors/3_log/test_073_missing_as_from_select.py

@@ -47,7 +47,13 @@ def test_wrong(query, solutions, schema, expected):
         'SELECT cid AS cname, cname AS cid FROM customer;',
         ['SELECT cid AS cname, cname AS cid FROM customer;'],
         'miedema',
-    )
+    ),
+    (
+        # no solutions (return no errors)
+        'SELECT a, b, c FROM table1;',
+        [],
+        None,
+    ),
     # subqueries -- Not applicable
     # CTEs -- Not applicable
 ])