sql-error-categorizer 0.1.7__tar.gz → 0.1.8__tar.gz

{sql_error_categorizer-0.1.7 → sql_error_categorizer-0.1.8}/.gitignore

@@ -178,5 +178,9 @@ cython_debug/
 # PyPI configuration file
 .pypirc
 
+<<<<<<< Updated upstream
 # VS Code
-.vscode/
+.vscode/
+=======
+.vscode
+>>>>>>> Stashed changes

{sql_error_categorizer-0.1.7 → sql_error_categorizer-0.1.8}/PKG-INFO

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

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

{sql_error_categorizer-0.1.7 → sql_error_categorizer-0.1.8}/src/sql_error_categorizer/detectors/semantic.py

@@ -74,10 +74,12 @@ class SemanticErrorDetector(BaseDetector):
 
             dnf = util.ast.extract_DNF(where)
 
+
             # Refer to Brass & Goldberg, 2006 for these checks (error #8)
             # (1) whole formula
             try:
-                whole = Or(*[smt.sql_to_z3(C, variables) for C in dnf])
+                whole_clauses = [smt.sql_to_z3(C, variables) for C in dnf]
+                whole = Or(*whole_clauses)
             except Exception:
                 continue  # skip if cannot convert to z3
 

{sql_error_categorizer-0.1.7 → sql_error_categorizer-0.1.8}/src/sql_error_categorizer/detectors/syntax.py

@@ -7,6 +7,9 @@ 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.typechecking import get_type, collect_errors
+
 from .base import BaseDetector, DetectedError
 from ..query import Query
 from ..sql_errors import SqlErrors
@@ -659,90 +662,51 @@ class SyntaxErrorDetector(BaseDetector):
     def syn_12_failure_to_specify_column_name_twice(self) -> list[DetectedError]:
         return []
     
-    # TODO: refactor, needs AST
     def syn_13_data_type_mismatch(self) -> list[DetectedError]:
         '''
         Checks for data type mismatches in comparisons within the query.
         '''
 
-        return []
-        
-        # Check for data type mismatches in the query.
-        results: list[DetectedError] = []
+        def parse_set_operation(set_op: 'SetOperation', location: str) -> list[DetectedError]:
 
-        comparison_operators = {'=', '<>', '!=', '<', '>', '<=', '>='}
+            '''
+            Util function to parse a SetOperation and check for data type mismatches among its main selects.
+            '''
+            errors: list[DetectedError] = []
+            expected_output = None # type of the first select's output
+            for select in set_op.main_selects:
 
-        
-        tokens = self.tokens
-        alias_map = self.query_map.get('alias_mapping', {})
-        all_table_columns = self.catalog.get("table_columns", {})
-        column_metadata = self.catalog.get("column_metadata", {})
+                typed_ast = select.typed_ast
+                
+                if typed_ast is None:
+                    continue
 
-        # Build reverse alias map for resolving columns to tables
-        column_to_table = {}
-        for table, columns in all_table_columns.items():
-            for col in columns:
-                column_to_table.setdefault(col.lower(), set()).add(table)
+                columns_type = get_type(typed_ast, select.catalog, select.search_path)
 
-        i = 0
-        while i < len(tokens):
-            tt, val = tokens[i]
-            if val in comparison_operators:
-                lhs_token = tokens[i - 1] if i - 1 >= 0 else None
-                rhs_token = tokens[i + 1] if i + 1 < len(tokens) else None
-
-                lhs_type = rhs_type = None
-
-                # --- LHS type resolution ---
-                if lhs_token:
-                    lhs_val = lhs_token[1].strip('"`')
-                    if '.' in lhs_val:
-                        tbl, col = lhs_val.split('.', 1)
-                        tbl = alias_map.get(tbl, [tbl])[0] if tbl in alias_map else tbl
-                        lhs_type = column_metadata.get(tbl, {}).get(col, {}).get("type")
-                    elif lhs_val.lower() in column_to_table:
-                        for tbl in column_to_table[lhs_val.lower()]:
-                            t = column_metadata.get(tbl, {}).get(lhs_val, {}).get("type")
-                            if t:
-                                lhs_type = t
-                                break
-                    elif lhs_val.startswith("'") and lhs_val.endswith("'"):
-                        lhs_type = "text"
-                    elif re.match(r'^\d+\.\d+$', lhs_val):
-                        lhs_type = "float"
-                    elif lhs_val.isdigit():
-                        lhs_type = "int"
-
-                # --- RHS type resolution ---
-                if rhs_token:
-                    rhs_val = rhs_token[1].strip('"`')
-                    if '.' in rhs_val:
-                        tbl, col = rhs_val.split('.', 1)
-                        tbl = alias_map.get(tbl, [tbl])[0] if tbl in alias_map else tbl
-                        rhs_type = column_metadata.get(tbl, {}).get(col, {}).get("type")
-                    elif rhs_val.lower() in column_to_table:
-                        for tbl in column_to_table[rhs_val.lower()]:
-                            t = column_metadata.get(tbl, {}).get(rhs_val, {}).get("type")
-                            if t:
-                                rhs_type = t
-                                break
-                    elif rhs_val.startswith("'") and rhs_val.endswith("'"):
-                        rhs_type = "text"
-                    elif re.match(r'^\d+\.\d+$', rhs_val):
-                        rhs_type = "float"
-                    elif rhs_val.isdigit():
-                        rhs_type = "int"
-
-                # --- Check mismatch ---
-                if lhs_type and rhs_type and not self._are_types_compatible(lhs_type, rhs_type):
-                    results.append((
-                        SqlErrors.SYN_13_DATA_TYPE_MISMATCH,
-                        f"Comparison type mismatch: {lhs_token[1]} ({lhs_type}) {val} {rhs_token[1]} ({rhs_type})"
-                    ))
+                # 1st select: set expected output type
+                if expected_output is None:
+                    expected_output = columns_type
+                else:
+                    # compare with expected output type
+                    if expected_output != columns_type:
+                        errors.append(DetectedError(SqlErrors.SYN_13_DATA_TYPE_MISMATCH, (location,"setop types inconsistent")))
 
-            i += 1
+                # load found messages
+                for message in columns_type.messages:
+                    errors.append(DetectedError(SqlErrors.SYN_13_DATA_TYPE_MISMATCH, message))
+
+            return errors
+
+        results: list[DetectedError] = []
+
+        # CTEs
+        for cte in self.query.ctes:
+            results.extend(parse_set_operation(cte, f"CTE {cte.output.name}"))
 
-        return results    
+        # Main Query
+        results.extend(parse_set_operation(self.query.main_query, "Main Query"))
+
+        return results
     
     def syn_14_aggregate_function_outside_select_or_having(self) -> list[DetectedError]:
         '''
@@ -1284,9 +1248,44 @@ class SyntaxErrorDetector(BaseDetector):
 
         return results
     
-    #TODO: implement
+
     def syn_35_is_where_not_applicable(self) -> list[DetectedError]:
-        return []
+        '''
+        Find all erroneous usages of IS where it is not applicable
+        '''
+
+        def parse_set_operation(set_operation: 'SetOperation') -> list[DetectedError]:
+            '''
+            Util function to parse a SetOperation and check for invalid usage of IS in all its main selects.
+            '''
+
+            errors: list[DetectedError] = []
+            for select in set_operation.main_selects:
+
+                typed_ast = select.typed_ast
+                
+                if typed_ast is None:
+                    continue
+
+                for is_expr in typed_ast.find_all(exp.Is):
+                    for error in collect_errors(is_expr, select.catalog, select.search_path):
+
+                        # if the expected type is boolean|null, it means that the part after IS is not valid
+                        if error[2] == 'boolean|null':
+                            errors.append(DetectedError(SqlErrors.SYN_35_IS_WHERE_NOT_APPLICABLE, error))
+
+            return errors
+
+        results: list[DetectedError] = []
+
+        # CTEs
+        for cte in self.query.ctes:
+            results.extend(parse_set_operation(cte))
+
+        # Main Query
+        results.extend(parse_set_operation(self.query.main_query))
+
+        return results
     
     #TODO: implement
     def syn_36_nonstandard_keywords_or_standard_keywords_in_wrong_context(self) -> list[DetectedError]:

{sql_error_categorizer-0.1.7 → sql_error_categorizer-0.1.8}/src/sql_error_categorizer/query/query.py

@@ -121,21 +121,7 @@ class Query(TokenizedSQL):
 
         result.extend(self.main_query.selects)
 
-        return result
-    
-
-    @property
-    def main_selects(self) -> list[Select]:
-
-        def _gather_selects_from_set_operation(so: SetOperation) -> list[Select]:
-            if isinstance(so, Select):
-                return [so]
-            elif isinstance(so, BinarySetOperation):
-                return _gather_selects_from_set_operation(so.left) + _gather_selects_from_set_operation(so.right)
-            else:
-                return []
-
-        return _gather_selects_from_set_operation(self.main_query)        
+        return result        
     
     @property
     def output_columns_source(self) -> set[tuple[str, str | None, str]]:

{sql_error_categorizer-0.1.7 → sql_error_categorizer-0.1.8}/src/sql_error_categorizer/query/set_operations/binary_set_operation.py

@@ -74,6 +74,10 @@ class BinarySetOperation(SetOperation, ABC):
         print(                      f'{pre}`- Right:')
         self.right.print_tree(pre=  f'{pre}   ')
 
+    @property
+    def main_selects(self) -> list['Select']:
+        return self.left.main_selects + self.right.main_selects
+
     @property
     def selects(self) -> list['Select']:
         return self.left.selects + self.right.selects

{sql_error_categorizer-0.1.7 → sql_error_categorizer-0.1.8}/src/sql_error_categorizer/query/set_operations/select.py

@@ -84,18 +84,10 @@ class Select(SetOperation, TokenizedSQL):
             # Table: look it up in the IN catalog
             elif isinstance(expr, exp.Table):
                 # schema name
-                schema_name = util.ast.table.get_schema(expr)
+                schema_name = util.ast.table.get_schema(expr) or self.search_path
                 table_name_in = util.ast.table.get_real_name(expr)
                 table_name_out = util.ast.table.get_name(expr)
 
-                if schema_name is None:
-                    # If no schema is specified, try to find the table in the CTEs
-                    if self.catalog.has_table(schema_name='', table_name=table_name_in):
-                        schema_name = ''
-                    # If not found in CTEs, use the search path
-                    else:
-                        schema_name = self.search_path 
-
                 # check if the table exists in the catalog
                 if self.catalog.has_table(schema_name=schema_name, table_name=table_name_in):
                     # Table exists
@@ -651,6 +643,10 @@ class Select(SetOperation, TokenizedSQL):
             return int(offset_exp.expression.this)
         except ValueError:
             return None
+        
+    @property
+    def main_selects(self) -> list['Select']:
+        return [self]
     
     @property
     def selects(self) -> list['Select']:

{sql_error_categorizer-0.1.7 → sql_error_categorizer-0.1.8}/src/sql_error_categorizer/query/set_operations/set_operation.py

@@ -52,6 +52,12 @@ class SetOperation(ABC):
             parsed = sqlglot.parse_one(fake_sql)
             self._trailing_ast = parsed
         return self._trailing_ast
+    
+    @property
+    @abstractmethod
+    def main_selects(self) -> list['Select']:
+        '''Returns a list of selects that are part of a set operation.'''
+        return []
 
     @property
     @abstractmethod

{sql_error_categorizer-0.1.7 → sql_error_categorizer-0.1.8}/src/sql_error_categorizer/query/smt.py

@@ -12,31 +12,93 @@ from z3 import (
     unsat,
     is_expr,
     BoolSort,
-    ExprRef
+    ExprRef,
+    Re,
+    AllChar,
+    Concat,
+    InRe,
+    PrefixOf,
+    SuffixOf,
+    Contains,
 )
 
 from ..catalog import Table
 
-def create_z3_var(variables: dict[str, Any], table_name: str | None, col_name: str, col_type: Callable[[str], ExprRef] | None = None) -> None:
+
+# ----------------------------------------------------------------------
+#  Z3 variable creation
+# ----------------------------------------------------------------------
+
+def create_z3_var(variables: dict[str, Any], table_name: str | None,
+                  col_name: str, col_type: Callable[[str], ExprRef] | None = None) -> None:
     '''
-    Create a Z3 variable for the given column name and type, and add it to the variables dictionary.
-    If col_type is None, default to Int.
+    Create a Z3 variable for the given column name and type, and add it to the
+    variables dictionary. If col_type is None, default to Int.
     '''
-    
     if col_type is None:
         col_type = Int  # default type
 
-    # Add both unqualified and qualified names and null flags
+    # unqualified
     variables[col_name] = col_type(col_name)
     variables[f'{col_name}_isnull'] = Bool(f'{col_name}_isnull')
 
+    # qualified
     if table_name:
         variables[f'{table_name}.{col_name}'] = col_type(f'{table_name}.{col_name}')
         variables[f'{table_name}.{col_name}_isnull'] = Bool(f'{table_name}.{col_name}_isnull')
 
+
+def fresh_symbol(prefix: str, sort: str):
+    '''Generate a fresh Z3 symbol with the given prefix and sort.'''
+    if sort == 'int':
+        return Int(f'{prefix}_{id(prefix)}')
+    if sort == 'real':
+        return Real(f'{prefix}_{id(prefix)}')
+    if sort == 'bool':
+        return Bool(f'{prefix}_{id(prefix)}')
+    return String(f'{prefix}_{id(prefix)}')
+
+
+# ----------------------------------------------------------------------
+#  Infer expected type of a subquery based on parent expression
+# ----------------------------------------------------------------------
+
+def infer_subquery_sort_from_parent(expr) -> str:
+    '''
+    Infer the expected Z3 sort of a subquery based on its parent expression.
+    '''
+    parent = expr.parent
+
+    # Arithmetic context → numeric
+    if isinstance(parent, (exp.Add, exp.Sub, exp.Mul, exp.Div, exp.Mod, exp.Pow)):
+        return 'real'
+
+    # Comparison context → numeric
+    if isinstance(parent, (exp.GT, exp.GTE, exp.LT, exp.LTE)):
+        return 'real'
+
+    # BETWEEN → numeric
+    if isinstance(parent, exp.Between):
+        return 'real'
+
+    # LIKE → string
+    if isinstance(parent, exp.Like):
+        return 'string'
+
+    # String concatenation (|| operator)
+    if isinstance(parent, exp.Concat):
+        return 'string'
+
+    # Default: boolean (EXISTS, WHERE (...))
+    return 'bool'
+
+
+# ----------------------------------------------------------------------
+#  Catalog → Z3 vars
+# ----------------------------------------------------------------------
+
 def catalog_table_to_z3_vars(table: Table) -> dict[str, ExprRef]:
     '''Convert catalog table columns to Z3 variables.'''
-
     variables = {}
     for column in table.columns:
         col_name = column.name
@@ -52,11 +114,16 @@ def catalog_table_to_z3_vars(table: Table) -> dict[str, ExprRef]:
             create_z3_var(variables, table.name, col_name, String)
         else:
             create_z3_var(variables, table.name, col_name)
-
     return variables
 
+
+# ----------------------------------------------------------------------
+#  SQL → Z3 conversion
+# ----------------------------------------------------------------------
+
 def sql_to_z3(expr, variables: dict[str, ExprRef] = {}) -> Any:
     '''Convert a SQLGlot expression to a Z3 expression.'''
+
     # --- Columns ---
     if isinstance(expr, exp.Column):
         name = expr.name.lower()
@@ -76,7 +143,6 @@ def sql_to_z3(expr, variables: dict[str, ExprRef] = {}) -> Any:
         elif val.upper() in ('TRUE', 'FALSE'):
             return BoolVal(val.upper() == 'TRUE')
         elif val.upper() == 'NULL':
-            # Represent NULL as a special None (handled by IS NULL)
             return None
         else:
             raise NotImplementedError(f"Unsupported literal: {val}")
@@ -122,21 +188,24 @@ def sql_to_z3(expr, variables: dict[str, ExprRef] = {}) -> Any:
     elif isinstance(expr, exp.Pow):
         return sql_to_z3(expr.left, variables) ** sql_to_z3(expr.right, variables)
 
-    # --- BETWEEN a AND b ---String
+    # --- BETWEEN ---
     elif isinstance(expr, exp.Between):
         target = sql_to_z3(expr.this, variables)
         low = sql_to_z3(expr.args['low'], variables)
         high = sql_to_z3(expr.args['high'], variables)
         return And(target >= low, target <= high)
 
-    # --- IN (list) ---
+    # --- IN ---
     elif isinstance(expr, exp.In):
         target = sql_to_z3(expr.this, variables)
-        if isinstance(expr.args['expressions'], exp.Subquery):
-            # Subquery handling can be complex; skipping for now
-            return BoolVal(True)
-        
+
+        if isinstance(expr.args.get('query'), exp.Subquery):
+            # subquery → symbolic value
+            sym = fresh_symbol('subq_in', 'string')
+            return target == sym
+
         options = [sql_to_z3(e, variables) for e in expr.expressions]
+
         return Or(*[target == o for o in options])
 
     # --- IS / IS NOT ---
@@ -144,65 +213,122 @@ def sql_to_z3(expr, variables: dict[str, ExprRef] = {}) -> Any:
         target_expr = expr.this
         right_expr = expr.args.get('expression')
 
-        # handle IS NULL and IS NOT NULL
         if isinstance(right_expr, exp.Null):
-            # x IS NULL → x_isnull = True
             if isinstance(target_expr, exp.Column):
                 name = target_expr.name.lower()
                 flag = variables.setdefault(f'{name}_isnull', Bool(f'{name}_isnull'))
                 return flag
-            else:
-                return BoolVal(False)
+            return BoolVal(False)
 
-        elif isinstance(right_expr, exp.Not) and isinstance(right_expr.this, exp.Null):
-            # x IS NOT NULL → ¬x_isnull
+        if isinstance(right_expr, exp.Not) and isinstance(right_expr.this, exp.Null):
             if isinstance(target_expr, exp.Column):
                 name = target_expr.name.lower()
                 flag = variables.setdefault(f'{name}_isnull', Bool(f'{name}_isnull'))
                 return Not(flag)
-            else:
-                return BoolVal(True)
+            return BoolVal(True)
+
+        return sql_to_z3(target_expr, variables) == sql_to_z3(right_expr, variables)
+
+    # --- LIKE ---
+    elif isinstance(expr, exp.Like):
+        target = sql_to_z3(expr.this, variables)
+        pattern_expr = sql_to_z3(expr.expression, variables)
+
+        # If pattern is a variable → fallback
+        if not isinstance(expr.expression, exp.Literal):
+            return target == pattern_expr
+
+        pattern = expr.expression.this.strip("'")
+        wildcard_count = pattern.count('%') + pattern.count('_')
+
+        if wildcard_count > 2:
+            return target == StringVal(pattern)
+
+        # PREFIX pattern: abc%
+        if '%' in pattern and '_' not in pattern:
+            if pattern.endswith('%') and pattern.count('%') == 1:
+                prefix = pattern[:-1]
+                return PrefixOf(StringVal(prefix), target)
+
+            # CONTAINS: %abc%
+            if pattern.startswith('%') and pattern.endswith('%') and pattern.count('%') == 2:
+                mid = pattern[1:-1]
+                return Contains(target, StringVal(mid))
+
+            # SUFFIX: %abc
+            if pattern.startswith('%') and pattern.count('%') == 1:
+                suffix = pattern[1:]
+                return SuffixOf(StringVal(suffix), target)
+
+        # EXACTLY ONE '_' wildcard
+        if '_' in pattern and '%' not in pattern and wildcard_count == 1:
+            parts = pattern.split('_')
+            regex = None
+            for i, p in enumerate(parts):
+                r = Re(StringVal(p))
+                regex = r if regex is None else Concat(regex, r)
+                if i < len(parts) - 1:
+                    regex = Concat(regex, AllChar(r.sort()))
+            return InRe(target, regex)
 
+        return target == StringVal(pattern)
+
+    # --- EXISTS ---
+    elif isinstance(expr, exp.Exists):
+        return fresh_symbol('subq_exists', 'bool')
+
+    # --- SUBQUERY ---
+    elif isinstance(expr, exp.Subquery):
+        sort = infer_subquery_sort_from_parent(expr)
+        if sort == 'int':
+            return fresh_symbol('subq_val', 'int')
+        elif sort == 'real':
+            return fresh_symbol('subq_val', 'real')
+        elif sort == 'string':
+            return fresh_symbol('subq_val', 'string')
         else:
-            # generic IS (e.g., IS TRUE, IS FALSE)
-            return sql_to_z3(target_expr, variables) == sql_to_z3(right_expr, variables)
+            return fresh_symbol('subq_bool', 'bool')
 
-    # Fallback: skip unsupported expressions
+    # --- Fallback ---
     return BoolVal(True)
 
+
+# ----------------------------------------------------------------------
+#  Formula checking
+# ----------------------------------------------------------------------
+
 def check_formula(expr) -> str:
     '''Check if the given SQLGlot expression is a tautology, contradiction, or contingent.'''
+    
     formula = sql_to_z3(expr, {})
+    
     if formula is None:
         return 'unknown'
 
     solver = Solver()
 
-    # Check for contradiction
     solver.push()
     solver.add(formula)
+
     if solver.check() == unsat:
-        solver.pop()
         return 'contradiction'
-    solver.pop()
 
-    # Check for tautology
+    solver.pop()
     solver.push()
     solver.add(Not(formula))
+
     if solver.check() == unsat:
-        solver.pop()
         return 'tautology'
-    solver.pop()
 
     return 'contingent'
 
 def is_satisfiable(expr_z3) -> bool:
-    '''Check if the given Z3 expression is satisfiable.'''
+
     solver = Solver()
     solver.add(expr_z3)
+    result = solver.check() != unsat
 
-    return solver.check() != unsat
+    return result
 
 def is_bool_expr(e) -> bool:
-    '''Check if the given Z3 expression is boolean.'''
     return is_expr(e) and e.sort().kind() == BoolSort().kind()

{sql_error_categorizer-0.1.7 → sql_error_categorizer-0.1.8}/src/sql_error_categorizer/query/typechecking/predicates.py

@@ -76,12 +76,14 @@ def _(expression: exp.In, catalog: Catalog, search_path: str) -> ResultType:
     # Case IN (<list>)
     for item in expression.expressions:
         item_type = get_type(item, catalog, search_path)
+        old_messages.extend(item_type.messages)
         if target_type != item_type:
             old_messages.append(error_message(expression, item_type, target_type))
 
     # Case IN (subquery)
     if expression.args.get("query"):
         subquery_type = get_type(expression.args.get("query"), catalog, search_path)
+        old_messages.extend(subquery_type.messages)
         if target_type != subquery_type:
             old_messages.append(error_message(expression, subquery_type, target_type))
 

{sql_error_categorizer-0.1.7 → sql_error_categorizer-0.1.8}/src/sql_error_categorizer/query/typechecking/primitives.py

@@ -3,6 +3,7 @@ from ...catalog import Catalog
 from sqlglot import exp
 from .types import ResultType, AtomicType, DataType, TupleType
 from .util import is_number, is_date, to_number, to_date, error_message
+from ...util.ast.column import get_real_name, get_schema
 
 @get_type.register
 def _(expression: exp.Literal, catalog: Catalog, search_path: str) -> ResultType:
@@ -66,8 +67,8 @@ def _(expression: exp.Column, catalog: Catalog, search_path: str) -> ResultType:
     if expression.type.this in (DataType.Type.UNKNOWN, DataType.Type.USERDEFINED):
         return AtomicType(messages=[error_message(expression.name, "Unknown column type")])
     else:
-        schema = expression.args.get("db") or search_path
-        table = expression.args.get("table")
+        schema = get_schema(expression) or search_path
+        table = get_real_name(expression)
 
         nullable = catalog[schema][table][expression.name].is_nullable
         return AtomicType(data_type=expression.type.this, constant=False, nullable=nullable)

{sql_error_categorizer-0.1.7 → sql_error_categorizer-0.1.8}/src/sql_error_categorizer/query/typechecking/queries.py

@@ -24,11 +24,11 @@ def _(expression: exp.Select, catalog: Catalog, search_path: str) -> ResultType:
 
     having = expression.args.get("having")
     if having:
-        old_messages.extend(get_type(having, catalog, search_path).messages)
+        old_messages.extend(get_type(having.this, catalog, search_path).messages)
     if len(types) == 1:
-        return AtomicType(data_type=types[0].data_type, messages=old_messages, nullable=types[0].nullable, constant=types[0].constant)
+        return AtomicType(data_type=types[0].data_type, messages=old_messages, nullable=types[0].nullable)
 
-    return TupleType(types=types, messages=old_messages, nullable=any(t.nullable for t in types), constant=all(t.constant for t in types))
+    return TupleType(types=types, messages=old_messages, nullable=any(t.nullable for t in types))
 
 @get_type.register
 def _(expression: exp.Subquery, catalog: Catalog, search_path: str) -> ResultType: