FEAT: BCP implementation in mssql-python driver using rust

mssql_python/cursor.py

@@ -2451,6 +2451,99 @@
         )
         return True
 
+    def _bulkcopy(self, table_name: str, data, **kwargs):
+        """
+        Perform bulk copy operation using Rust-based implementation.
+
+        Args:
+            table_name: Target table name
+            data: Iterable of tuples/lists containing row data
+            **kwargs: Additional options passed to the Rust bulkcopy method
+                - batch_size: Number of rows per batch (default: 1000)
+                - timeout: Timeout in seconds (default: 30)
+                - column_mappings: List of tuples mapping source column index to target column name
+
+        Returns:
+            Dictionary with rows_copied, batch_count, and elapsed_time
+
+        Raises:
+            ImportError: If mssql_py_core is not installed
+            ValueError: If parameters are invalid
+            RuntimeError: If connection string is not available
+        """
+        try:
+            import mssql_py_core
+        except ImportError as exc:
+            raise ImportError(
+                "Bulk copy requires mssql_py_core Rust library. "
+                "Install from BCPRustWheel directory."
+            ) from exc
+
+        # Validate inputs
+        if not table_name or not isinstance(table_name, str):
+            raise ValueError("table_name must be a non-empty string")
+
+        # Extract and validate kwargs with defaults
+        batch_size = kwargs.get("batch_size", 1000)
+        timeout = kwargs.get("timeout", 30)
+
+        if batch_size <= 0:
+            raise ValueError(f"batch_size must be positive, got {batch_size}")
+        if timeout <= 0:
+            raise ValueError(f"timeout must be positive, got {timeout}")
+
+        # Get and parse connection string
+        if not hasattr(self.connection, "connection_str"):
+            raise RuntimeError("Connection string not available for bulk copy")
+
+        params = {
+            k.strip().lower(): v.strip()
+            for pair in self.connection.connection_str.split(";")
+            if "=" in pair
+            for k, v in [pair.split("=", 1)]
+        }
+
+        if not params.get("server"):
+            raise ValueError("SERVER parameter is required in connection string")
+
+        # Build connection context for Rust library
+        trust_cert = params.get("trustservercertificate", "yes").lower() in ("yes", "true")
+        context = {
+            "server": params.get("server", "localhost"),
+            "database": params.get("database", "master"),
+            "user_name": params.get("uid", ""),
+            "password": params.get("pwd", ""),
+            "trust_server_certificate": trust_cert,
+            "encryption": "Optional",
+        }
+
+        logger.debug("Bulk copy connecting to %s/%s", context["server"], context["database"])
+
+        rust_connection = None
+        rust_cursor = None
+        try:
+            rust_connection = mssql_py_core.PyCoreConnection(context)
+            rust_cursor = rust_connection.cursor()
+
+            logger.debug("Bulk copy to '%s' - batch_size=%d", table_name, batch_size)
+            result = rust_cursor.bulkcopy(table_name, iter(data), kwargs=kwargs)
+
+            logger.debug("Bulk copy completed - rows=%d", result.get("rows_copied", 0))
+            return result
+
+        except Exception as e:
+            logger.error("Bulk copy failed: %s - %s", type(e).__name__, str(e))
+            raise
+
+        finally:
+            # Clean up Rust resources
+            for resource in (rust_cursor, rust_connection):
+                if resource and hasattr(resource, "close"):
+                    try:
+                        resource.close()
+                    except Exception:
+                        pass
+
     def __enter__(self):
         """
         Enter the runtime context for the cursor.