sequel-duckdb 0.1.0 → 0.2.1

data/lib/sequel/adapters/shared/duckdb.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-require "duckdb"
+require_relative "../../../sequel/duckdb"
+require_relative "../../../sequel/duckdb/helpers/pathifier"
+require_relative "../../../sequel/duckdb/helpers/copier"
 
 # Sequel is the database toolkit for Ruby
 module Sequel
@@ -58,185 +60,37 @@ module Sequel
         true
       end
 
-      private
+      # Error classification using DATABASE_ERROR_REGEXPS following SQLite pattern
+      DATABASE_ERROR_REGEXPS = {
+        /NOT NULL constraint failed/i => Sequel::NotNullConstraintViolation,
+        /UNIQUE constraint failed|PRIMARY KEY|duplicate/i => Sequel::UniqueConstraintViolation,
+        /FOREIGN KEY constraint failed/i => Sequel::ForeignKeyConstraintViolation,
+        /CHECK constraint failed/i => Sequel::CheckConstraintViolation,
+        /constraint failed/i => Sequel::ConstraintViolation
+      }.freeze
 
-      # DuckDB doesn't fold unquoted identifiers to uppercase
-      def folds_unquoted_identifiers_to_uppercase?
-        false
+      def database_error_regexps
+        DATABASE_ERROR_REGEXPS
       end
 
-      public
-
-      # Execute SQL statement
+      # Return a dataset that represents a VALUES clause with the given rows.
+      # DuckDB supports standard SQL VALUES syntax like PostgreSQL.
       #
-      # @param sql [String] SQL statement to execute
-      # @param opts [Hash, Array] Options for execution or parameters array
-      # @return [Object] Result of execution
-      def execute(sql, opts = {}, &block)
-        # Handle both old-style (sql, opts) and new-style (sql, params) calls
-        if opts.is_a?(Array)
-          params = opts
-          opts = {}
-        elsif opts.is_a?(Hash)
-          params = opts[:params] || []
-        else
-          # Handle other types (like strings) by treating as empty params
-          params = []
-          opts = {}
-        end
+      #   DB.values([[1, 2], [3, 4]])
+      #   # VALUES ((1, 2), (3, 4))
+      def values(v)
+        raise Error, "Cannot provide an empty array for values" if v.empty?
 
-        synchronize(opts[:server]) do |conn|
-          result = execute_statement(conn, sql, params, opts, &block)
-
-          # For UPDATE/DELETE operations without a block, return the number of affected rows
-          # This is what Sequel models expect
-          if !block && result.is_a?(::DuckDB::Result) \
-            && (sql.strip.upcase.start_with?("UPDATE ") \
-            || sql.strip.upcase.start_with?("DELETE "))
-            return result.rows_changed
-          end
-
-          return result
-        end
-      end
-
-      # Execute INSERT statement
-      #
-      # @param sql [String] INSERT SQL statement
-      # @param opts [Hash] Options for execution
-      # @return [Object] Result of execution
-      def execute_insert(sql, opts = {})
-        execute(sql, opts)
-        # For INSERT statements, we should return the inserted ID if possible
-        # Since DuckDB doesn't support AUTOINCREMENT, we'll return nil for now
-        # This matches the behavior expected by Sequel
-        nil
-      end
-
-      # Execute UPDATE statement
-      #
-      # @param sql [String] UPDATE SQL statement
-      # @param opts [Hash] Options for execution
-      # @return [Object] Result of execution
-      def execute_update(sql, opts = {})
-        result = execute(sql, opts)
-        # For UPDATE/DELETE statements, return the number of affected rows
-        # DuckDB::Result has a rows_changed method for affected row count
-        if result.respond_to?(:rows_changed)
-          result.rows_changed
-        else
-          # Fallback: try to get row count from result
-          result.is_a?(Integer) ? result : 0
-        end
+        @default_dataset.clone(values: v)
       end
 
       private
 
-      # Get database error classes that should be caught and converted to Sequel exceptions
-      #
-      # @return [Array<Class>] Array of DuckDB error classes
-      def database_error_classes
-        [::DuckDB::Error]
-      end
-
-      # Extract SQL state from DuckDB exception if available
-      #
-      # @param _exception [::DuckDB::Error] The DuckDB exception
-      # @param _opts [Hash] Additional options
-      # @return [String, nil] SQL state code or nil if not available
-      def database_exception_sqlstate(_exception, _opts)
-        # DuckDB errors may not always have SQL state codes
-        # This can be enhanced when more detailed error information is available
-        nil
-      end
-
-      # Whether to use SQL states for exception handling
-      #
-      # @return [Boolean] true if SQL states should be used
-      def database_exception_use_sqlstates?
+      # DuckDB doesn't fold unquoted identifiers to uppercase
+      def folds_unquoted_identifiers_to_uppercase?
         false
       end
 
-      # Map DuckDB errors to appropriate Sequel exception types (Requirements 8.1, 8.2, 8.3, 8.7)
-      #
-      # @param exception [::DuckDB::Error] The DuckDB exception
-      # @param _opts [Hash] Additional options
-      # @return [Class] Sequel exception class to use
-      def database_exception_class(exception, _opts)
-        message = exception.message.to_s
-
-        # Map specific DuckDB error patterns to appropriate Sequel exceptions
-        case message
-        when /connection/i, /database.*not.*found/i, /cannot.*open/i
-          # Connection-related errors (Requirement 8.1)
-          Sequel::DatabaseConnectionError
-        when /violates.*not.*null/i, /not.*null.*constraint/i, /null.*value.*not.*allowed/i
-          # NOT NULL constraint violations (Requirement 8.3) - moved up for priority
-          Sequel::NotNullConstraintViolation
-        when /unique.*constraint/i, /duplicate.*key/i, /already.*exists/i,
-           /primary.*key.*constraint/i, /duplicate.*primary.*key/i
-          # UNIQUE and PRIMARY KEY constraint violations (Requirement 8.3)
-          # Primary key violations are a type of unique constraint
-          Sequel::UniqueConstraintViolation
-        when /foreign.*key.*constraint/i, /violates.*foreign.*key/i
-          # Foreign key constraint violations (Requirement 8.3)
-          Sequel::ForeignKeyConstraintViolation
-        when /check.*constraint/i, /violates.*check/i
-          # CHECK constraint violations (Requirement 8.3)
-          Sequel::CheckConstraintViolation
-        when /constraint.*violation/i, /violates.*constraint/i
-          # Generic constraint violations (Requirement 8.3) - moved to end for lower priority
-          Sequel::ConstraintViolation
-        else
-          # when /syntax.*error/i, /parse.*error/i, /unexpected.*token/i,
-          #      /table.*does.*not.*exist/i, /relation.*does.*not.*exist/i,
-          #      /no.*such.*table/i, /column.*does.*not.*exist/i,
-          #      /no.*such.*column/i, /unknown.*column/i,
-          #      /referenced.*column.*not.*found/i,
-          #      /does.*not.*have.*a.*column/i, /schema.*does.*not.*exist/i,
-          #      /no.*such.*schema/i, /function.*does.*not.*exist/i,
-          #      /no.*such.*function/i, /unknown.*function/i, /type.*error/i,
-          #      /cannot.*cast/i, /invalid.*type/i, /permission.*denied/i,
-          #      /access.*denied/i, /insufficient.*privileges/i
-          # Various database errors (Requirements 8.2, 8.7):
-          # - SQL syntax errors
-          # - Table/column/schema/function not found errors
-          # - Type conversion errors
-          # - Permission/access errors
-          Sequel::DatabaseError
-        end
-      end
-
-      # Enhanced error message formatting for better debugging (Requirements 8.2, 8.7)
-      #
-      # @param exception [::DuckDB::Error] The DuckDB exception
-      # @param opts [Hash] Additional options including SQL and parameters
-      # @return [String] Enhanced error message
-      def database_exception_message(exception, opts)
-        message = "DuckDB error: #{exception.message}"
-
-        # Add SQL context if available for better debugging
-        message += " -- SQL: #{opts[:sql]}" if opts[:sql]
-
-        # Add parameter context if available
-        message += " -- Parameters: #{opts[:params].inspect}" if opts[:params] && !opts[:params].empty?
-
-        message
-      end
-
-      # Handle constraint violation errors with specific categorization (Requirement 8.3)
-      #
-      # @param exception [::DuckDB::Error] The DuckDB exception
-      # @param opts [Hash] Additional options
-      # @return [Exception] Appropriate Sequel constraint exception
-      def handle_constraint_violation(exception, opts = {})
-        message = database_exception_message(exception, opts)
-        exception_class = database_exception_class(exception, opts)
-
-        # Create the appropriate exception with enhanced message
-        exception_class.new(message)
-      end
-
       # Schema introspection methods
 
       # Parse table list from database
@@ -244,12 +98,18 @@ module Sequel
       # @param opts [Hash] Options for table parsing
       # @return [Array<Symbol>] Array of table names as symbols
       def schema_parse_tables(opts = {})
-        schema_name = opts[:schema] || "main"
-
-        sql = "SELECT table_name FROM information_schema.tables WHERE table_schema = ? AND table_type = 'BASE TABLE'"
+        schema_ref = opts[:schema] || "main"
+
+        sql = if schema_ref.is_a?(Sequel::SQL::QualifiedIdentifier)
+                "SELECT table_name FROM information_schema.tables " \
+                  "WHERE table_catalog = '#{schema_ref.table}' AND table_schema = '#{schema_ref.column}' AND table_type = 'BASE TABLE'"
+              else
+                "SELECT table_name FROM information_schema.tables " \
+                  "WHERE table_schema = '#{schema_ref}' AND table_type = 'BASE TABLE'"
+              end
 
         tables = []
-        execute(sql, [schema_name]) do |row|
+        execute(sql) do |row|
           tables << row[:table_name].to_sym
         end
 
@@ -279,12 +139,12 @@ module Sequel
             numeric_precision,
             numeric_scale
           FROM information_schema.columns
-          WHERE table_schema = ? AND table_name = ?
+          WHERE table_schema = '#{schema_name}' AND table_name = '#{table_name}'
           ORDER BY ordinal_position
         SQL
 
         columns = []
-        execute(sql, [schema_name, table_name.to_s]) do |row|
+        execute(sql) do |row|
           column_name = row[:column_name].to_sym
 
           # Map DuckDB types to Sequel types
@@ -340,11 +200,11 @@ module Sequel
             expressions,
             sql
           FROM duckdb_indexes()
-          WHERE schema_name = ? AND table_name = ?
+          WHERE schema_name = '#{schema_name}' AND table_name = '#{table_name}'
         SQL
 
         indexes = {}
-        execute(sql, [schema_name, table_name.to_s]) do |row|
+        execute(sql) do |row|
           index_name = row[:index_name].to_sym
 
           # Parse column expressions - DuckDB returns them as JSON array strings
@@ -377,19 +237,12 @@ module Sequel
       #
       # @raise [Sequel::DatabaseError] If the pragma setting is invalid or fails
       #
-      # @example Set memory limit
-      #   db.set_pragma("memory_limit", "2GB")
       #   db.set_pragma(:memory_limit, "1GB")
       #
-      # @example Set thread count
-      #   db.set_pragma("threads", 4)
       #
-      # @example Enable/disable features
-      #   db.set_pragma("enable_progress_bar", true)
       #   db.set_pragma("enable_profiling", false)
       #
       # @see configure_duckdb
-      # @since 0.1.0
       def set_pragma(key, value)
         # Convert key to string for consistency
         pragma_key = key.to_s
@@ -424,22 +277,17 @@ module Sequel
       #
       # @raise [Sequel::DatabaseError] If any pragma setting fails
       #
-      # @example Configure multiple settings
-      #   db.configure_duckdb(
       #     memory_limit: "2GB",
       #     threads: 8,
       #     enable_progress_bar: true,
       #     default_order: "ASC"
       #   )
       #
-      # @example Configure with string keys
-      #   db.configure_duckdb(
       #     "memory_limit" => "1GB",
       #     "threads" => 4
       #   )
       #
       # @see set_pragma
-      # @since 0.1.0
       def configure_duckdb(options = {})
         return if options.empty?
 
@@ -451,16 +299,24 @@ module Sequel
 
       # Check if table exists
       #
-      # @param table_name [Symbol, String] Name of the table
+      # @param table_name [Symbol, String, Sequel::SQL::QualifiedIdentifier] Name of the table
       # @param opts [Hash] Options
       # @return [Boolean] true if table exists
       def table_exists?(table_name, opts = {})
-        schema_name = opts[:schema] || "main"
+        # Handle qualified identifiers (e.g., Sequel[:schema][:table])
+        if table_name.is_a?(Sequel::SQL::QualifiedIdentifier)
+          schema_name = table_name.table.to_s
+          table_name = table_name.column.to_s
+        else
+          schema_name = opts[:schema] || "main"
+          table_name = table_name.to_s
+        end
 
-        sql = "SELECT 1 FROM information_schema.tables WHERE table_schema = ? AND table_name = ? LIMIT 1"
+        sql = "SELECT 1 FROM information_schema.tables " \
+              "WHERE table_schema = '#{schema_name}' AND table_name = '#{table_name}' LIMIT 1"
 
         result = nil
-        execute(sql, [schema_name, table_name.to_s]) do |_row|
+        execute(sql) do |_row|
           result = true
         end
 
@@ -475,15 +331,41 @@ module Sequel
         schema_parse_tables(opts)
       end
 
+      # Get list of views
+      #
+      # @param opts [Hash] Options
+      # @return [Array<Symbol>] Array of view names
+      def views(opts = {})
+        schema_ref = opts[:schema] || "main"
+
+        sql = if schema_ref.is_a?(Sequel::SQL::QualifiedIdentifier)
+                "SELECT table_name FROM information_schema.tables " \
+                  "WHERE table_catalog = '#{schema_ref.table}' AND table_schema = '#{schema_ref.column}' AND table_type = 'VIEW'"
+              else
+                "SELECT table_name FROM information_schema.tables " \
+                  "WHERE table_schema = '#{schema_ref}' AND table_type = 'VIEW'"
+              end
+
+        views = []
+        execute(sql) do |row|
+          views << row[:table_name].to_sym
+        end
+
+        views
+      end
+
       # Get schema information for a table
       #
-      # @param table_name [Symbol, String, Dataset] Name of the table or dataset
+      # @param table_name [Symbol, String, Dataset, QualifiedIdentifier] Name of the table or dataset
       # @param opts [Hash] Options
       # @return [Array<Array>] Schema information
       def schema(table_name, opts = {})
-        # Handle case where Sequel passes a Dataset object instead of table name
-        if table_name.is_a?(Sequel::Dataset)
-          # Extract table name from dataset
+        # Handle qualified identifiers (e.g., Sequel[:schema][:table])
+        if table_name.is_a?(Sequel::SQL::QualifiedIdentifier)
+          opts = opts.merge(schema: table_name.table.to_s)
+          actual_table_name = table_name.column.to_s.to_sym
+        elsif table_name.is_a?(Sequel::Dataset)
+          # Handle case where Sequel passes a Dataset object instead of table name
           if table_name.opts[:from]&.first
             actual_table_name = table_name.opts[:from].first
             # Handle case where table name is wrapped in an identifier
@@ -494,7 +376,6 @@ module Sequel
             raise Sequel::Error, "Cannot determine table name from dataset: #{table_name}" unless sql =~ /FROM\s+(\w+)/i
 
             actual_table_name = ::Regexp.last_match(1).to_sym
-
           end
         else
           actual_table_name = table_name
@@ -596,12 +477,12 @@ module Sequel
             AND tc.table_schema = kcu.table_schema
             AND tc.table_name = kcu.table_name
           WHERE tc.constraint_type = 'PRIMARY KEY'
-            AND tc.table_schema = ?
-            AND tc.table_name = ?
+            AND tc.table_schema = '#{schema_name}'
+            AND tc.table_name = '#{table_name}'
         SQL
 
         primary_key_columns = []
-        execute(sql, [schema_name, table_name.to_s]) do |row|
+        execute(sql) do |row|
           primary_key_columns << row[:column_name].to_sym
         end
 
@@ -629,198 +510,19 @@ module Sequel
 
       public
 
-      # Advanced transaction support methods (Requirements 5.5, 5.6, 5.7)
-
-      # Check if DuckDB supports savepoints for nested transactions
-      #
-      # @return [Boolean] true if savepoints are supported
+      # Transaction support - DuckDB has basic transaction support only
       def supports_savepoints?
-        # DuckDB does not currently support SAVEPOINT/ROLLBACK TO SAVEPOINT syntax
-        # Nested transactions are handled by Sequel's default behavior
         false
       end
 
-      # Check if DuckDB supports the specified transaction isolation level
-      #
-      # @param _level [Symbol] Isolation level (:read_uncommitted, :read_committed, :repeatable_read, :serializable)
-      # @return [Boolean] true if the isolation level is supported
       def supports_transaction_isolation_level?(_level)
-        # DuckDB does not currently support setting transaction isolation levels
-        # It uses a default isolation level similar to READ_COMMITTED
         false
       end
 
-      # Check if DuckDB supports manual transaction control
-      #
-      # @return [Boolean] true if manual transaction control is supported
       def supports_manual_transaction_control?
-        # DuckDB supports BEGIN, COMMIT, and ROLLBACK statements
         true
       end
 
-      # Check if DuckDB supports autocommit control
-      #
-      # @return [Boolean] true if autocommit can be controlled
-      def supports_autocommit_control?
-        # DuckDB has autocommit behavior but limited control over it
-        false
-      end
-
-      # Check if DuckDB supports disabling autocommit
-      #
-      # @return [Boolean] true if autocommit can be disabled
-      def supports_autocommit_disable?
-        # DuckDB doesn't support disabling autocommit mode
-        false
-      end
-
-      # Check if currently in a transaction
-      #
-      # @return [Boolean] true if in a transaction
-      def in_transaction?
-        # Use Sequel's built-in transaction tracking
-        # Sequel tracks transaction state internally
-        @transactions && !@transactions.empty?
-      end
-
-      # Begin a transaction manually
-      # Sequel calls this with (conn, opts) arguments
-      #
-      # @param conn [::DuckDB::Connection] Database connection
-      # @param opts [Hash] Transaction options
-      # @return [void]
-      def begin_transaction(conn, opts = {})
-        if opts[:isolation]
-          isolation_sql = case opts[:isolation]
-                          when :read_uncommitted
-                            "SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED"
-                          when :read_committed
-                            "SET TRANSACTION ISOLATION LEVEL READ COMMITTED"
-                          else
-                            raise Sequel::DatabaseError, "Unsupported isolation level: #{opts[:isolation]}"
-                          end
-          conn.query(isolation_sql)
-        end
-
-        conn.query("BEGIN TRANSACTION")
-      end
-
-      # Commit the current transaction manually
-      # Sequel calls this with (conn, opts) arguments
-      #
-      # @param conn [::DuckDB::Connection] Database connection
-      # @param _opts [Hash] Options
-      # @return [void]
-      def commit_transaction(conn, _opts = {})
-        conn.query("COMMIT")
-      end
-
-      # Rollback the current transaction manually
-      # Sequel calls this with (conn, opts) arguments
-      #
-      # @param conn [::DuckDB::Connection] Database connection
-      # @param _opts [Hash] Options
-      # @return [void]
-      def rollback_transaction(conn, _opts = {})
-        conn.query("ROLLBACK")
-      end
-
-      # Override Sequel's transaction method to support advanced features
-      def transaction(opts = {}, &)
-        # Handle savepoint transactions (nested transactions)
-        return savepoint_transaction(opts, &) if opts[:savepoint] && supports_savepoints?
-
-        # Handle isolation level setting
-        if opts[:isolation] && supports_transaction_isolation_level?(opts[:isolation])
-          return isolation_transaction(
-            opts,
-            &
-          )
-        end
-
-        # Fall back to standard Sequel transaction handling
-        super
-      end
-
-      private
-
-      # Handle savepoint-based nested transactions
-      #
-      # @param opts [Hash] Transaction options
-      # @return [Object] Result of the transaction block
-      def savepoint_transaction(opts = {})
-        # Generate a unique savepoint name
-        savepoint_name = "sp_#{Time.now.to_f.to_s.gsub(".", "_")}"
-
-        synchronize(opts[:server]) do |conn|
-          # Create savepoint
-          conn.query("SAVEPOINT #{savepoint_name}")
-
-          # Execute the block
-          result = yield
-
-          # Release savepoint on success
-          conn.query("RELEASE SAVEPOINT #{savepoint_name}")
-
-          result
-        rescue Sequel::Rollback
-          # Rollback to savepoint on explicit rollback
-          conn.query("ROLLBACK TO SAVEPOINT #{savepoint_name}")
-          conn.query("RELEASE SAVEPOINT #{savepoint_name}")
-          nil
-        rescue StandardError => e
-          # Rollback to savepoint on any other exception
-          begin
-            conn.query("ROLLBACK TO SAVEPOINT #{savepoint_name}")
-            conn.query("RELEASE SAVEPOINT #{savepoint_name}")
-          rescue ::DuckDB::Error
-            # Ignore errors during rollback cleanup
-          end
-          raise e
-        end
-      end
-
-      # Handle transactions with specific isolation levels
-      #
-      # @param opts [Hash] Transaction options including :isolation
-      # @return [Object] Result of the transaction block
-      def isolation_transaction(opts = {})
-        synchronize(opts[:server]) do |conn|
-          # Set isolation level before beginning transaction
-          isolation_sql = case opts[:isolation]
-                          when :read_uncommitted
-                            "SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED"
-                          when :read_committed
-                            "SET TRANSACTION ISOLATION LEVEL READ COMMITTED"
-                          else
-                            raise Sequel::DatabaseError, "Unsupported isolation level: #{opts[:isolation]}"
-                          end
-
-          conn.query(isolation_sql)
-          conn.query("BEGIN TRANSACTION")
-
-          # Execute the block
-          result = yield
-
-          # Commit on success
-          conn.query("COMMIT")
-
-          result
-        rescue Sequel::Rollback
-          # Rollback on explicit rollback
-          conn.query("ROLLBACK")
-          nil
-        rescue StandardError => e
-          # Rollback on any other exception
-          begin
-            conn.query("ROLLBACK")
-          rescue ::DuckDB::Error
-            # Ignore errors during rollback cleanup
-          end
-          raise e
-        end
-      end
-
       # DuckDB-specific schema generation methods
 
       # Generate SQL for primary key column
@@ -896,276 +598,190 @@ module Sequel
         end
       end
 
-      # Execute SQL statement against DuckDB connection
-      #
-      # @param conn [::DuckDB::Connection] Database connection (already connected)
-      # @param sql [String] SQL statement to execute
-      # @param params [Array] Parameters for prepared statement
-      # @param _opts [Hash] Options for execution
-      # @return [Object] Result of execution
-      def execute_statement(conn, sql, params = [], _opts = {})
-        # Log the SQL query with timing information (Requirements 8.4, 8.5)
-        start_time = Time.now
-
-        begin
-          # Log the SQL query before execution
-          log_sql_query(sql, params)
-
-          # Handle parameterized queries
-          if params && !params.empty?
-            # Prepare statement with ? placeholders
-            stmt = conn.prepare(sql)
-
-            # Bind parameters using 1-based indexing
-            params.each_with_index do |param, index|
-              stmt.bind(index + 1, param)
-            end
+      # Schema management methods (Requirements: schema creation, deletion, introspection)
 
-            # Execute the prepared statement
-            result = stmt.execute
-          else
-            # Execute directly without parameters
-            result = conn.query(sql)
-          end
-
-          # Log timing information for the operation
-          end_time = Time.now
-          execution_time = end_time - start_time
-          log_sql_timing(sql, execution_time)
-
-          if block_given?
-            # Get column names from the result
-            columns = result.columns
-
-            # Iterate through each row
-            result.each do |row_array|
-              # Convert array to hash with column names as keys
-              row_hash = {}
-              columns.each_with_index do |column, index|
-                # DuckDB::Column objects have a name method
-                column_name = column.respond_to?(:name) ? column.name : column.to_s
-                row_hash[column_name.to_sym] = row_array[index]
-              end
-              yield row_hash
-            end
-          else
-            result
-          end
-        rescue ::DuckDB::Error => e
-          # Log the error for debugging (Requirement 8.6)
-          end_time = Time.now
-          execution_time = end_time - start_time
-          log_sql_error(sql, params, e, execution_time)
-
-          # Use enhanced error mapping for better exception categorization (Requirements 8.1, 8.2, 8.3, 8.7)
-          error_opts = { sql: sql, params: params }
-          exception_class = database_exception_class(e, error_opts)
-          enhanced_message = database_exception_message(e, error_opts)
-
-          raise exception_class, enhanced_message
-        rescue StandardError => e
-          # Log unexpected errors
-          end_time = Time.now
-          execution_time = end_time - start_time
-          log_sql_error(sql, params, e, execution_time)
-          raise e
-        end
-      end
-
-      # Log SQL query execution (Requirement 8.4)
+      # Create a schema
       #
-      # @param sql [String] SQL statement
-      # @param params [Array] Parameters for the query
-      def log_sql_query(sql, params = [])
-        return unless log_connection_info?
-
-        if params && !params.empty?
-          # Log parameterized query with parameters
-          log_info("SQL Query: #{sql} -- Parameters: #{params.inspect}")
-        else
-          # Log simple query
-          log_info("SQL Query: #{sql}")
-        end
-      end
-
-      # Log SQL query timing information (Requirement 8.5)
+      # @param name [String, Symbol] Schema name
+      # @param opts [Hash] Options
+      # @option opts [Boolean] :if_not_exists Add IF NOT EXISTS clause
+      # @option opts [Boolean] :or_replace Add OR REPLACE clause (mutually exclusive with :if_not_exists)
+      # @return [void]
       #
-      # @param sql [String] SQL statement
-      # @param execution_time [Float] Time taken to execute in seconds
-      def log_sql_timing(sql, execution_time)
-        return unless log_connection_info?
-
-        # Log timing information, highlighting slow operations
-        time_ms = (execution_time * 1000).round(2)
-
-        if execution_time > 1.0 # Log slow operations (> 1 second) as warnings
-          log_warn("SLOW SQL Query (#{time_ms}ms): #{sql}")
-        else
-          log_info("SQL Query completed in #{time_ms}ms")
-        end
-      end
-
-      # Log SQL query errors (Requirement 8.6)
       #
-      # @param sql [String] SQL statement that failed
-      # @param params [Array] Parameters for the query
-      # @param error [Exception] The error that occurred
-      # @param execution_time [Float] Time taken before error
-      def log_sql_error(sql, params, error, execution_time)
-        return unless log_connection_info?
-
-        time_ms = (execution_time * 1000).round(2)
-
-        if params && !params.empty?
-          log_error("SQL Error after #{time_ms}ms: #{error.message} -- SQL: #{sql} -- Parameters: #{params.inspect}")
-        else
-          log_error("SQL Error after #{time_ms}ms: #{error.message} -- SQL: #{sql}")
-        end
-      end
-
-      # Check if connection info should be logged
       #
-      # @return [Boolean] true if logging is enabled
-      def log_connection_info?
-        # Use Sequel's built-in logging mechanism
-        !loggers.empty?
+      def create_schema(name, opts = OPTS)
+        self << create_schema_sql(name, opts)
       end
 
-      # Log info message using Sequel's logging system
+      # Generate SQL for creating a schema
       #
-      # @param message [String] Message to log
-      def log_info(message)
-        log_connection_yield(message, nil) { nil }
+      # @param name [String, Symbol] Schema name
+      # @param opts [Hash] Options
+      # @option opts [Boolean] :if_not_exists Add IF NOT EXISTS clause
+      # @option opts [Boolean] :or_replace Add OR REPLACE clause (mutually exclusive with :if_not_exists)
+      # @return [String] CREATE SCHEMA SQL
+      def create_schema_sql(name, opts = OPTS)
+        # DuckDB doesn't support both OR REPLACE and IF NOT EXISTS together
+        if opts[:or_replace] && opts[:if_not_exists]
+          raise Sequel::Error, "Cannot use both :or_replace and :if_not_exists options"
+        end
+
+        sql = "CREATE"
+        sql += " OR REPLACE" if opts[:or_replace]
+        sql += " SCHEMA"
+        sql += " IF NOT EXISTS" if opts[:if_not_exists]
+        sql += " #{quote_identifier(name)}"
+        sql
       end
 
-      # Log warning message using Sequel's logging system
+      # Drop a schema
+      #
+      # @param name [String, Symbol] Schema name
+      # @param opts [Hash] Options
+      # @option opts [Boolean] :if_exists Add IF EXISTS clause
+      # @option opts [Boolean] :cascade Add CASCADE clause to drop dependent objects
+      # @return [void]
+      #
+      #
       #
-      # @param message [String] Message to log
-      def log_warn(message)
-        log_connection_yield("WARNING: #{message}", nil) { nil }
+      def drop_schema(name, opts = OPTS)
+        self << drop_schema_sql(name, opts)
+        remove_all_cached_schemas
       end
 
-      # Log error message using Sequel's logging system
+      # Generate SQL for dropping a schema
       #
-      # @param message [String] Message to log
-      def log_error(message)
-        log_connection_yield("ERROR: #{message}", nil) { nil }
+      # @param name [String, Symbol] Schema name
+      # @param opts [Hash] Options
+      # @option opts [Boolean] :if_exists Add IF EXISTS clause
+      # @option opts [Boolean] :cascade Add CASCADE clause to drop dependent objects
+      # @return [String] DROP SCHEMA SQL
+      def drop_schema_sql(name, opts = OPTS)
+        sql = "DROP SCHEMA"
+        sql += " IF EXISTS" if opts[:if_exists]
+        sql += " #{quote_identifier(name)}"
+        sql += " CASCADE" if opts[:cascade]
+        sql
       end
 
-      public
-
-      # EXPLAIN functionality access for query plans (Requirement 9.6)
+      # Remove all cached schema information
       #
-      # @param sql [String] SQL query to explain
-      # @return [Array<Hash>] Query plan information
-      def explain_query(sql)
-        explain_sql = "EXPLAIN #{sql}"
-        plan_rows = []
-
-        execute(explain_sql) do |row|
-          plan_rows << row
-        end
-
-        plan_rows
+      # Called after schema modifications to ensure cache consistency
+      #
+      # @return [void]
+      def remove_all_cached_schemas
+        @schema_cache = {}
+        @schemas = {}
+        @primary_keys = {}
+        @primary_key_sequences = {}
       end
 
-      # Get query plan for a SQL statement
+      # List all schemas in the database
+      #
+      # @param opts [Hash] Options
+      # @option opts [String] :catalog Catalog name to filter by
+      # @return [Array<Symbol>] Array of schema names as symbols
       #
-      # @param sql [String] SQL statement to analyze
-      # @return [String] Query plan as string
-      def query_plan(sql)
-        plan_rows = explain_query(sql)
+      def schemas(opts = OPTS)
+        sql = "SELECT schema_name FROM information_schema.schemata"
+        sql += " WHERE catalog_name = '#{opts[:catalog]}'" if opts[:catalog]
 
-        if plan_rows.empty?
-          "No query plan available"
-        else
-          # Format the plan rows into a readable string
-          plan_rows.map { |row| row.values.join(" | ") }.join("\n")
+        schemas = []
+        execute(sql) do |row|
+          schemas << row[:schema_name].to_sym
         end
-      end
 
-      # Check if EXPLAIN functionality is supported
-      #
-      # @return [Boolean] true if EXPLAIN is supported
-      def supports_explain?
-        true # DuckDB supports EXPLAIN
+        schemas
       end
 
-      # Get detailed query analysis information
+      # Check if a schema exists
       #
-      # @param sql [String] SQL statement to analyze
-      # @return [Hash] Analysis information including plan, timing estimates, etc.
-      def analyze_query(sql)
-        {
-          plan: query_plan(sql),
-          explain_output: explain_query(sql),
-          supports_explain: supports_explain?
-        }
-      end
-
-      # DuckDB configuration methods for performance optimization
-
-      # Set DuckDB configuration value
+      # @param name [String, Symbol] Schema name
+      # @param opts [Hash] Options (reserved for future use)
+      # @return [Boolean] true if schema exists
       #
-      # @param key [String] Configuration key
-      # @param value [Object] Configuration value
-      def set_config_value(key, value)
-        synchronize do |conn|
-          # Use PRAGMA for DuckDB configuration
-          conn.query("PRAGMA #{key} = #{value}")
-        end
-      end
+      def schema_exists?(name, _opts = OPTS)
+        sql = "SELECT 1 FROM information_schema.schemata WHERE schema_name = '#{name}' LIMIT 1"
 
-      # Get DuckDB configuration value
-      #
-      # @param key [String] Configuration key
-      # @return [Object] Configuration value
-      def get_config_value(key)
         result = nil
-        synchronize do |conn|
-          # Use PRAGMA to get configuration values
-          conn.query("PRAGMA #{key}") do |row|
-            result = row.values.first
-            break
-          end
+        execute(sql) do |_row|
+          result = true
         end
-        result
+
+        !!result
       end
 
-      # Configure DuckDB for optimal parallel execution
+      # Override create_view_prefix_sql to support DuckDB options
       #
-      # @param thread_count [Integer] Number of threads to use
-      def configure_parallel_execution(thread_count = nil)
-        thread_count ||= [4, cpu_count].min
+      # @param name [Symbol, String] View name
+      # @param options [Hash] View options
+      # @option options [Boolean] :temp Create a TEMPORARY view
+      # @option options [Boolean] :replace Use OR REPLACE
+      # @option options [Array<Symbol>] :columns Column names for the view
+      # @return [String] CREATE VIEW prefix SQL
+      def create_view_prefix_sql(name, options)
+        sql = String.new
+        sql << "CREATE "
+        sql << "OR REPLACE " if options[:replace]
+        sql << "TEMPORARY " if options[:temp]
+        sql << "VIEW #{quote_schema_table(name)}"
+
+        # Add columns if specified
+        if options[:columns]
+          sql << " ("
+          schema_utility_dataset.send(:identifier_list_append, sql, options[:columns])
+          sql << ")"
+        end
 
-        set_config_value("threads", thread_count)
-        set_config_value("enable_optimizer", true)
-        set_config_value("enable_profiling", false) # Disable for performance
+        sql
       end
 
-      # Configure DuckDB for memory-efficient operations
-      #
-      # @param memory_limit [String] Memory limit (e.g., "1GB", "512MB")
-      def configure_memory_optimization(memory_limit = "1GB")
-        set_config_value("memory_limit", "'#{memory_limit}'")
-        set_config_value("temp_directory", "'/tmp'")
+      # Override create_view_sql to handle DuckDB-specific view sources
+      #
+      # @param name [Symbol, String] View name
+      # @param source [String, Dataset, Hash] View source - can be SQL, Dataset, or Hash for parquet files
+      # @param options [Hash] View options
+      # @option options [String] :using Data source type (e.g., "parquet")
+      # @option options [Hash] :options Options for the data source (e.g., path for parquet)
+      # @return [String] CREATE VIEW SQL
+      def create_view_sql(name, source, options = OPTS)
+        options = source if source.is_a?(Hash)
+        some_paths = options[:path] || options[:paths] || options.dig(:options, :path) || options.dig(:options, :paths)
+        # Handle DuckDB-specific source patterns
+        source = if options[:using] || some_paths
+                   # Build read_parquet or similar function call
+                   read_something_sql(some_paths, options).then do |read_stmt|
+                     from(read_stmt)
+                   end.sql
+                 elsif source.is_a?(Dataset)
+                   source.sql
+                 elsif source.is_a?(String)
+                   source
+                 else
+                   raise Sequel::Error, "Unsupported source type: #{source.class}"
+                 end
+
+        sql = String.new
+        sql << "#{create_view_prefix_sql(name, options)} AS #{source}"
+
+        if (check = options[:check])
+          sql << " WITH#{" LOCAL" if check == :local} CHECK OPTION"
+        end
+
+        sql
       end
 
-      # Configure DuckDB for columnar storage optimization
-      def configure_columnar_optimization
-        set_config_value("enable_optimizer", true)
-        set_config_value("enable_profiling", false)
-        set_config_value("enable_progress_bar", false)
+      def copy_to(source, path, options = Sequel::OPTS)
+        Sequel::DuckDB::Helpers::Copier.new(source, path, options).then do |copier|
+          run(copier.to_sql)
+        end
       end
 
       private
 
-      # Get CPU count for parallel execution configuration
-      def cpu_count
-        require "etc"
-        Etc.nprocessors
-      rescue StandardError
-        4 # Default fallback
+      def read_something_sql(paths, options = OPTS)
+        Sequel::DuckDB::Helpers::Pathifier.new(paths, options).to_sql
       end
 
       # Type conversion methods for DuckDB-specific handling
@@ -1236,6 +852,19 @@ module Sequel
         array struct map
       ].freeze
 
+      # DuckDB interval unit mapping for date arithmetic
+      DUCKDB_DURATION_UNITS = {
+        years: "YEAR",
+        months: "MONTH",
+        days: "DAY",
+        hours: "HOUR",
+        minutes: "MINUTE",
+        seconds: "SECOND"
+      }.freeze
+
+      # Override select SQL clause order to support VALUES
+      Dataset.def_sql_method(self, :select, [["if opts[:values]", %w[values compounds order limit]], ["else", %w[with select distinct columns from join where group having compounds order limit lock]]])
+
       private
 
       # DuckDB uses lowercase identifiers
@@ -1262,83 +891,12 @@ module Sequel
         DUCKDB_RESERVED_WORDS.include?(name.to_s.downcase)
       end
 
-      # Generate INSERT SQL statement
-      #
-      # @param values [Hash, Array] Values to insert
-      # @return [String] The INSERT SQL statement
-      def insert_sql(*values)
-        return @opts[:sql] if @opts[:sql]
-
-        # Handle empty values case
-        if values.empty? || (values.length == 1 && values.first.empty?)
-          return "INSERT INTO #{table_name_sql} DEFAULT VALUES"
-        end
-
-        # Handle single hash of values
-        if values.length == 1 && values.first.is_a?(Hash)
-          values_hash = values.first
-          columns = values_hash.keys
-          column_list = literal(columns)
-          values_list = literal(columns.map { |k| values_hash[k] })
-
-          return "INSERT INTO #{table_name_sql} #{column_list} VALUES #{values_list}"
-        end
-
-        # Handle array of hashes (multiple records)
-        if values.length == 1 && values.first.is_a?(Array)
-          records = values.first
-          return "INSERT INTO #{table_name_sql} DEFAULT VALUES" if records.empty?
-
-          first_record = records.first
-          columns = first_record.keys
-          column_list = literal(columns)
-
-          values_lists = records.map do |record|
-            literal(columns.map { |k| record[k] })
-          end
-
-          return "INSERT INTO #{table_name_sql} #{column_list} VALUES #{values_lists.join(", ")}"
-        end
-
-        # Fallback for other cases
-        "INSERT INTO #{table_name_sql} DEFAULT VALUES"
-      end
-
-      # Generate UPDATE SQL statement
-      #
-      # @param values [Hash] Values to update
-      # @return [String] The UPDATE SQL statement
-      def update_sql(values = {})
-        return @opts[:sql] if @opts[:sql]
-
-        sql = "UPDATE #{table_name_sql} SET "
-
-        # Add SET clause
-        set_clauses = values.map do |column, value|
-          col_sql = String.new
-          quote_identifier_append(col_sql, column)
-          "#{col_sql} = #{literal(value)}"
-        end
-        sql << set_clauses.join(", ")
-
-        # Add WHERE clause
-        select_where_sql(sql) if @opts[:where]
-
-        sql
-      end
-
-      # Generate DELETE SQL statement
-      #
-      # @return [String] The DELETE SQL statement
-      def delete_sql
-        return @opts[:sql] if @opts[:sql]
-
-        sql = "DELETE FROM #{table_name_sql}"
-
-        # Add WHERE clause
-        select_where_sql(sql) if @opts[:where]
-
-        sql
+      # DuckDB doesn't support "schema"."table".* syntax.
+      # Strip the schema qualifier so it generates "table".* instead.
+      def column_all_sql_append(sql, ca)
+        table = ca.table
+        table = table.column if table.is_a?(Sequel::SQL::QualifiedIdentifier)
+        qualified_identifier_sql_append(sql, table, Sequel::LiteralString.new("*"))
       end
 
       # DuckDB capability flags
@@ -1358,259 +916,35 @@ module Sequel
         true
       end
 
-      def supports_join_using?
-        true
-      end
-
-      # Validate table name for SELECT operations
-      def validate_table_name_for_select
-        return unless @opts[:from] # Skip if no FROM clause
-
-        @opts[:from].each do |table|
-          if table.nil? || (table.respond_to?(:to_s) && table.to_s.strip.empty?)
-            raise ArgumentError,
-                  "Table name cannot be nil or empty"
-          end
-        end
+      # DuckDB supports multi-row inserts using VALUES syntax
+      # This allows inserting multiple rows in a single INSERT statement
+      def multi_insert_sql_strategy
+        :values
       end
 
-      # Check if a word is a SQL reserved word that needs quoting
-      def reserved_word?(word)
-        %w[order group select from where having limit offset].include?(word.downcase)
+      def supports_join_using?
+        true
       end
 
-      # Get properly quoted table name
-      def table_name_sql
-        raise ArgumentError, "Table name cannot be nil or empty" if @opts[:from].nil? || @opts[:from].empty?
-
-        # Check if the table name is nil
-        table_name = @opts[:from].first
-        raise ArgumentError, "Table name cannot be nil" if table_name.nil?
-
-        table_name = table_name.to_s
-        raise ArgumentError, "Table name cannot be empty" if table_name.empty?
-
-        # Use quote_identifier_append to respect quote_identifiers? setting
-        sql = String.new
-        quote_identifier_append(sql, table_name)
-        sql
+      # DuckDB requires WITH RECURSIVE if any CTE is recursive
+      # This follows the same pattern as PostgreSQL
+      def select_with_sql_base
+        opts[:with].any? { |w| w[:recursive] } ? "WITH RECURSIVE " : "WITH "
       end
 
-      private
-
-      # Override the WITH clause generation to support RECURSIVE keyword
-      def select_with_sql(sql)
-        return unless opts[:with]
-
-        # Check if any WITH clause is recursive (either explicitly marked or auto-detected)
-        has_recursive = opts[:with].any? { |w| w[:recursive] || cte_is_recursive?(w) }
-
-        # Add WITH or WITH RECURSIVE prefix
-        sql << (has_recursive ? "WITH RECURSIVE " : "WITH ")
-
-        # Add each CTE
-        opts[:with].each_with_index do |w, i|
-          sql << ", " if i.positive?
-          name_sql = String.new
-          quote_identifier_append(name_sql, w[:name])
-          sql << "#{name_sql} AS (#{w[:dataset].sql})"
-        end
-
-        sql << " "
+      # Support VALUES clause instead of SELECT to return rows.
+      def select_values_sql(sql)
+        sql << "VALUES "
+        expression_list_append(sql, opts[:values])
       end
 
-      # Auto-detect if a CTE is recursive by analyzing its SQL for self-references
-      #
-      # @param cte_info [Hash] CTE information hash with :name and :dataset
-      # @return [Boolean] true if the CTE appears to be recursive
-      def cte_is_recursive?(cte_info)
-        return false unless cte_info[:dataset]
+      # Return true if this dataset uses a VALUES clause (not a real table query).
+      def empty?
+        return false if @opts[:values]
 
-        cte_name = cte_info[:name].to_s
-        cte_sql = cte_info[:dataset].sql
-
-        # Check if the CTE SQL contains references to its own name
-        # Look for patterns like "FROM table_name" or "JOIN table_name"
-        # Use word boundaries to avoid false positives with partial matches
-        recursive_pattern = /\b(?:FROM|JOIN)\s+#{Regexp.escape(cte_name)}\b/i
-
-        cte_sql.match?(recursive_pattern)
-      end
-
-      public
-
-      # Override select_from_sql to validate table names
-      def select_from_sql(sql)
-        if (f = @opts[:from])
-          # Validate that no table names are nil
-          f.each do |table|
-            raise ArgumentError, "Table name cannot be nil" if table.nil?
-          end
-        end
-
-        # Call parent implementation
         super
       end
 
-      # Add JOIN clauses to SQL (Requirement 6.9)
-      def select_join_sql(sql)
-        return unless @opts[:join]
-
-        @opts[:join].each do |join| # rubocop:disable Metrics/BlockLength
-          # Handle different join clause types
-          case join
-          when Sequel::SQL::JoinOnClause
-            join_type = join.join_type || :inner
-            table = join.table
-            conditions = join.on
-
-            # Format join type
-            join_clause = case join_type
-                          when :left, :left_outer
-                            "LEFT JOIN"
-                          when :right, :right_outer
-                            "RIGHT JOIN"
-                          when :full, :full_outer
-                            "FULL JOIN"
-                          else
-                            # when :inner
-                            "INNER JOIN"
-                          end
-
-            sql << " #{join_clause} "
-
-            # Add table name
-            sql << if table.is_a?(Sequel::Dataset)
-                     alias_sql = String.new
-                     quote_identifier_append(alias_sql, join.table_alias || "subquery")
-                     "(#{table.sql}) AS #{alias_sql}"
-                   else
-                     literal(table)
-                   end
-
-            # Add ON conditions
-            if conditions
-              sql << " ON "
-              literal_append(sql, conditions)
-            end
-
-          when Sequel::SQL::JoinUsingClause
-            join_type = join.join_type || :inner
-            table = join.table
-            using_columns = join.using
-
-            join_clause = case join_type
-                          when :left, :left_outer
-                            "LEFT JOIN"
-                          when :right, :right_outer
-                            "RIGHT JOIN"
-                          when :full, :full_outer
-                            "FULL JOIN"
-                          else
-                            # when :inner
-                            "INNER JOIN"
-                          end
-
-            sql << " #{join_clause} "
-
-            # Handle table with alias
-            sql << if table.is_a?(Sequel::Dataset)
-                     # Subquery with alias
-                     "(#{table.sql})"
-                   else
-                     # Regular table (may have alias)
-                     literal(table)
-                     # Add alias if present
-                   end
-            if join.table_alias
-              sql << " AS "
-              quote_identifier_append(sql, join.table_alias)
-            end
-
-            if using_columns
-              sql << " USING ("
-              Array(using_columns).each_with_index do |col, i|
-                sql << ", " if i.positive?
-                quote_identifier_append(sql, col)
-              end
-              sql << ")"
-            end
-
-          when Sequel::SQL::JoinClause
-            join_type = join.join_type || :inner
-            table = join.table
-
-            join_clause = case join_type
-                          when :cross
-                            "CROSS JOIN"
-                          when :natural
-                            "NATURAL JOIN"
-                          else
-                            "INNER JOIN"
-                          end
-
-            sql << " #{join_clause} "
-            sql << literal(table)
-          end
-        end
-      end
-
-      # Add WHERE clause to SQL (enhanced for complex conditions - Requirement 6.4)
-      def select_where_sql(sql)
-        return unless @opts[:where]
-
-        sql << " WHERE "
-        literal_append(sql, @opts[:where])
-      end
-
-      # Add GROUP BY clause to SQL (Requirement 6.7)
-      def select_group_sql(sql)
-        return unless @opts[:group]
-
-        sql << " GROUP BY "
-        if @opts[:group].is_a?(Array)
-          sql << @opts[:group].map { |col| literal(col) }.join(", ")
-        else
-          literal_append(sql, @opts[:group])
-        end
-      end
-
-      # Add HAVING clause to SQL (Requirement 6.8)
-      def select_having_sql(sql)
-        return unless @opts[:having]
-
-        sql << " HAVING "
-        literal_append(sql, @opts[:having])
-      end
-
-      # Add ORDER BY clause to SQL (enhanced - Requirement 6.5)
-      def select_order_sql(sql)
-        return unless @opts[:order]
-
-        sql << " ORDER BY "
-        sql << if @opts[:order].is_a?(Array)
-                 @opts[:order].map { |col| order_column_sql(col) }.join(", ")
-               else
-                 order_column_sql(@opts[:order])
-               end
-      end
-
-      # Format individual ORDER BY column
-      def order_column_sql(column)
-        case column
-        when Sequel::SQL::OrderedExpression
-          col_sql = literal(column.expression)
-          col_sql << (column.descending ? " DESC" : " ASC")
-          # Check if nulls option exists (may not be available in all Sequel versions)
-          if column.respond_to?(:nulls) && column.nulls
-            col_sql << (column.nulls == :first ? " NULLS FIRST" : " NULLS LAST")
-          end
-          col_sql
-        else
-          literal(column)
-        end
-      end
-
       # DuckDB-specific SQL generation enhancements
 
       # Override complex_expression_sql_append for DuckDB-specific handling
@@ -1666,20 +1000,6 @@ module Sequel
         end
       end
 
-      # Override join method to support USING clause syntax
-      def join(table, expr = nil, options = {})
-        # Handle the case where using parameter is passed
-        if options.is_a?(Hash) && options[:using]
-          using_columns = Array(options[:using])
-          join_type = options[:type] || :inner
-          join_clause = Sequel::SQL::JoinUsingClause.new(using_columns, join_type, table)
-          clone(join: (@opts[:join] || []) + [join_clause])
-        else
-          # Fall back to standard Sequel join behavior
-          super
-        end
-      end
-
       # Override literal methods for DuckDB-specific formatting
       def literal_string_append(sql, string)
         sql << "'" << string.gsub("'", "''") << "'"
@@ -1766,568 +1086,50 @@ module Sequel
         "'#{blob.unpack1("H*")}'"
       end
 
-      # Dataset operation methods (Requirements 6.1, 6.2, 6.3, 9.5)
-
-      # Override all method to ensure proper model instantiation
-      # Sequel's default all method doesn't always apply row_proc correctly
-      def all
-        records = []
-        fetch_rows(select_sql) do |row|
-          # Apply row_proc if it exists (for model instantiation)
-          row_proc = @row_proc || opts[:row_proc]
-          processed_row = row_proc ? row_proc.call(row) : row
-          records << processed_row
-        end
-        records
-      end
-
-      # Insert a record into the dataset's table
-      #
-      # @param values [Hash] Column values to insert
-      # @return [Integer, nil] Number of affected rows (always nil for DuckDB due to no AUTOINCREMENT)
-      def insert(values = {})
-        sql = insert_sql(values)
-        result = db.execute(sql)
-
-        # For DuckDB, we need to return the number of affected rows
-        # Since DuckDB doesn't support AUTOINCREMENT, we return nil for the ID
-        # but we should return 1 to indicate successful insertion
-        if result.is_a?(::DuckDB::Result)
-          # DuckDB::Result doesn't have a direct way to get affected rows for INSERT
-          # For INSERT operations, if no error occurred, assume 1 row was affected
-          1
-        else
-          result
-        end
-      end
-
-      # Update records in the dataset
-      #
-      # @param values [Hash] Column values to update
-      # @return [Integer] Number of affected rows
-      def update(values = {})
-        sql = update_sql(values)
-        # Use execute_update which properly returns the row count
-        db.execute_update(sql)
-      end
-
-      # Delete records from the dataset
-      #
-      # @return [Integer] Number of affected rows
-      def delete
-        sql = delete_sql
-        # Use execute_update which properly returns the row count
-        db.execute_update(sql)
-      end
-
-      # Streaming result support where possible (Requirement 9.5)
-      #
-      # @param sql [String] SQL to execute
-      # @yield [Hash] Block to process each row
-      # @return [Enumerator] If no block given, returns enumerator
-      def stream(sql = select_sql, &)
-        if block_given?
-          # Stream results by processing them one at a time
-          fetch_rows(sql, &)
-        else
-          # Return enumerator for lazy evaluation
-          enum_for(:stream, sql)
-        end
-      end
-
-      # Performance optimization methods (Requirements 9.1, 9.2, 9.3, 9.4)
-      # These methods are public to provide enhanced performance capabilities
-
-      # Optimized fetch_rows method for large result sets (Requirement 9.1)
-      # This method provides efficient row fetching with streaming capabilities
-      # Override the existing fetch_rows method to make it public and optimized
-      def fetch_rows(sql)
-        # Use streaming approach to avoid loading all results into memory at once
-        # This is particularly important for large result sets
-        if block_given?
-          # Get schema information for type conversion
-          table_schema = table_schema_for_conversion
-
-          # Execute with type conversion
-          db.execute(sql) do |row|
-            # Apply type conversion for TIME columns
-            converted_row = convert_row_types(row, table_schema)
-            yield converted_row
-          end
-        else
-          # Return enumerator if no block given (for compatibility)
-          enum_for(:fetch_rows, sql)
-        end
-      end
-
-      private
-
-      # Get table schema information for type conversion
-      def table_schema_for_conversion
-        return nil unless @opts[:from]&.first
-
-        table_name = @opts[:from].first
-        # Handle case where table name is wrapped in an identifier
-        table_name = table_name.value if table_name.respond_to?(:value)
-
-        begin
-          schema_info = db.schema(table_name)
-          schema_hash = {}
-          schema_info.each do |column_name, column_info|
-            schema_hash[column_name] = column_info
-          end
-          schema_hash
-        rescue StandardError
-          # If schema lookup fails, return nil to skip type conversion
-          nil
-        end
-      end
-
-      # Convert row values based on column types
-      def convert_row_types(row, table_schema)
-        return row unless table_schema
-
-        converted_row = {}
-        row.each do |column_name, value|
-          column_info = table_schema[column_name]
-          converted_row[column_name] = if column_info && column_info[:type] == :time && value.is_a?(Time)
-                                         # Convert TIME columns to time-only values
-                                         Time.local(1970, 1, 1, value.hour, value.min, value.sec, value.usec)
-                                       else
-                                         value
-                                       end
-        end
-        converted_row
-      end
-
-      public
-
-      # Enhanced bulk insert optimization (Requirement 9.3)
-      # Override multi_insert to use DuckDB's efficient bulk loading capabilities
-      def multi_insert(columns = nil, &)
-        if columns.is_a?(Array) && !columns.empty? && columns.first.is_a?(Hash)
-          # Handle array of hashes (most common case)
-          bulk_insert_optimized(columns)
-        else
-          # Fall back to standard Sequel behavior for other cases
-          super
-        end
-      end
-
-      # Optimized bulk insert implementation using DuckDB's capabilities
-      def bulk_insert_optimized(rows)
-        return 0 if rows.empty?
-
-        # Get column names from first row
-        columns = rows.first.keys
-
-        # Get table name from opts[:from]
-        table_name = @opts[:from].first
-
-        # Build optimized INSERT statement with VALUES clause
-        # DuckDB handles multiple VALUES efficiently
-        values_placeholders = rows.map { |_| "(#{columns.map { "?" }.join(", ")})" }.join(", ")
-        table_sql = String.new
-        quote_identifier_append(table_sql, table_name)
-        col_list = columns.map do |c|
-          col_sql = String.new
-          quote_identifier_append(col_sql, c)
-          col_sql
-        end.join(", ")
-        sql = "INSERT INTO #{table_sql} (#{col_list}) VALUES #{values_placeholders}"
-
-        # Flatten all row values for parameter binding
-        params = rows.flat_map { |row| columns.map { |col| row[col] } }
-
-        # Execute the bulk insert
-        db.execute(sql, params)
-
-        rows.length
-      end
-
-      # Prepared statement support for performance (Requirement 9.2)
-      # Enhanced prepare method that leverages DuckDB's prepared statement capabilities
-      def prepare(type, name = nil, *values)
-        # Check if DuckDB connection supports prepared statements
-        if db.respond_to?(:prepare_statement)
-          # Use DuckDB's native prepared statement support
-          sql = case type
-                when :select, :all
-                  select_sql
-                when :first
-                  clone(limit: 1).select_sql
-                when :insert
-                  insert_sql(*values)
-                when :update
-                  update_sql(*values)
-                when :delete
-                  delete_sql
-                else
-                  raise ArgumentError, "Unsupported prepared statement type: #{type}"
-                end
-
-          # Create and cache prepared statement
-          prepared_stmt = db.prepare_statement(sql)
-
-          # Return a callable object that executes the prepared statement
-          lambda do |*params|
-            case type
-            when :select, :all
-              prepared_stmt.execute(*params).to_a
-            when :first
-              result = prepared_stmt.execute(*params).first
-              result
-            else
-              prepared_stmt.execute(*params)
-            end
-          end
-        else
-          # Fall back to standard Sequel prepared statement handling
-          super
-        end
-      end
-
-      # Connection pooling optimization (Requirement 9.4)
-      # Enhanced connection management for better performance
-      def with_connection_pooling
-        # Ensure efficient connection reuse
-        db.synchronize do |conn|
-          # Verify connection is still valid before use
-          unless db.valid_connection?(conn)
-            # Reconnect if connection is invalid
-            conn = db.connect(db.opts)
-          end
-
-          yield conn
-        end
-      end
-
-      # Memory-efficient streaming for large result sets (Requirement 9.5)
-      # Enhanced each method with better memory management
-      def each(&)
-        return enum_for(:each) unless block_given?
+      # DuckDB-specific implementation of date arithmetic
+      # This will be called by Sequel's date_arithmetic extension
+      # via the `super` mechanism when the extension is loaded
+      def date_add_sql_append(sql, date_arith)
+        expr = date_arith.expr
+        interval_hash = date_arith.interval
+        cast_type = date_arith.cast_type
 
-        # Use streaming approach to minimize memory usage
-        sql = select_sql
+        # Build expression with chained interval additions
+        result = expr
+        interval_hash.each do |unit, value|
+          sql_unit = DUCKDB_DURATION_UNITS[unit]
+          next unless sql_unit
 
-        # Check if SQL already has LIMIT/OFFSET - if so, don't add batching
-        if sql.match?(/\bLIMIT\b/i) || sql.match?(/\bOFFSET\b/i)
-          # SQL already has LIMIT/OFFSET, execute directly without batching
-          fetch_rows(sql, &)
-          return self
+          # Create interval addition
+          interval = build_interval_literal(value, sql_unit)
+          result = Sequel.+(result, interval)
         end
 
-        # Process results in batches to balance memory usage and performance
-        batch_size = @opts[:stream_batch_size] || 1000
-        offset = 0
+        # Apply cast if specified or default to Time (TIMESTAMP)
+        # Note: DuckDB returns TIMESTAMP when adding intervals to DATE
+        result = Sequel.cast(result, cast_type || Time)
 
-        loop do
-          # Fetch a batch of results
-          batch_sql = "#{sql} LIMIT #{batch_size} OFFSET #{offset}"
-          batch_count = 0
-
-          fetch_rows(batch_sql) do |row|
-            yield row
-            batch_count += 1
-          end
-
-          # Break if we got fewer rows than the batch size (end of results)
-          break if batch_count < batch_size
-
-          offset += batch_size
-        end
-
-        self
-      end
-
-      # Set custom batch size for streaming operations (Requirement 9.5)
-      #
-      # @param size [Integer] Batch size for streaming
-      # @return [Dataset] New dataset with custom batch size
-      def stream_batch_size(size)
-        clone(stream_batch_size: size)
-      end
-
-      # Stream results with memory limit enforcement (Requirement 9.5)
-      #
-      # @param memory_limit [Integer] Maximum memory growth allowed in bytes
-      # @yield [Hash] Block to process each row
-      # @return [Enumerator] If no block given
-      def stream_with_memory_limit(memory_limit, &)
-        return enum_for(:stream_with_memory_limit, memory_limit) unless block_given?
-
-        sql = select_sql
-
-        # Check if SQL already has LIMIT/OFFSET - if so, don't add batching
-        if sql.match?(/\bLIMIT\b/i) || sql.match?(/\bOFFSET\b/i)
-          # SQL already has LIMIT/OFFSET, execute directly without batching
-          fetch_rows(sql, &)
-          return self
-        end
-
-        initial_memory = memory_usage
-        batch_size = @opts[:stream_batch_size] || 500
-        offset = 0
-
-        loop do
-          # Check memory usage before processing batch
-          current_memory = memory_usage
-          memory_growth = current_memory - initial_memory
-
-          # Reduce batch size if memory usage is high
-          batch_size = [batch_size / 2, 100].max if memory_growth > memory_limit * 0.8
-
-          batch_sql = "#{sql} LIMIT #{batch_size} OFFSET #{offset}"
-          batch_count = 0
-
-          fetch_rows(batch_sql) do |row|
-            yield row
-            batch_count += 1
-
-            # Force garbage collection periodically to manage memory
-            GC.start if (batch_count % 100).zero?
-          end
-
-          break if batch_count < batch_size
-
-          offset += batch_size
-        end
-
-        self
-      end
-
-      private
-
-      # Get approximate memory usage for streaming optimization
-      def memory_usage
-        GC.start
-        ObjectSpace.count_objects[:TOTAL] * 40
-      end
-
-      public
-
-      # Optimized count method for DuckDB
-      # Provides fast path for simple COUNT(*) queries on base tables
-      # Falls back to Sequel's implementation for complex scenarios
-      def count(*args, &block)
-        # Only optimize if:
-        # - No arguments or block provided
-        # - No grouping, having, distinct, or where clauses
-        # - Has a from clause with a table
-        if args.empty? && !block && !@opts[:group] && !@opts[:having] &&
-           !@opts[:distinct] && !@opts[:where] && @opts[:from]&.first
-          # Use optimized COUNT(*) for simple cases
-          table_name = @opts[:from].first
-          table_sql = String.new
-          quote_identifier_append(table_sql, table_name)
-          single_value("SELECT COUNT(*) FROM #{table_sql}")
-        else
-          # Fall back to standard Sequel count behavior for complex cases
-          super
-        end
+        literal_append(sql, result)
       end
 
       private
 
-      # Get a single value from a SQL query (used by count)
-      def single_value(sql)
-        value = nil
-        fetch_rows(sql) do |row|
-          value = row.values.first
-          break
-        end
-        value
-      end
-
-      # Helper method to check if bulk operations should be used
-      def should_use_bulk_operations?(row_count)
-        # Use bulk operations for more than 10 rows
-        row_count > 10
-      end
-
-      # Helper method to optimize query execution based on result set size
-      def optimize_for_result_size(sql)
-        # Add DuckDB-specific optimization hints if needed
-        if @opts[:small_result_set]
-          # For small result sets, DuckDB can use different optimization strategies
-        end
-        sql
-      end
-
-      public
-
-      # Index-aware query generation methods (Requirement 9.7)
-
-      # Get query execution plan with index usage information
-      #
-      # @return [String] Query execution plan
-      def explain
-        explain_sql = "EXPLAIN #{select_sql}"
-        plan_text = ""
-
-        fetch_rows(explain_sql) do |row|
-          plan_text += "#{row.values.join(" ")}\n"
-        end
-
-        plan_text
-      end
-
-      # Get detailed query analysis including index usage
-      #
-      # @return [Hash] Analysis information
-      def analyze_query
-        {
-          plan: explain,
-          indexes_used: extract_indexes_from_plan(explain),
-          optimization_hints: generate_optimization_hints
-        }
-      end
-
-      # Override where method to add index-aware optimization hints
-      def where(*cond, &)
-        result = super
-
-        # Add index optimization hints based on WHERE conditions
-        result = result.add_index_hints(cond.first.keys) if cond.length == 1 && cond.first.is_a?(Hash)
-
-        result
-      end
-
-      # Override order method to leverage index optimization
-      def order(*columns)
-        result = super
-
-        # Add index hints for ORDER BY optimization
-        order_columns = columns.map do |col|
-          case col
-          when Sequel::SQL::OrderedExpression
-            col.expression
+      def build_interval_literal(value, unit)
+        # If value is numeric, use direct syntax
+        # If value is expression, wrap in parentheses
+        if value.is_a?(Numeric)
+          # Direct numeric: INTERVAL 5 HOUR or INTERVAL (-5) HOUR for negatives
+          # DuckDB requires parentheses around negative numbers
+          if value.negative?
+            Sequel.lit("INTERVAL (#{value}) #{unit}")
           else
-            col
+            Sequel.lit(["INTERVAL ", " #{unit}"], value)
           end
+        else
+          # Expression: INTERVAL (column_name) HOUR
+          # Note: expressions already include negation from date_sub
+          Sequel.lit(["INTERVAL (", ") #{unit}"], value)
         end
-
-        result.add_index_hints(order_columns)
-      end
-
-      # Add index optimization hints to the dataset
-      #
-      # @param columns [Array] Columns that might benefit from index usage
-      # @return [Dataset] Dataset with index hints
-      def add_index_hints(columns)
-        # Get available indexes for the table
-        table_name = @opts[:from]&.first
-        return self unless table_name
-
-        available_indexes = begin
-          db.indexes(table_name)
-        rescue StandardError
-          {}
-        end
-
-        # Find indexes that match the columns
-        matching_indexes = available_indexes.select do |_index_name, index_info|
-          index_columns = index_info[:columns] || []
-          columns.any? { |col| index_columns.include?(col.to_sym) }
-        end
-
-        # Add index hints to options
-        clone(index_hints: matching_indexes.keys)
-      end
-
-      # Columnar storage optimization methods (Requirement 9.7)
-
-      # Override select method to add columnar optimization
-      def select(*columns)
-        result = super
-
-        # Mark as columnar-optimized if selecting specific columns
-        result = result.clone(columnar_optimized: true) if columns.length.positive? && columns.length < 10
-
-        result
-      end
-
-      # Optimize aggregation queries for columnar storage
-      def group(*columns)
-        result = super
-
-        # Add columnar aggregation optimization hints
-        result.clone(columnar_aggregation: true)
-      end
-
-      # Parallel query execution support (Requirement 9.7)
-
-      # Enable parallel execution for the query
-      #
-      # @param thread_count [Integer] Number of threads to use (optional)
-      # @return [Dataset] Dataset configured for parallel execution
-      def parallel(thread_count = nil)
-        opts = { parallel_execution: true }
-        opts[:parallel_threads] = thread_count if thread_count
-        clone(opts)
-      end
-
-      private
-
-      # Extract index names from query execution plan
-      def extract_indexes_from_plan(plan)
-        indexes = []
-        plan.scan(/idx_\w+|index\s+(\w+)/i) do |match|
-          indexes << (match.is_a?(Array) ? match.first : match)
-        end
-        indexes.compact.uniq
-      end
-
-      # Generate optimization hints based on query structure
-      def generate_optimization_hints
-        hints = []
-
-        # Check for potential index usage
-        hints << "Consider adding indexes on WHERE clause columns" if @opts[:where]
-
-        # Check for ORDER BY optimization
-        hints << "ORDER BY may benefit from index on ordered columns" if @opts[:order]
-
-        # Check for GROUP BY optimization
-        hints << "GROUP BY operations are optimized for columnar storage" if @opts[:group]
-
-        hints
-      end
-
-      # Optimize SQL for columnar projection
-      def optimize_for_columnar_projection(sql)
-        # Add DuckDB-specific hints for columnar projection
-        if @opts[:columnar_optimized]
-          # DuckDB automatically optimizes column access, but we can add hints
-        end
-        sql
-      end
-
-      # Determine if parallel execution should be used
-      def should_use_parallel_execution?
-        # Use parallel execution for:
-        # 1. Explicit parallel requests
-        # 2. Complex aggregations
-        # 3. Large joins
-        # 4. Window functions
-
-        return true if @opts[:parallel_execution]
-        return true if @opts[:group] && @opts[:columnar_aggregation]
-        return true if @opts[:join] && @opts[:join].length > 1
-        return true if sql.downcase.include?("over(")
-
-        false
-      end
-
-      # Add parallel execution hints to SQL
-      def add_parallel_hints(sql)
-        # DuckDB handles parallelization automatically, but we can add configuration
-        if @opts[:parallel_threads]
-          # NOTE: This would require connection-level configuration in practice
-          # For now, we'll rely on DuckDB's automatic parallelization
-        end
-
-        sql
       end
     end
   end