sql-error-categorizer 0.2.4__tar.gz → 0.3.0__tar.gz

{sql_error_categorizer-0.2.4 → sql_error_categorizer-0.3.0}/.gitignore

@@ -1,7 +1,7 @@
 # CUSTOM
 test_q.sql
 test_s?.sql
-
+.codex
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

{sql_error_categorizer-0.2.4 → sql_error_categorizer-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql_error_categorizer
-Version: 0.2.4
+Version: 0.3.0
 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
@@ -14,7 +14,7 @@ Requires-Python: >=3.11
 Requires-Dist: psycopg2
 Requires-Dist: python-dateutil
 Requires-Dist: pyyaml
-Requires-Dist: sql-error-taxonomy
+Requires-Dist: sql-error-taxonomy>=1.1.2
 Requires-Dist: sqlglot
 Requires-Dist: sqlparse
 Requires-Dist: sqlscope>=1.0.15

{sql_error_categorizer-0.2.4 → sql_error_categorizer-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sql_error_categorizer"
-version = "0.2.4"
+version = "0.3.0"
 authors = [
   { name="Davide Ponzini", email="davide.ponzini95@gmail.com" },
 ]
@@ -22,7 +22,7 @@ dependencies = [
     "sqlparse",
     "sqlglot",
     "sqlscope>=1.0.15",
-    "sql_error_taxonomy",
+    "sql_error_taxonomy>=1.1.2",
     "z3-solver",
     "python-dateutil",
 ]

{sql_error_categorizer-0.2.4 → sql_error_categorizer-0.3.0}/requirements.txt

@@ -4,7 +4,7 @@ sqlparse
 sqlglot==28.0.0
 z3-solver
 python-dateutil
-sql_error_taxonomy>=1.0.1
+sql_error_taxonomy>=1.1.2
 sqlscope>=1.0.15
 
 # Dependencies for development

{sql_error_categorizer-0.2.4 → sql_error_categorizer-0.3.0}/src/sql_error_categorizer/detectors/complications.py

@@ -1,14 +1,10 @@
 '''Detector for complications in SQL queries.'''
 
-import difflib
-import re
-import sqlparse
-import sqlparse.keywords
 from typing import Callable
 from sqlglot import exp
 from sql_error_taxonomy import SqlErrors
-from sqlscope.catalog import ConstraintType, ConstraintColumn, Constraint
-from sqlscope import Query, Catalog
+from sqlscope.catalog import ConstraintType, ConstraintColumn
+from sqlscope import Query
 from sqlscope import util
 
 from .base import BaseDetector, DetectedError
@@ -36,29 +32,31 @@ class ComplicationDetector(BaseDetector):
         results: list[DetectedError] = super().run()
 
         checks = [
-            self.com_83_unnecessary_distinct_in_select_clause,
-            self.com_84_unnecessary_join,
-            self.com_85_unused_correlation_name,
-            self.com_86_correlation_names_are_always_identical,
-            self.com_87_unnecessary_general_comparison_operator,
-            self.com_88_like_without_wildcards,
-            self.com_89_unnecessarily_complicated_select_in_exists_subquery,
-            self.com_90_in_exists_can_be_replaced_by_comparison,
-            self.com_91_unnecessary_aggregate_function,
-            self.com_92_unnecessary_distinct_in_aggregate_function,
-            self.com_93_unnecessary_argument_of_count,
-            self.com_94_unnecessary_group_by_in_exists_subquery,
-            self.com_95_group_by_with_singleton_groups,
-            self.com_96_group_by_with_only_a_single_group,
-            self.com_97_group_by_can_be_replaced_by_distinct,
-            self.com_98_union_can_be_replaced_by_or,
-            self.com_99_complication_unnecessary_column_in_order_by_clause,
-            self.com_100_order_by_in_subquery,
-            self.com_101_inefficient_having,
-            self.com_102_inefficient_union,
-            self.com_103_condition_in_the_subquery_can_be_moved_up,
-            self.com_104_condition_on_left_table_in_left_outer_join,
-            self.com_105_outer_join_can_be_replaced_by_inner_join,
+            self.detect_95_unnecessary_complication,
+            self.detect_96_unnecessary_distinct_in_select_clause,
+            self.detect_97_unnecessary_table_reference,
+            self.detect_98_unused_correlation_name,
+            self.detect_99_tables_have_same_data,
+            self.detect_100_correlation_name_identical_to_table_name,
+            self.detect_101_unnecessary_general_comparison_operator,
+            self.detect_102_like_without_wildcards,
+            self.detect_103_unnecessarily_complicated_select_in_exists_subquery,
+            self.detect_104_in_exists_can_be_replaced_by_comparison,
+            self.detect_105_unnecessary_aggregate_function,
+            self.detect_106_unnecessary_distinct_in_aggregate_function,
+            self.detect_107_unnecessary_argument_of_count,
+            self.detect_108_unnecessary_group_by_in_exists_subquery,
+            self.detect_109_group_by_with_singleton_groups,
+            self.detect_110_group_by_with_only_a_single_group,
+            self.detect_111_group_by_can_be_replaced_by_distinct,
+            self.detect_112_union_can_be_replaced_by_or,
+            self.detect_113_unnecessary_column_in_order_by_clause,
+            self.detect_114_order_by_in_subquery,
+            self.detect_115_inefficient_having,
+            self.detect_116_inefficient_union,
+            self.detect_117_condition_in_the_subquery_can_be_moved_up,
+            self.detect_118_outer_join_can_be_replaced_by_inner_join,
+            self.detect_119_unused_cte,
         ]
         
         for chk in checks:
@@ -66,7 +64,11 @@ class ComplicationDetector(BaseDetector):
 
         return results
 
-    def com_83_unnecessary_distinct_in_select_clause(self) -> list[DetectedError]:
+    def detect_95_unnecessary_complication(self) -> list[DetectedError]:
+        '''NOTE: this is an umbrella term, so it can't be directly detected.'''
+        return []
+
+    def detect_96_unnecessary_distinct_in_select_clause(self) -> list[DetectedError]:
         '''
         Flags a SELECT DISTINCT clause that is unnecessary because the selected
         columns are already unique due to existing constraints.
@@ -81,12 +83,12 @@ class ComplicationDetector(BaseDetector):
             constraints = [c for c in select.output.unique_constraints if c.constraint_type != ConstraintType.DISTINCT]
 
             if len(constraints) > 0:
-                result.append(DetectedError(SqlErrors.COM_83_UNNECESSARY_DISTINCT_IN_SELECT_CLAUSE, (select.sql,)))
+                result.append(DetectedError(SqlErrors.UNNECESSARY_DISTINCT_IN_SELECT_CLAUSE, (select.sql,)))
 
         return result
 
     # TODO: refactor
-    def com_84_unnecessary_join(self) -> list[DetectedError]:
+    def detect_97_unnecessary_table_reference(self) -> list[DetectedError]:
         '''
         Flags a query that joins to a table not present in the correct solution.
         '''
@@ -110,25 +112,29 @@ class ComplicationDetector(BaseDetector):
                 # Find the original table name (with alias if it was used) to report back
                 original_table_name = next((t for t in original_q_tables if t.lower().startswith(table_name_lower)), table_name_lower)
                 results.append((
-                    SqlErrors.COM_84_UNNECESSARY_JOIN,
+                    SqlErrors.UNNECESSARY_TABLE_REFERENCE,
                     f"Unnecessary JOIN: The table '{original_table_name}' is not needed to answer the query."
                 ))
             
         return results
     
     # TODO: implement
-    def com_85_unused_correlation_name(self) -> list[DetectedError]:
+    def detect_98_unused_correlation_name(self) -> list[DetectedError]:
         return []
     
     # TODO: implement
-    def com_86_correlation_names_are_always_identical(self) -> list[DetectedError]:
+    def detect_99_tables_have_same_data(self) -> list[DetectedError]:
+        return []
+
+    # TODO: implement
+    def detect_100_correlation_name_identical_to_table_name(self) -> list[DetectedError]:
         return []
     
     # TODO: implement
-    def com_87_unnecessary_general_comparison_operator(self) -> list[DetectedError]:
+    def detect_101_unnecessary_general_comparison_operator(self) -> list[DetectedError]:
         return []
     
-    def com_88_like_without_wildcards(self) -> list[DetectedError]:
+    def detect_102_like_without_wildcards(self) -> list[DetectedError]:
         '''
         Flags queries where the LIKE operator is used without wildcards ('%' or '_').
         This indicates a potential misunderstanding, where the '=' operator should
@@ -157,23 +163,23 @@ class ComplicationDetector(BaseDetector):
                 if '%' not in pattern_value and '_' not in pattern_value:
                     full_expression = str(like)
 
-                    results.append(DetectedError(SqlErrors.COM_88_LIKE_WITHOUT_WILDCARDS, (full_expression,)))
+                    results.append(DetectedError(SqlErrors.LIKE_WITHOUT_WILDCARDS, (full_expression,)))
 
         return results
     
     # TODO: implement
-    def com_89_unnecessarily_complicated_select_in_exists_subquery(self) -> list[DetectedError]:
+    def detect_103_unnecessarily_complicated_select_in_exists_subquery(self) -> list[DetectedError]:
         return []
     
     # TODO: implement
-    def com_90_in_exists_can_be_replaced_by_comparison(self) -> list[DetectedError]:
+    def detect_104_in_exists_can_be_replaced_by_comparison(self) -> list[DetectedError]:
         return []
     
     # TODO: implement
-    def com_91_unnecessary_aggregate_function(self) -> list[DetectedError]:
+    def detect_105_unnecessary_aggregate_function(self) -> list[DetectedError]:
         return []
     
-    def com_92_unnecessary_distinct_in_aggregate_function(self) -> list[DetectedError]:
+    def detect_106_unnecessary_distinct_in_aggregate_function(self) -> list[DetectedError]:
         '''MIN and MAX never require DISTINCT. For other aggregate functions, DISTINCT is unnecessary if the argument is unique.'''
 
         results: list[DetectedError] = []
@@ -189,7 +195,7 @@ class ComplicationDetector(BaseDetector):
                     continue
 
                 if isinstance(agg_func, (exp.Min, exp.Max)):
-                    results.append(DetectedError(SqlErrors.COM_92_UNNECESSARY_DISTINCT_IN_AGGREGATE_FUNCTION, (str(agg_func),)))
+                    results.append(DetectedError(SqlErrors.UNNECESSARY_DISTINCT_IN_AGGREGATE_FUNCTION, (str(agg_func),)))
                     continue
 
                 arg_expr = agg_func.this.expressions   # `.this` is the DISTINCT, `.expressions` are the arguments
@@ -199,7 +205,7 @@ class ComplicationDetector(BaseDetector):
                 for expr in arg_expr:
                     # Check if the argument is a constant literal
                     if isinstance(expr, exp.Literal):
-                        results.append(DetectedError(SqlErrors.COM_92_UNNECESSARY_DISTINCT_IN_AGGREGATE_FUNCTION, (str(agg_func),)))
+                        results.append(DetectedError(SqlErrors.UNNECESSARY_DISTINCT_IN_AGGREGATE_FUNCTION, (str(agg_func),)))
                         continue
 
                     # Check if the argument is a column
@@ -210,18 +216,18 @@ class ComplicationDetector(BaseDetector):
                         unique_constraints = [c for c in select.all_constraints if c.constraint_type == ConstraintType.UNIQUE]
                         for constraint in unique_constraints:
                             if { ConstraintColumn(column_name, table_idx=select._get_table_idx_for_column(expr)) } == constraint.columns:
-                                results.append(DetectedError(SqlErrors.COM_92_UNNECESSARY_DISTINCT_IN_AGGREGATE_FUNCTION, (str(agg_func),)))
+                                results.append(DetectedError(SqlErrors.UNNECESSARY_DISTINCT_IN_AGGREGATE_FUNCTION, (str(agg_func),)))
                                 break
         return results
     
-    def com_93_unnecessary_argument_of_count(self) -> list[DetectedError]:
+    def detect_107_unnecessary_argument_of_count(self) -> list[DetectedError]:
         return []
     
     # TODO: implement
-    def com_94_unnecessary_group_by_in_exists_subquery(self) -> list[DetectedError]:
+    def detect_108_unnecessary_group_by_in_exists_subquery(self) -> list[DetectedError]:
         return []
     
-    def com_95_group_by_with_singleton_groups(self) -> list[DetectedError]:
+    def detect_109_group_by_with_singleton_groups(self) -> list[DetectedError]:
         '''
         Flags GROUP BY clauses on singleton groups due to the presence
         of UNIQUE constraints on the grouped columns.
@@ -241,16 +247,16 @@ class ComplicationDetector(BaseDetector):
 
             for constraint in constraints:
                 if constraint.columns.issubset(group_by_constraint.columns):
-                    results.append(DetectedError(SqlErrors.COM_95_GROUP_BY_WITH_SINGLETON_GROUPS, (group_by_constraint, constraint)))
+                    results.append(DetectedError(SqlErrors.GROUP_BY_WITH_SINGLETON_GROUPS, (group_by_constraint, constraint)))
                     break        
 
         return results
     
     # TODO: implement
-    def com_96_group_by_with_only_a_single_group(self) -> list[DetectedError]:
+    def detect_110_group_by_with_only_a_single_group(self) -> list[DetectedError]:
         return []
     
-    def com_97_group_by_can_be_replaced_by_distinct(self) -> list[DetectedError]:
+    def detect_111_group_by_can_be_replaced_by_distinct(self) -> list[DetectedError]:
         '''
         Flags GROUP BY clauses that can be replaced by SELECT DISTINCT.
         This occurs when all selected columns are included in the GROUP BY clause
@@ -290,18 +296,18 @@ class ComplicationDetector(BaseDetector):
             group_by_col_names = {(util.ast.column.get_real_name(col), select._get_table_idx_for_column(col)) for col in group_by_columns}
 
             if select_col_names == group_by_col_names:
-                results.append(DetectedError(SqlErrors.COM_97_GROUP_BY_CAN_BE_REPLACED_WITH_DISTINCT, (select_col_names,)))
+                results.append(DetectedError(SqlErrors.GROUP_BY_CAN_BE_REPLACED_WITH_DISTINCT, (select_col_names,)))
 
         return results
                         
 
     
     # TODO: implement
-    def com_98_union_can_be_replaced_by_or(self) -> list[DetectedError]:
+    def detect_112_union_can_be_replaced_by_or(self) -> list[DetectedError]:
         return []
     
     # TODO: refactor
-    def com_99_complication_unnecessary_column_in_order_by_clause(self) -> list[DetectedError]:
+    def detect_113_unnecessary_column_in_order_by_clause(self) -> list[DetectedError]:
         '''
         Flags when the ORDER BY clause contains unnecessary columns in addition
         to the required ones.
@@ -330,7 +336,7 @@ class ComplicationDetector(BaseDetector):
         return results
     
     # TODO: implement
-    def com_100_order_by_in_subquery(self) -> list[DetectedError]:
+    def detect_114_order_by_in_subquery(self) -> list[DetectedError]:
         '''
         Flags when a subquery contains an ORDER BY clause.
         Subqueries both ORDER BY and LIMIT are considered valid.
@@ -348,31 +354,30 @@ class ComplicationDetector(BaseDetector):
 
                 checked_subqueries.add(subquery.sql)
                 if subquery.order_by and not subquery.limit:
-                    results.append(DetectedError(SqlErrors.COM_100_ORDER_BY_IN_SUBQUERY, (subquery.sql,)))
+                    results.append(DetectedError(SqlErrors.ORDER_BY_IN_SUBQUERY, (subquery.sql,)))
 
         return results
     
     # TODO: implement
-    def com_101_inefficient_having(self) -> list[DetectedError]:
+    def detect_115_inefficient_having(self) -> list[DetectedError]:
         return []
     
     # TODO: implement
-    def com_102_inefficient_union(self) -> list[DetectedError]:
+    def detect_116_inefficient_union(self) -> list[DetectedError]:
         return []
     
     # TODO: implement
-    def com_103_condition_in_the_subquery_can_be_moved_up(self) -> list[DetectedError]:
+    def detect_117_condition_in_the_subquery_can_be_moved_up(self) -> list[DetectedError]:
         return []
     
     # TODO: implement
-    def com_104_condition_on_left_table_in_left_outer_join(self) -> list[DetectedError]:
+    def detect_118_outer_join_can_be_replaced_by_inner_join(self) -> list[DetectedError]:
         return []
-    
+
     # TODO: implement
-    def com_105_outer_join_can_be_replaced_by_inner_join(self) -> list[DetectedError]:
+    def detect_119_unused_cte(self) -> list[DetectedError]:
         return []
 
-
     #region Utility methods
     def _get_select_columns(self, ast: dict) -> list:
         '''