sequel-duckdb 0.1.0 → 0.2.0

data/docs/DUCKDB_SQL_PATTERNS.md

@@ -13,6 +13,7 @@ The sequel-duckdb adapter generates SQL that is optimized for DuckDB's analytica
 The adapter generates clean LIKE clauses without unnecessary ESCAPE clauses, following DuckDB's simplified syntax requirements.
 
 #### Standard LIKE Patterns
+
 ```ruby
 # Sequel Code
 dataset.where(Sequel.like(:name, "%John%"))
@@ -22,6 +23,7 @@ SELECT * FROM users WHERE (name LIKE '%John%')
 ```
 
 #### NOT LIKE Patterns
+
 ```ruby
 # Sequel Code
 dataset.exclude(Sequel.like(:name, "%John%"))
@@ -31,6 +33,7 @@ SELECT * FROM users WHERE (name NOT LIKE '%John%')
 ```
 
 #### Pattern Variations
+
 ```ruby
 # Prefix matching
 dataset.where(Sequel.like(:name, "John%"))
@@ -52,6 +55,7 @@ dataset.where(Sequel.like(:name, "%John%"))
 Since DuckDB doesn't have native ILIKE support, the adapter converts ILIKE operations to UPPER() LIKE UPPER() patterns with proper parentheses.
 
 #### ILIKE Conversion
+
 ```ruby
 # Sequel Code
 dataset.where(Sequel.ilike(:name, "%john%"))
@@ -61,6 +65,7 @@ SELECT * FROM users WHERE (UPPER(name) LIKE UPPER('%john%'))
 ```
 
 #### NOT ILIKE Conversion
+
 ```ruby
 # Sequel Code
 dataset.exclude(Sequel.ilike(:name, "%john%"))
@@ -76,6 +81,7 @@ SELECT * FROM users WHERE (UPPER(name) NOT LIKE UPPER('%john%'))
 The adapter uses DuckDB's `regexp_matches()` function for reliable regex operations, with proper parentheses for expression grouping.
 
 #### Basic Regex Matching
+
 ```ruby
 # Sequel Code
 dataset.where(name: /^John/)
@@ -85,6 +91,7 @@ SELECT * FROM users WHERE (regexp_matches(name, '^John'))
 ```
 
 #### Case-Insensitive Regex
+
 ```ruby
 # Sequel Code
 dataset.where(name: /john/i)
@@ -94,6 +101,7 @@ SELECT * FROM users WHERE (regexp_matches(name, 'john', 'i'))
 ```
 
 #### Complex Regex Patterns
+
 ```ruby
 # Sequel Code
 dataset.where(name: /^John.*Doe$/)
@@ -109,6 +117,7 @@ SELECT * FROM users WHERE (regexp_matches(name, '^John.*Doe$'))
 The adapter uses standard SQL dot notation for qualified column references, ensuring compatibility with SQL standards and DuckDB's expectations.
 
 #### Table.Column Format
+
 ```ruby
 # Sequel Code
 dataset.join(:profiles, user_id: :id)
@@ -118,6 +127,7 @@ SELECT * FROM users INNER JOIN profiles ON (profiles.user_id = users.id)
 ```
 
 #### Subquery Column References
+
 ```ruby
 # Sequel Code
 subquery = db[:orders].select(:count).where(user_id: :users__id)
@@ -134,6 +144,7 @@ SELECT name, (SELECT count FROM orders WHERE (user_id = users.id)) AS order_coun
 The adapter supports all standard JOIN types with proper syntax generation for DuckDB.
 
 #### INNER JOIN
+
 ```ruby
 # Sequel Code
 dataset.join(:profiles, user_id: :id)
@@ -143,6 +154,7 @@ SELECT * FROM users INNER JOIN profiles ON (profiles.user_id = users.id)
 ```
 
 #### LEFT JOIN
+
 ```ruby
 # Sequel Code
 dataset.left_join(:profiles, user_id: :id)
@@ -152,6 +164,7 @@ SELECT * FROM users LEFT JOIN profiles ON (profiles.user_id = users.id)
 ```
 
 #### JOIN USING Clause
+
 ```ruby
 # Sequel Code (using internal JOIN USING clause)
 join_clause = Sequel::SQL::JoinUsingClause.new([:user_id], :inner, :profiles)
@@ -162,6 +175,7 @@ SELECT * FROM users INNER JOIN profiles USING (user_id)
 ```
 
 #### Multiple Column USING
+
 ```ruby
 # Generated SQL for multiple columns
 SELECT * FROM users INNER JOIN profiles USING (user_id, company_id)
@@ -174,6 +188,7 @@ SELECT * FROM users INNER JOIN profiles USING (user_id, company_id)
 The adapter automatically detects recursive CTEs and generates appropriate WITH RECURSIVE syntax.
 
 #### Regular CTE
+
 ```ruby
 # Sequel Code
 cte = db[:users].select(:id, :name).where(active: true)
@@ -184,6 +199,7 @@ WITH active_users AS (SELECT id, name FROM users WHERE (active IS TRUE)) SELECT
 ```
 
 #### Recursive CTE (Auto-detected)
+
 ```ruby
 # Sequel Code
 base_case = db.select(Sequel.as(1, :n))
@@ -202,6 +218,7 @@ WITH RECURSIVE t AS (SELECT 1 AS n UNION ALL SELECT n + 1 FROM t WHERE (n < 10))
 The adapter formats literals according to DuckDB's expectations for optimal type handling.
 
 #### String Literals
+
 ```ruby
 # Sequel Code
 dataset.where(name: "John's Name")
@@ -211,6 +228,7 @@ SELECT * FROM users WHERE (name = 'John''s Name')
 ```
 
 #### Date/Time Literals
+
 ```ruby
 # Date literal
 dataset.where(birth_date: Date.new(2023, 5, 15))
@@ -226,6 +244,7 @@ dataset.where(start_time: Time.local(1970, 1, 1, 9, 30, 0))
 ```
 
 #### Boolean Literals
+
 ```ruby
 # Sequel Code
 dataset.where(active: true)
@@ -235,6 +254,7 @@ SELECT * FROM users WHERE (active IS TRUE)
 ```
 
 #### NULL Literals
+
 ```ruby
 # Sequel Code
 dataset.where(deleted_at: nil)
@@ -250,6 +270,7 @@ SELECT * FROM users WHERE (deleted_at IS NULL)
 The adapter ensures proper parentheses around complex expressions for correct operator precedence and readability.
 
 #### Expression Grouping
+
 ```ruby
 # All complex expressions are wrapped in parentheses
 # LIKE: (name LIKE '%John%')
@@ -266,6 +287,7 @@ The adapter ensures proper parentheses around complex expressions for correct op
 The adapter supports DuckDB's comprehensive window function capabilities.
 
 #### Basic Window Function
+
 ```ruby
 # Sequel Code
 dataset.select(:name, Sequel.function(:row_number).over(order: :name))
@@ -275,6 +297,7 @@ SELECT name, row_number() OVER (ORDER BY name) FROM users
 ```
 
 #### Partitioned Window Function
+
 ```ruby
 # Sequel Code
 dataset.select(
@@ -294,6 +317,7 @@ SELECT product_id, amount, rank() OVER (PARTITION BY category ORDER BY amount DE
 The adapter generates standard aggregate function syntax optimized for DuckDB's columnar storage.
 
 #### Standard Aggregates
+
 ```ruby
 # Sequel Code
 dataset.select(
@@ -311,12 +335,15 @@ SELECT count(*) AS total_count, avg(age) AS avg_age, max(age) AS max_age FROM us
 ## Performance Optimizations
 
 ### 1. Columnar Projection
+
 The adapter optimizes SELECT statements for DuckDB's columnar storage by generating efficient column projections.
 
 ### 2. Parallel Execution Hints
+
 For complex queries, the adapter can include hints for DuckDB's parallel execution engine.
 
 ### 3. Bulk Operations
+
 The adapter uses DuckDB's efficient bulk loading capabilities for multi-insert operations.
 
 ## Error Handling Patterns
@@ -331,6 +358,7 @@ The adapter maps DuckDB errors to appropriate Sequel exception types:
 ## Best Practices for Developers
 
 ### 1. Use Appropriate Data Types
+
 ```ruby
 # Prefer specific types for better performance
 create_table :events do
@@ -344,6 +372,7 @@ end
 ```
 
 ### 2. Leverage DuckDB's Analytical Features
+
 ```ruby
 # Use window functions for analytical queries
 sales_with_rank = db[:sales]
@@ -364,6 +393,7 @@ result = db.with(:monthly, monthly_sales)
 ```
 
 ### 3. Optimize for Columnar Storage
+
 ```ruby
 # Select only needed columns for better performance
 db[:large_table].select(:id, :name, :amount).where(active: true)
@@ -379,32 +409,40 @@ db[:sales].group(:category).select(
 ## Troubleshooting Common Issues
 
 ### 1. LIKE Clause Issues
+
 If LIKE clauses aren't working as expected, ensure you're not expecting ESCAPE clause behavior:
+
 ```ruby
 # Correct - no ESCAPE needed
 dataset.where(Sequel.like(:name, "%John%"))
 ```
 
 ### 2. Case-Insensitive Matching
+
 Use ILIKE for case-insensitive matching:
+
 ```ruby
 # Case-insensitive search
 dataset.where(Sequel.ilike(:name, "%john%"))
 ```
 
 ### 3. Regular Expression Matching
+
 Use Ruby regex syntax for pattern matching:
+
 ```ruby
 # Regex matching
 dataset.where(name: /^John.*Doe$/)
 ```
 
 ### 4. Qualified Column References
+
 Use standard Sequel syntax for qualified columns:
+
 ```ruby
 # Correct qualified reference
 dataset.join(:profiles, user_id: :id)
 # Generates: profiles.user_id = users.id
 ```
 
-This documentation provides a comprehensive reference for understanding and working with the SQL patterns generated by the sequel-duckdb adapter. The patterns are designed to leverage DuckDB's strengths while maintaining compatibility with Sequel's conventions.
+This documentation provides a comprehensive reference for understanding and working with the SQL patterns generated by the sequel-duckdb adapter. The patterns are designed to leverage DuckDB's strengths while maintaining compatibility with Sequel's conventions.

data/docs/TASK_12_VERIFICATION_SUMMARY.md

@@ -7,6 +7,7 @@ Task 12 has been successfully completed. All tests in the sequel-duckdb adapter
 ## Test Results Summary
 
 ### Complete Test Suite Results
+
 - **Total Tests**: 547 runs
 - **Total Assertions**: 42,451 assertions
 - **Failures**: 0
@@ -17,6 +18,7 @@ Task 12 has been successfully completed. All tests in the sequel-duckdb adapter
 ### Key Test Categories Verified
 
 #### 1. SQL Generation Tests (62 tests, 69 assertions)
+
 - All SQL generation patterns produce consistent, standard SQL
 - LIKE clauses generate clean SQL without unnecessary ESCAPE clauses
 - Complex expressions are properly parenthesized
@@ -24,21 +26,25 @@ Task 12 has been successfully completed. All tests in the sequel-duckdb adapter
 - All SQL syntax follows Sequel conventions
 
 #### 2. Dataset Tests (50 tests, 201 assertions)
+
 - Dataset operations work correctly with generated SQL
 - Integration between SQL generation and actual database operations
 - Proper handling of complex queries and data operations
 
 #### 3. Core SQL Generation Tests (56 tests, 56 assertions)
+
 - Basic SQL operations (SELECT, INSERT, UPDATE, DELETE) generate correct syntax
 - Proper handling of data types, literals, and expressions
 - Consistent identifier quoting and escaping
 
 #### 4. Advanced SQL Generation Tests (70 tests, 70 assertions)
+
 - Complex SQL features work correctly (CTEs, window functions, subqueries)
 - JOIN operations including JOIN USING generate proper syntax
 - Recursive CTEs include RECURSIVE keyword when needed
 
 #### 5. Integration Tests (7 tests, 367 assertions)
+
 - End-to-end functionality verification
 - Real database operations work with generated SQL
 - Performance and memory efficiency validation
@@ -48,30 +54,37 @@ Task 12 has been successfully completed. All tests in the sequel-duckdb adapter
 All key SQL patterns that were addressed in previous tasks are working correctly:
 
 ### ✅ LIKE Clause Generation (Requirement 1.1)
+
 - **Generated SQL**: `SELECT * FROM users WHERE (name LIKE '%John%')`
 - **Status**: Clean generation without ESCAPE clause
 
 ### ✅ ILIKE Clause Generation (Requirement 1.3)
+
 - **Generated SQL**: `SELECT * FROM users WHERE (UPPER(name) LIKE UPPER('%john%'))`
 - **Status**: Proper parentheses and UPPER() conversion
 
 ### ✅ Regex Expression Generation (Requirement 2.2)
+
 - **Generated SQL**: `SELECT * FROM users WHERE (name = '^John')`
 - **Status**: Proper parentheses around expressions
 
 ### ✅ Qualified Column References (Requirement 3.1)
+
 - **Generated SQL**: `SELECT * FROM users WHERE (users.id = 1)`
 - **Status**: Standard dot notation for table.column references
 
 ### ✅ Subquery Column References (Requirement 5.1)
+
 - **Generated SQL**: `SELECT * FROM users WHERE (id IN (SELECT user_id FROM posts WHERE (posts.active IS TRUE)))`
 - **Status**: Proper dot notation in subqueries
 
 ### ✅ JOIN USING Generation (Requirement 4.1)
+
 - **Generated SQL**: `SELECT * FROM users INNER JOIN posts USING (user_id)`
 - **Status**: Correct USING clause syntax
 
 ### ✅ Recursive CTE Generation (Requirement 5.1)
+
 - **Generated SQL**: `WITH RECURSIVE tree AS (...)`
 - **Status**: RECURSIVE keyword properly included
 
@@ -119,4 +132,4 @@ The adapter is ready for production use with confidence in its SQL generation re
 - Integration with actual DuckDB database instances
 - Mock database SQL generation patterns
 
-**Task 12 Status: ✅ COMPLETED SUCCESSFULLY**
+**Task 12 Status: ✅ COMPLETED SUCCESSFULLY**

data/justfile

@@ -0,0 +1,52 @@
+test:
+    bundle exec rake test
+
+lint:
+    bundle exec rubocop
+
+ci: fmt-check lint test hygiene
+
+bundle-update *ARGS:
+    bundle update {{ ARGS }}
+
+# CHANGELOG.md is generated by release-please in its own style and rewritten on
+# every release, so the markdown formatter leaves it alone.
+# Rewrite files to canonical format. Run deliberately; never from a hook.
+fmt:
+    git ls-files "*.sh" | xargs -r shfmt -w
+    just --fmt --unstable
+    git ls-files "*.md" ":!:CHANGELOG.md" | xargs -r mdformat
+
+# Report format drift without changing anything. This is what the hooks run —
+# a formatter that rewrites files mid-commit changes what you already reviewed.
+fmt-check:
+    git ls-files "*.sh" | xargs -r shfmt -d
+    just --fmt --check --unstable
+    git ls-files "*.md" ":!:CHANGELOG.md" | xargs -r mdformat --check
+
+# What actually runs before a push. Defaults to the complete `ci`; point it at
+# something smaller ONLY where running complete CI locally is impractical.
+pre-push: ci
+
+# Runs on every commit, so it must stay FAST — a sub-minute budget. Tests belong
+# here when they fit; lint alone when they do not. fmt-check never rewrites.
+pre-commit: fmt-check lint test hygiene
+
+# Content checks inherited from overcommit when it was removed (2026-09-12):
+# MergeConflicts, YamlSyntax, JsonSyntax. RuboCop and the test target were already
+# covered by fmt-check/lint/test; HardTabs and TrailingWhitespace were dropped because
+# they fight shfmt, .tsv, and generated files. See habituate/standards.md.
+hygiene:
+    #!/usr/bin/env bash
+    set -uo pipefail
+    rc=0
+    bad=$(git ls-files | xargs -r grep -IlE '^(<{7}|={7}|>{7})( |$)' 2>/dev/null || true)
+    [ -n "$bad" ] && { echo "merge conflict markers:"; printf '%s\n' "$bad" | sed 's/^/  /'; rc=1; }
+    for f in $(git ls-files '*.yml' '*.yaml'); do
+      python3 -c 'import yaml,sys; yaml.safe_load(open(sys.argv[1]))' "$f" 2>/dev/null \
+        || { echo "invalid YAML: $f"; rc=1; }
+    done
+    for f in $(git ls-files '*.json'); do
+      jq empty "$f" 2>/dev/null || { echo "invalid JSON: $f"; rc=1; }
+    done
+    exit $rc

data/lib/sequel/adapters/duckdb.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "sequel"
+require "duckdb"
 require_relative "shared/duckdb"
 
 # Sequel is a database toolkit for Ruby that provides a powerful ORM and database abstraction layer.
@@ -52,6 +53,140 @@ module Sequel
   #
   # @since 0.1.0
   module DuckDB
+    module DriverDatabaseMethods
+      private
+
+      # Open the DuckDB::Database once during Sequel::Database initialization.
+      # DuckDB's ATTACH/schema state is per-Database, not per-Connection, so all
+      # pool connections must share one Database instance.
+      def adapter_initialize
+        database_path = opts[:database]
+
+        @duckdb_database = if database_path == ":memory:" || database_path.nil?
+                             ::DuckDB::Database.open(":memory:")
+                           else
+                             if database_path.match?(/^[a-zA-Z]/) && !database_path.start_with?(":")
+                               database_path = "/#{database_path}"
+                             end
+                             ::DuckDB::Database.open(database_path)
+                           end
+      rescue ::DuckDB::Error => e
+        raise Sequel::DatabaseConnectionError, "Failed to connect to DuckDB database: #{e.message}"
+      rescue StandardError => e
+        raise Sequel::DatabaseConnectionError, "Unexpected error connecting to DuckDB: #{e.message}"
+      end
+
+      public
+
+      def connect(_server)
+        @duckdb_database.connect
+      rescue ::DuckDB::Error => e
+        raise Sequel::DatabaseConnectionError, "Failed to connect to DuckDB database: #{e.message}"
+      end
+
+      def disconnect_connection(conn)
+        return unless conn
+
+        begin
+          conn.close
+        rescue ::DuckDB::Error # rubocop:disable Lint/SuppressedException -- best-effort cleanup on disconnect
+        end
+      end
+
+      def valid_connection?(conn)
+        return false unless conn
+
+        begin
+          conn.query("SELECT 1")
+          true
+        rescue ::DuckDB::Error
+          false
+        end
+      end
+
+      def execute(sql, opts = OPTS, &)
+        _execute(:select, sql, opts, &)
+      end
+
+      def execute_dui(sql, opts = OPTS)
+        _execute(:update, sql, opts)
+      end
+
+      def execute_insert(sql, opts = OPTS)
+        _execute(:insert, sql, opts)
+      end
+
+      def dataset_class_default
+        Dataset
+      end
+
+      private
+
+      def database_error_classes
+        [::DuckDB::Error]
+      end
+
+      def _execute(type, sql, opts, &block)
+        synchronize(opts[:server]) do |conn|
+          case type
+          when :select
+            execute_select(sql, conn, &block)
+          when :insert, :update
+            log_connection_yield(sql, conn) { conn.query(sql).rows_changed }
+          end
+        end
+      rescue ::DuckDB::Error => e
+        raise_error(e, opts)
+      end
+
+      def execute_select(sql, conn, &block)
+        log_connection_yield(sql, conn) do
+          result = conn.query(sql)
+          yield_rows(result, &block) if block
+          result
+        end
+      end
+
+      def yield_rows(result)
+        columns = result.columns
+        result.each do |row_array|
+          row_hash = {}
+          columns.each_with_index do |column, index|
+            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
+      end
+
+      def result_column_names(result)
+        result.columns.map do |column|
+          column.respond_to?(:name) ? column.name.to_s : column.to_s
+        end
+      end
+    end
+
+    module DriverDatasetMethods
+      def fetch_rows(sql)
+        db.synchronize(opts[:server]) do |conn|
+          result = db.send(:log_connection_yield, sql, conn) { conn.query(sql) }
+
+          col_names = db.send(:result_column_names, result)
+          self.columns = col_names.map { |c| output_identifier(c) }
+
+          result.each do |row_array|
+            row_hash = {}
+            col_names.each_with_index do |col_name, i|
+              row_hash[output_identifier(col_name)] = row_array[i]
+            end
+            yield row_hash
+          end
+        end
+      rescue ::DuckDB::Error => e
+        raise Sequel::DatabaseError, e.message
+      end
+    end
+
     # Database class for DuckDB adapter
     #
     # This class extends Sequel::Database to provide DuckDB-specific functionality.
@@ -86,107 +221,11 @@ module Sequel
     # @since 0.1.0
     class Database < Sequel::Database
       include Sequel::DuckDB::DatabaseMethods
+      include Sequel::DuckDB::DriverDatabaseMethods
 
       # Set the adapter scheme for DuckDB
       # This allows Sequel.connect('duckdb://...') to work
       set_adapter_scheme :duckdb
-
-      # Connect to a DuckDB database
-      #
-      # Creates a connection to either a file-based or in-memory DuckDB database.
-      # This method handles the low-level connection establishment and error handling.
-      #
-      # @param server [Hash] Server configuration options from Sequel
-      # @option server [String] :database Database path or ':memory:' for in-memory database
-      # @option server [Hash] :config DuckDB-specific configuration options
-      # @option server [Boolean] :readonly Whether to open database in read-only mode
-      #
-      # @return [::DuckDB::Connection] Active DuckDB database connection
-      #
-      # @raise [Sequel::DatabaseConnectionError] If connection fails due to:
-      #   - Invalid database path
-      #   - Insufficient permissions
-      #   - DuckDB library errors
-      #   - Configuration errors
-      #
-      # @example Connect to in-memory database
-      #   conn = connect(database: ':memory:')
-      #
-      # @example Connect to file database
-      #   conn = connect(database: '/path/to/database.duckdb')
-      #
-      # @example Connect with configuration
-      #   conn = connect(
-      #     database: '/path/to/database.duckdb',
-      #     config: { memory_limit: '2GB', threads: 4 }
-      #   )
-      #
-      # @see disconnect_connection
-      # @see valid_connection?
-      # @since 0.1.0
-      def connect(server) # rubocop:disable Metrics/MethodLength
-        opts = server_opts(server)
-        database_path = opts[:database]
-
-        begin
-          if database_path == ":memory:" || database_path.nil?
-            # Create in-memory database and return connection
-            db = ::DuckDB::Database.open(":memory:")
-          else
-            # Fix URI parsing issue - add leading slash if missing for absolute paths
-            database_path = "/#{database_path}" if database_path.match?(/^[a-zA-Z]/) && !database_path.start_with?(":")
-
-            # Create file-based database (will create file if it doesn't exist) and return connection
-            db = ::DuckDB::Database.open(database_path)
-          end
-          db.connect
-        rescue ::DuckDB::Error => e
-          raise Sequel::DatabaseConnectionError, "Failed to connect to DuckDB database: #{e.message}"
-        rescue StandardError => e
-          raise Sequel::DatabaseConnectionError, "Unexpected error connecting to DuckDB: #{e.message}"
-        end
-      end
-
-      # Disconnect from a DuckDB database connection
-      #
-      # @param conn [::DuckDB::Connection] The database connection to close
-      # @return [void]
-      def disconnect_connection(conn)
-        return unless conn
-
-        begin
-          conn.close
-        rescue ::DuckDB::Error
-          # Ignore errors during disconnect - connection may already be closed
-        end
-      end
-
-      # Check if a DuckDB connection is valid and open
-      #
-      # @param conn [::DuckDB::Connection] The database connection to check
-      # @return [Boolean] true if connection is valid and open, false otherwise
-      def valid_connection?(conn)
-        return false unless conn
-
-        begin
-          # Try a simple query to check if the connection is still valid
-          conn.query("SELECT 1")
-          true
-        rescue ::DuckDB::Error
-          false
-        end
-      end
-
-      # Return the default dataset class for this database
-      #
-      # This method is called by Sequel to determine which Dataset class
-      # to use when creating new datasets for this database connection.
-      #
-      # @return [Class] The Dataset class to use for this database (always DuckDB::Dataset)
-      # @see Dataset
-      def dataset_class_default
-        Dataset
-      end
     end
 
     # Dataset class for DuckDB adapter
@@ -240,17 +279,7 @@ module Sequel
     # @since 0.1.0
     class Dataset < Sequel::Dataset
       include Sequel::DuckDB::DatasetMethods
+      include Sequel::DuckDB::DriverDatasetMethods
     end
   end
 end
-
-# Register the DuckDB adapter with Sequel
-# This registration allows Sequel.connect("duckdb://...") to automatically
-# use the DuckDB adapter and create DuckDB::Database instances.
-#
-# @example Connection string usage
-#   db = Sequel.connect('duckdb::memory:')
-#   db = Sequel.connect('duckdb:///path/to/database.duckdb')
-#
-# @see Sequel::DuckDB::Database
-Sequel::Database.set_shared_adapter_scheme :duckdb, Sequel::DuckDB