improve the change and rebase

Author: ptiurin

docsrc/Connecting_and_queries.rst

@@ -469,8 +469,7 @@ Example with FB_NUMERIC parameter style::
     cursor.close()
 
 When ``bulk_insert=True``, the SDK concatenates all INSERT statements into a single batch
-and sends them to the server with the ``merge_prepared_statement_batches=true`` parameter,
-allowing for optimized batch processing.
+and sends them to the server for optimized batch processing.
 
 
 Setting session parameters

src/firebolt/async_db/cursor.py

@@ -46,7 +46,6 @@
 from firebolt.common.row_set.asynchronous.streaming import StreamingAsyncRowSet
 from firebolt.common.statement_formatter import create_statement_formatter
 from firebolt.utils.exception import (
-    ConfigurationError,
     EngineNotRunningError,
     FireboltDatabaseError,
     FireboltError,
@@ -229,11 +228,11 @@ async def _do_execute(
 
         try:
             statement_planner = StatementPlannerFactory.create_planner(
-                paramstyle, self._formatter
+                paramstyle, self._formatter, bulk_insert
             )
 
             plan = statement_planner.create_execution_plan(
-                raw_query, parameters, skip_parsing, async_execution, streaming, bulk_insert
+                raw_query, parameters, skip_parsing, async_execution, streaming
             )
             await self._execute_plan(plan, timeout)
             self._state = CursorState.DONE
@@ -407,8 +406,7 @@ async def executemany(
                 cursor object until it's closed. They can also be removed with
                 `flush_parameters` method call.
             Bulk insert: When bulk_insert=True, multiple INSERT queries are
-                concatenated and sent as a single batch with
-                merge_prepared_statement_batches=true for improved performance.
+                concatenated and sent as a single batch for improved performance.
                 Only supported for INSERT statements.
 
         Args:

src/firebolt/common/cursor/base_cursor.py

@@ -3,13 +3,13 @@
 import logging
 import re
 from types import TracebackType
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Type, Union
+from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
 from httpx import URL, Response
 
 from firebolt.client.auth.base import Auth
 from firebolt.client.client import AsyncClient, Client
-from firebolt.common._types import ParameterType, RawColType, SetParameter
+from firebolt.common._types import RawColType, SetParameter
 from firebolt.common.constants import (
     DISALLOWED_PARAMETER_LIST,
     IMMUTABLE_PARAMETER_LIST,
@@ -27,11 +27,7 @@
     SecureCacheKey,
     _firebolt_cache,
 )
-from firebolt.utils.exception import (
-    ConfigurationError,
-    FireboltError,
-    ProgrammingError,
-)
+from firebolt.utils.exception import ConfigurationError, FireboltError
 from firebolt.utils.util import fix_url_schema
 
 logger = logging.getLogger(__name__)
@@ -240,6 +236,7 @@ def _log_query(query: Union[str, SetParameter]) -> None:
             "aws_key_id|credentials", query, flags=re.IGNORECASE
         ):
             logger.debug(f"Running query: {query}")
+
     @property
     def engine_name(self) -> str:
         """
@@ -320,44 +317,3 @@ def set_cache_record(self, record: ConnectionInfo) -> None:
             self._client.auth.secret,
         )
         _firebolt_cache.set(cache_key, record)
-
-    def _validate_bulk_insert_query(self, query: str) -> None:
-        """Validate that query is an INSERT statement for bulk_insert."""
-        query_normalized = query.lstrip().lower()
-
-        if not query_normalized.startswith("insert"):
-            raise ConfigurationError(
-                "bulk_insert is only supported for INSERT statements"
-            )
-
-        if ";" in query.strip().rstrip(";"):
-            raise ProgrammingError(
-                "bulk_insert does not support multi-statement queries"
-            )
-
-    def _prepare_bulk_insert(
-        self, query: str, parameters_seq: Sequence[Sequence[ParameterType]]
-    ) -> tuple[str, Sequence[Sequence[ParameterType]]]:
-        """Execute multiple INSERT queries as a single batch."""
-        self._validate_bulk_insert_query(query)
-
-        if not parameters_seq:
-            raise ProgrammingError("bulk_insert requires at least one parameter set")
-
-        # For bulk insert, we need to create unique parameter names for each INSERT
-        # Example: ($1, $2); ($3, $4); ($5, $6) instead of ($1, $2); ($1, $2); ($1, $2)
-        queries = []
-        param_offset = 0
-        for param_set in parameters_seq:
-            # Replace parameter placeholders with unique numbers
-            modified_query = query
-            for i in range(len(param_set)):
-                old_param = f"${i + 1}"
-                new_param = f"${param_offset + i + 1}"
-                modified_query = modified_query.replace(old_param, new_param)
-            queries.append(modified_query)
-            param_offset += len(param_set)
-
-        combined_query = "; ".join(queries)
-        parameters = [param for param_set in parameters_seq for param in param_set]
-        return combined_query, [parameters]