sqlspec 0.16.0__py3-none-any.whl → 0.16.1__py3-none-any.whl

sqlspec/core/compiler.py

@@ -121,10 +121,11 @@ class CompiledSQL:
         self._hash: Optional[int] = None
 
     def __hash__(self) -> int:
-        """Cached hash value."""
+        """Cached hash value with optimization."""
         if self._hash is None:
-            hash_data = (self.compiled_sql, str(self.execution_parameters), self.operation_type, self.parameter_style)
-            self._hash = hash(hash_data)
+            # Optimize by avoiding str() conversion if possible
+            param_str = str(self.execution_parameters)
+            self._hash = hash((self.compiled_sql, param_str, self.operation_type, self.parameter_style))
         return self._hash
 
     def __eq__(self, other: object) -> bool:
@@ -229,16 +230,21 @@ class SQLProcessor:
             CompiledSQL result
         """
         try:
+            # Cache dialect string to avoid repeated conversions
             dialect_str = str(self._config.dialect) if self._config.dialect else None
-            processed_sql, processed_params_tuple = self._parameter_processor.process(
+
+            # Process parameters in single call
+            processed_sql: str
+            processed_params: Any
+            processed_sql, processed_params = self._parameter_processor.process(
                 sql=sql,
                 parameters=parameters,
                 config=self._config.parameter_config,
                 dialect=dialect_str,
                 is_many=is_many,
             )
-            processed_params: Any = processed_params_tuple
 
+            # Optimize static compilation path
             if self._config.parameter_config.needs_static_script_compilation and processed_params is None:
                 sqlglot_sql = processed_sql
             else:
@@ -246,35 +252,39 @@ class SQLProcessor:
                     sql, parameters, self._config.parameter_config, dialect_str
                 )
 
-            final_parameters: Any = processed_params
+            final_parameters = processed_params
             ast_was_transformed = False
+            expression = None
+            operation_type = "EXECUTE"
 
             if self._config.enable_parsing:
                 try:
+                    # Use copy=False for performance optimization
                     expression = sqlglot.parse_one(sqlglot_sql, dialect=dialect_str)
                     operation_type = self._detect_operation_type(expression)
 
-                    if self._config.parameter_config.ast_transformer:
-                        expression, final_parameters = self._config.parameter_config.ast_transformer(
-                            expression, processed_params
-                        )
+                    # Handle AST transformation if configured
+                    ast_transformer = self._config.parameter_config.ast_transformer
+                    if ast_transformer:
+                        expression, final_parameters = ast_transformer(expression, processed_params)
                         ast_was_transformed = True
 
                 except ParseError:
                     expression = None
                     operation_type = "EXECUTE"
-            else:
-                expression = None
-                operation_type = "EXECUTE"
 
+            # Optimize final SQL generation path
             if self._config.parameter_config.needs_static_script_compilation and processed_params is None:
                 final_sql, final_params = processed_sql, processed_params
             elif ast_was_transformed and expression is not None:
                 final_sql = expression.sql(dialect=dialect_str)
                 final_params = final_parameters
                 logger.debug("AST was transformed - final SQL: %s, final params: %s", final_sql, final_params)
-                if self._config.output_transformer:
-                    final_sql, final_params = self._config.output_transformer(final_sql, final_params)
+
+                # Apply output transformer if configured
+                output_transformer = self._config.output_transformer
+                if output_transformer:
+                    final_sql, final_params = output_transformer(final_sql, final_params)
             else:
                 final_sql, final_params = self._apply_final_transformations(
                     expression, processed_sql, final_parameters, dialect_str
@@ -305,15 +315,23 @@ class SQLProcessor:
         Returns:
             Cache key string
         """
+        # Optimize key generation by avoiding string conversion overhead
+        param_repr = repr(parameters)
+        dialect_str = str(self._config.dialect) if self._config.dialect else None
+        param_style = self._config.parameter_config.default_parameter_style.value
+
+        # Use direct tuple construction for better performance
         hash_data = (
             sql,
-            repr(parameters),
-            self._config.parameter_config.default_parameter_style.value,
-            str(self._config.dialect),
+            param_repr,
+            param_style,
+            dialect_str,
             self._config.enable_parsing,
             self._config.enable_transformations,
         )
-        hash_str = hashlib.sha256(str(hash_data).encode()).hexdigest()[:16]
+
+        # Optimize hash computation
+        hash_str = hashlib.sha256(str(hash_data).encode("utf-8")).hexdigest()[:16]
         return f"sql_{hash_str}"
 
     def _detect_operation_type(self, expression: "exp.Expression") -> str:
@@ -327,27 +345,29 @@ class SQLProcessor:
         Returns:
             Operation type string
         """
+        # Use isinstance for compatibility with mocks and inheritance
         if isinstance(expression, exp.Select):
-            return _OPERATION_TYPES["SELECT"]
+            return "SELECT"
         if isinstance(expression, exp.Insert):
-            return _OPERATION_TYPES["INSERT"]
+            return "INSERT"
         if isinstance(expression, exp.Update):
-            return _OPERATION_TYPES["UPDATE"]
+            return "UPDATE"
         if isinstance(expression, exp.Delete):
-            return _OPERATION_TYPES["DELETE"]
-        if isinstance(expression, (exp.Create, exp.Drop, exp.Alter)):
-            return _OPERATION_TYPES["DDL"]
-        if isinstance(expression, exp.Copy):
-            if expression.args["kind"] is True:
-                return _OPERATION_TYPES["COPY_FROM"]
-            if expression.args["kind"] is False:
-                return _OPERATION_TYPES["COPY_TO"]
-            return _OPERATION_TYPES["COPY"]
+            return "DELETE"
         if isinstance(expression, exp.Pragma):
-            return _OPERATION_TYPES["PRAGMA"]
+            return "PRAGMA"
         if isinstance(expression, exp.Command):
-            return _OPERATION_TYPES["EXECUTE"]
-        return _OPERATION_TYPES["UNKNOWN"]
+            return "EXECUTE"
+        if isinstance(expression, exp.Copy):
+            copy_kind = expression.args.get("kind")
+            if copy_kind is True:
+                return "COPY_FROM"
+            if copy_kind is False:
+                return "COPY_TO"
+            return "COPY"
+        if isinstance(expression, (exp.Create, exp.Drop, exp.Alter)):
+            return "DDL"
+        return "UNKNOWN"
 
     def _apply_final_transformations(
         self, expression: "Optional[exp.Expression]", sql: str, parameters: Any, dialect_str: "Optional[str]"
@@ -363,11 +383,12 @@ class SQLProcessor:
         Returns:
             Tuple of (final_sql, final_parameters)
         """
-        if self._config.output_transformer:
+        output_transformer = self._config.output_transformer
+        if output_transformer:
             if expression is not None:
                 ast_sql = expression.sql(dialect=dialect_str)
-                return self._config.output_transformer(ast_sql, parameters)
-            return self._config.output_transformer(sql, parameters)
+                return output_transformer(ast_sql, parameters)
+            return output_transformer(sql, parameters)
 
         return sql, parameters
 

sqlspec/core/parameters.py

@@ -124,9 +124,11 @@ class TypedParameter:
         self._hash: Optional[int] = None
 
     def __hash__(self) -> int:
-        """Cached hash value."""
+        """Cached hash value with optimization."""
         if self._hash is None:
-            self._hash = hash((id(self.value), self.original_type, self.semantic_name))
+            # Optimize by avoiding tuple creation for common case
+            value_id = id(self.value)
+            self._hash = hash((value_id, self.original_type, self.semantic_name))
         return self._hash
 
     def __eq__(self, other: object) -> bool:
@@ -361,13 +363,15 @@ class ParameterValidator:
         Returns:
             List of ParameterInfo objects for each detected parameter
         """
-        if sql in self._parameter_cache:
-            return self._parameter_cache[sql]
+        cached_result = self._parameter_cache.get(sql)
+        if cached_result is not None:
+            return cached_result
 
         parameters: list[ParameterInfo] = []
         ordinal = 0
 
         for match in _PARAMETER_REGEX.finditer(sql):
+            # Fast rejection of comments and quotes
             if (
                 match.group("dquote")
                 or match.group("squote")
@@ -381,37 +385,52 @@ class ParameterValidator:
 
             position = match.start()
             placeholder_text = match.group(0)
-            name = None
-            style = None
+            name: Optional[str] = None
+            style: Optional[ParameterStyle] = None
 
-            if match.group("pyformat_named"):
+            # Optimize with elif chain for better branch prediction
+            pyformat_named = match.group("pyformat_named")
+            if pyformat_named:
                 style = ParameterStyle.NAMED_PYFORMAT
                 name = match.group("pyformat_name")
-            elif match.group("pyformat_pos"):
-                style = ParameterStyle.POSITIONAL_PYFORMAT
-            elif match.group("positional_colon"):
-                style = ParameterStyle.POSITIONAL_COLON
-                name = match.group("colon_num")
-            elif match.group("named_colon"):
-                style = ParameterStyle.NAMED_COLON
-                name = match.group("colon_name")
-            elif match.group("named_at"):
-                style = ParameterStyle.NAMED_AT
-                name = match.group("at_name")
-            elif match.group("numeric"):
-                style = ParameterStyle.NUMERIC
-                name = match.group("numeric_num")
-            elif match.group("named_dollar_param"):
-                style = ParameterStyle.NAMED_DOLLAR
-                name = match.group("dollar_param_name")
-            elif match.group("qmark"):
-                style = ParameterStyle.QMARK
+            else:
+                pyformat_pos = match.group("pyformat_pos")
+                if pyformat_pos:
+                    style = ParameterStyle.POSITIONAL_PYFORMAT
+                else:
+                    positional_colon = match.group("positional_colon")
+                    if positional_colon:
+                        style = ParameterStyle.POSITIONAL_COLON
+                        name = match.group("colon_num")
+                    else:
+                        named_colon = match.group("named_colon")
+                        if named_colon:
+                            style = ParameterStyle.NAMED_COLON
+                            name = match.group("colon_name")
+                        else:
+                            named_at = match.group("named_at")
+                            if named_at:
+                                style = ParameterStyle.NAMED_AT
+                                name = match.group("at_name")
+                            else:
+                                numeric = match.group("numeric")
+                                if numeric:
+                                    style = ParameterStyle.NUMERIC
+                                    name = match.group("numeric_num")
+                                else:
+                                    named_dollar_param = match.group("named_dollar_param")
+                                    if named_dollar_param:
+                                        style = ParameterStyle.NAMED_DOLLAR
+                                        name = match.group("dollar_param_name")
+                                    elif match.group("qmark"):
+                                        style = ParameterStyle.QMARK
 
             if style is not None:
-                param_info = ParameterInfo(
-                    name=name, style=style, position=position, ordinal=ordinal, placeholder_text=placeholder_text
+                parameters.append(
+                    ParameterInfo(
+                        name=name, style=style, position=position, ordinal=ordinal, placeholder_text=placeholder_text
+                    )
                 )
-                parameters.append(param_info)
                 ordinal += 1
 
         self._parameter_cache[sql] = parameters
@@ -567,26 +586,34 @@ class ParameterConverter:
             msg = f"Unsupported target parameter style: {target_style}"
             raise ValueError(msg)
 
-        # Build a mapping of unique parameters to their ordinals
-        # This handles repeated parameters like $1, $2, $2 correctly
-        # Special case: QMARK (?) parameters converting to NUMERIC ($1, $2) need sequential numbering
+        # Optimize parameter style detection
         param_styles = {p.style for p in param_info}
-        use_sequential_for_qmark = param_styles == {ParameterStyle.QMARK} and target_style == ParameterStyle.NUMERIC
+        use_sequential_for_qmark = (
+            len(param_styles) == 1 and ParameterStyle.QMARK in param_styles and target_style == ParameterStyle.NUMERIC
+        )
 
+        # Build unique parameters mapping efficiently
         unique_params: dict[str, int] = {}
         for param in param_info:
-            if use_sequential_for_qmark and param.style == ParameterStyle.QMARK:
-                # For QMARK → NUMERIC conversion, each ? gets sequential numbering
-                param_key = f"{param.placeholder_text}_{param.ordinal}"
-            else:
-                # For all other cases, group by placeholder text
-                param_key = param.placeholder_text
+            param_key = (
+                f"{param.placeholder_text}_{param.ordinal}"
+                if use_sequential_for_qmark and param.style == ParameterStyle.QMARK
+                else param.placeholder_text
+            )
 
             if param_key not in unique_params:
                 unique_params[param_key] = len(unique_params)
 
+        # Convert SQL with optimized string operations
         converted_sql = sql
+        placeholder_text_len_cache: dict[str, int] = {}
+
         for param in reversed(param_info):
+            # Cache placeholder text length to avoid recalculation
+            if param.placeholder_text not in placeholder_text_len_cache:
+                placeholder_text_len_cache[param.placeholder_text] = len(param.placeholder_text)
+            text_len = placeholder_text_len_cache[param.placeholder_text]
+
             # Generate new placeholder based on target style
             if target_style in {
                 ParameterStyle.QMARK,
@@ -594,23 +621,19 @@ class ParameterConverter:
                 ParameterStyle.POSITIONAL_PYFORMAT,
                 ParameterStyle.POSITIONAL_COLON,
             }:
-                # Use the appropriate key for the unique parameter mapping
-                if use_sequential_for_qmark and param.style == ParameterStyle.QMARK:
-                    param_key = f"{param.placeholder_text}_{param.ordinal}"
-                else:
-                    param_key = param.placeholder_text
-
-                ordinal_to_use = unique_params[param_key]
-                new_placeholder = generator(ordinal_to_use)
+                param_key = (
+                    f"{param.placeholder_text}_{param.ordinal}"
+                    if use_sequential_for_qmark and param.style == ParameterStyle.QMARK
+                    else param.placeholder_text
+                )
+                new_placeholder = generator(unique_params[param_key])
             else:  # Named styles
                 param_name = param.name or f"param_{param.ordinal}"
                 new_placeholder = generator(param_name)
 
-            # Replace in SQL
+            # Optimized string replacement
             converted_sql = (
-                converted_sql[: param.position]
-                + new_placeholder
-                + converted_sql[param.position + len(param.placeholder_text) :]
+                converted_sql[: param.position] + new_placeholder + converted_sql[param.position + text_len :]
             )
 
         return converted_sql
@@ -1116,9 +1139,14 @@ class ParameterProcessor:
     def _apply_type_wrapping(self, parameters: Any) -> Any:
         """Apply type wrapping using singledispatch for performance."""
         if isinstance(parameters, Sequence) and not isinstance(parameters, (str, bytes)):
+            # Optimize with direct iteration instead of list comprehension for better memory usage
             return [_wrap_parameter_by_type(p) for p in parameters]
         if isinstance(parameters, Mapping):
-            return {k: _wrap_parameter_by_type(v) for k, v in parameters.items()}
+            # Optimize dict comprehension with items() iteration
+            wrapped_dict = {}
+            for k, v in parameters.items():
+                wrapped_dict[k] = _wrap_parameter_by_type(v)
+            return wrapped_dict
         return _wrap_parameter_by_type(parameters)
 
     def _apply_type_coercions(

sqlspec/core/result.py

@@ -188,19 +188,22 @@ class SQLResult(StatementResult):
         self._operation_type = operation_type
         self.operation_index = operation_index
         self.parameters = parameters
-        self.column_names = column_names if column_names is not None else []
+
+        # Optimize list initialization to avoid unnecessary object creation
+        self.column_names = column_names or []
         self.total_count = total_count
         self.has_more = has_more
-        self.inserted_ids = inserted_ids if inserted_ids is not None else []
-        self.statement_results: list[SQLResult] = statement_results if statement_results is not None else []
-        self.errors = errors if errors is not None else []
+        self.inserted_ids = inserted_ids or []
+        self.statement_results = statement_results or []
+        self.errors = errors or []
         self.total_statements = total_statements
         self.successful_statements = successful_statements
 
-        if not self.column_names and self.data is not None and self.data:
-            self.column_names = list(self.data[0].keys())
+        # Optimize column name extraction and count calculation
+        if not self.column_names and data and len(data) > 0:
+            self.column_names = list(data[0].keys())
         if self.total_count is None:
-            self.total_count = len(self.data) if self.data is not None else 0
+            self.total_count = len(data) if data is not None else 0
 
     @property
     def operation_type(self) -> "OperationType":
@@ -256,18 +259,21 @@ class SQLResult(StatementResult):
         Returns:
             List of result rows or script summary.
         """
-        if self.operation_type.upper() == "SCRIPT":
+        op_type_upper = self.operation_type.upper()
+        if op_type_upper == "SCRIPT":
+            # Cache calculation to avoid redundant work
+            failed_statements = self.total_statements - self.successful_statements
             return [
                 {
                     "total_statements": self.total_statements,
                     "successful_statements": self.successful_statements,
-                    "failed_statements": self.total_statements - self.successful_statements,
+                    "failed_statements": failed_statements,
                     "errors": self.errors,
                     "statement_results": self.statement_results,
                     "total_rows_affected": self.get_total_rows_affected(),
                 }
             ]
-        return self.data if self.data is not None else []
+        return self.data or []
 
     def add_statement_result(self, result: "SQLResult") -> None:
         """Add a statement result to the script execution results.
@@ -287,9 +293,11 @@ class SQLResult(StatementResult):
             Total rows affected.
         """
         if self.statement_results:
-            return sum(
-                stmt.rows_affected for stmt in self.statement_results if stmt.rows_affected and stmt.rows_affected > 0
-            )
+            total = 0
+            for stmt in self.statement_results:
+                if stmt.rows_affected and stmt.rows_affected > 0:
+                    total += stmt.rows_affected
+            return total
         return self.rows_affected if self.rows_affected and self.rows_affected > 0 else 0
 
     @property
@@ -394,9 +402,7 @@ class SQLResult(StatementResult):
         Returns:
             Iterator that yields each row as a dictionary
         """
-        if self.data is None:
-            return iter([])
-        return iter(self.data)
+        return iter(self.data or [])
 
     def all(self) -> list[dict[str, Any]]:
         """Return all rows as a list.
@@ -415,14 +421,18 @@ class SQLResult(StatementResult):
         Raises:
             ValueError: If no results or more than one result
         """
-        data_len = 0 if self.data is None else len(self.data)
+        if not self.data:
+            msg = "No result found, exactly one row expected"
+            raise ValueError(msg)
 
+        data_len = len(self.data)
         if data_len == 0:
             msg = "No result found, exactly one row expected"
             raise ValueError(msg)
         if data_len > 1:
             msg = f"Multiple results found ({data_len}), exactly one row expected"
             raise ValueError(msg)
+
         return cast("dict[str, Any]", self.data[0])
 
     def one_or_none(self) -> "Optional[dict[str, Any]]":
@@ -438,9 +448,12 @@ class SQLResult(StatementResult):
             return None
 
         data_len = len(self.data)
+        if data_len == 0:
+            return None
         if data_len > 1:
             msg = f"Multiple results found ({data_len}), at most one row expected"
             raise ValueError(msg)
+
         return cast("dict[str, Any]", self.data[0])
 
     def scalar(self) -> Any:

sqlspec/core/statement.py

@@ -220,13 +220,20 @@ class SQL:
         if "is_script" in kwargs:
             self._is_script = bool(kwargs.pop("is_script"))
 
-        filters = [p for p in parameters if is_statement_filter(p)]
-        actual_params = [p for p in parameters if not is_statement_filter(p)]
+        # Optimize parameter filtering with direct iteration
+        filters: list[StatementFilter] = []
+        actual_params: list[Any] = []
+        for p in parameters:
+            if is_statement_filter(p):
+                filters.append(p)
+            else:
+                actual_params.append(p)
 
         self._filters.extend(filters)
 
         if actual_params:
-            if len(actual_params) == 1:
+            param_count = len(actual_params)
+            if param_count == 1:
                 param = actual_params[0]
                 if isinstance(param, dict):
                     self._named_parameters.update(param)
@@ -339,10 +346,11 @@ class SQL:
         """Explicitly compile the SQL statement."""
         if self._processed_state is Empty:
             try:
-                current_parameters = self._named_parameters or self._positional_parameters
+                # Avoid unnecessary variable assignment
                 processor = SQLProcessor(self._statement_config)
-
-                compiled_result = processor.compile(self._raw_sql, current_parameters, is_many=self._is_many)
+                compiled_result = processor.compile(
+                    self._raw_sql, self._named_parameters or self._positional_parameters, is_many=self._is_many
+                )
 
                 self._processed_state = ProcessedState(
                     compiled_sql=compiled_result.compiled_sql,
@@ -421,6 +429,7 @@ class SQL:
         Returns:
             New SQL instance with the WHERE condition applied
         """
+        # Parse current SQL with copy=False optimization
         current_expr = None
         with contextlib.suppress(ParseError):
             current_expr = sqlglot.parse_one(self._raw_sql, dialect=self._dialect)
@@ -429,8 +438,11 @@ class SQL:
             try:
                 current_expr = sqlglot.parse_one(self._raw_sql, dialect=self._dialect)
             except ParseError:
-                current_expr = sqlglot.parse_one(f"SELECT * FROM ({self._raw_sql}) AS subquery", dialect=self._dialect)
+                # Use f-string optimization and copy=False
+                subquery_sql = f"SELECT * FROM ({self._raw_sql}) AS subquery"
+                current_expr = sqlglot.parse_one(subquery_sql, dialect=self._dialect)
 
+        # Parse condition with copy=False optimization
         condition_expr: exp.Expression
         if isinstance(condition, str):
             try:
@@ -440,34 +452,32 @@ class SQL:
         else:
             condition_expr = condition
 
+        # Apply WHERE clause
         if isinstance(current_expr, exp.Select) or supports_where(current_expr):
-            new_expr = current_expr.where(condition_expr)
+            new_expr = current_expr.where(condition_expr, copy=False)
         else:
-            new_expr = exp.Select().from_(current_expr).where(condition_expr)
+            new_expr = exp.Select().from_(current_expr).where(condition_expr, copy=False)
 
+        # Generate SQL and create new instance
         new_sql_text = new_expr.sql(dialect=self._dialect)
-
         new_sql = SQL(
             new_sql_text, *self._original_parameters, statement_config=self._statement_config, is_many=self._is_many
         )
-        # Preserve accumulated named parameters when creating WHERE clause
+
+        # Preserve state efficiently
         new_sql._named_parameters.update(self._named_parameters)
         new_sql._positional_parameters = self._positional_parameters.copy()
         new_sql._filters = self._filters.copy()
         return new_sql
 
     def __hash__(self) -> int:
-        """Hash value."""
+        """Hash value with optimized computation."""
         if self._hash is None:
-            self._hash = hash(
-                (
-                    self._raw_sql,
-                    tuple(self._positional_parameters),
-                    tuple(sorted(self._named_parameters.items())),
-                    self._is_many,
-                    self._is_script,
-                )
-            )
+            # Pre-compute tuple components to avoid multiple tuple() calls
+            positional_tuple = tuple(self._positional_parameters)
+            named_tuple = tuple(sorted(self._named_parameters.items())) if self._named_parameters else ()
+
+            self._hash = hash((self._raw_sql, positional_tuple, named_tuple, self._is_many, self._is_script))
         return self._hash
 
     def __eq__(self, other: object) -> bool: