chore: update Databricks adapter to version 1.10.15-5 and add SQL binding formatting method

### Description

This commit updates the Databricks adapter version to 1.10.15-5 and introduces a new static method `format_bindings_for_sql` in the `SqlUtils` class. This method formats bindings as SQL literals for safe string substitution in session mode, enhancing SQL injection safety and syntax correctness. Additionally, the `SessionCursorWrapper` class has been updated to utilize this new method for handling bindings during SQL execution. A comprehensive set of unit tests for session mode components has also been added to ensure functionality and correctness.

Author: alexeyegorov

dbt/adapters/databricks/__version__.py

@@ -1 +1 @@
-version = "1.10.15-3"
+version = "1.10.15-5"

dbt/adapters/databricks/handle.py

@@ -288,6 +288,47 @@ def translate_bindings(bindings: Optional[Sequence[Any]]) -> Optional[Sequence[A
             return list(map(lambda x: float(x) if isinstance(x, decimal.Decimal) else x, bindings))
         return None
 
+    @staticmethod
+    def format_bindings_for_sql(bindings: Optional[Sequence[Any]]) -> Optional[Sequence[str]]:
+        """
+        Format bindings as SQL literals for string substitution in session mode.
+        
+        This method properly quotes string values and handles special cases to ensure
+        SQL injection safety and correct SQL syntax. Used when executing SQL via
+        SparkSession.sql() which doesn't support parameterized queries.
+        
+        Args:
+            bindings: Sequence of binding values (strings, numbers, None, etc.)
+            
+        Returns:
+            Sequence of SQL literal strings, or None if bindings is None/empty
+        """
+        if not bindings:
+            return None
+        
+        formatted = []
+        for value in bindings:
+            if value is None:
+                formatted.append("NULL")
+            elif isinstance(value, bool):
+                formatted.append("TRUE" if value else "FALSE")
+            elif isinstance(value, str):
+                # Escape single quotes by doubling them, then wrap in quotes
+                escaped = value.replace("'", "''")
+                formatted.append(f"'{escaped}'")
+            elif isinstance(value, (int, float, decimal.Decimal)):
+                # Numbers don't need quotes
+                if isinstance(value, decimal.Decimal):
+                    formatted.append(str(float(value)))
+                else:
+                    formatted.append(str(value))
+            else:
+                # For other types, convert to string and quote
+                escaped = str(value).replace("'", "''")
+                formatted.append(f"'{escaped}'")
+        
+        return formatted
+
     @staticmethod
     def clean_sql(sql: str) -> str:
         cleaned = sql.strip()

dbt/adapters/databricks/session.py

@@ -50,11 +50,14 @@ def execute(
         """Execute a SQL statement and store the resulting DataFrame."""
         cleaned_sql = SqlUtils.clean_sql(sql)
 
-        # Handle bindings by simple string substitution if provided
+        # Handle bindings by formatting as SQL literals and substituting
+        # This ensures string values are properly quoted (e.g., 'k. A.' instead of k. A.)
         if bindings:
             translated = SqlUtils.translate_bindings(bindings)
             if translated:
-                cleaned_sql = cleaned_sql % tuple(translated)
+                formatted_bindings = SqlUtils.format_bindings_for_sql(translated)
+                if formatted_bindings:
+                    cleaned_sql = cleaned_sql % tuple(formatted_bindings)
 
         logger.debug(f"Session mode executing SQL: {cleaned_sql[:200]}...")
         self._df = self._spark.sql(cleaned_sql)
@@ -165,7 +168,8 @@ def create(
 
         Args:
             catalog: Optional catalog to set as current
-            schema: Optional schema to set as current database
+            schema: Optional schema (not used - dbt uses fully qualified names and
+                    creates schemas during execution)
             session_properties: Optional session configuration properties
 
         Returns:
@@ -246,10 +250,12 @@ def create(
                 # Fall back to USE CATALOG for older Spark versions
                 spark.sql(f"USE CATALOG {catalog}")
 
-        # Set schema/database if provided
-        if schema:
-            spark.catalog.setCurrentDatabase(schema)
-            logger.debug(f"Set current database to: {schema}")
+        # Note: We intentionally do NOT call setCurrentDatabase(schema) here.
+        # The schema from the profile is used as a base/prefix for generated schema names
+        # (e.g., "dbt" -> "dbt_seeds", "dbt_bronze" via generate_schema_name macro).
+        # dbt creates these schemas during execution via CREATE SCHEMA IF NOT EXISTS,
+        # and uses fully qualified names (catalog.schema.table) for all operations.
+        # Setting the current database would fail if the schema doesn't exist yet.
 
         # Apply session properties
         if session_properties: