activerecord-duckdb 0.1.0 → 0.1.1

data/gemfiles/rails_8.1.gemfile.lock

@@ -0,0 +1,197 @@
+PATH
+  remote: ..
+  specs:
+    activerecord-duckdb (0.1.0)
+      activerecord (>= 7.0.0)
+      duckdb (>= 1.3, < 2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (8.1.2)
+      activesupport (= 8.1.2)
+    activerecord (8.1.2)
+      activemodel (= 8.1.2)
+      activesupport (= 8.1.2)
+      timeout (>= 0.4.0)
+    activesupport (8.1.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      json
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    appraisal (2.5.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    ast (2.4.3)
+    base64 (0.3.0)
+    bigdecimal (4.0.1)
+    commander (5.0.0)
+      highline (~> 3.0.0)
+    concurrent-ruby (1.3.6)
+    connection_pool (3.0.2)
+    date (3.5.1)
+    debug (1.11.1)
+      irb (~> 1.10)
+      reline (>= 0.3.8)
+    diff-lcs (1.6.2)
+    docile (1.4.1)
+    drb (2.2.3)
+    duckdb (1.4.3.0)
+      bigdecimal (>= 3.1.4)
+    erb (6.0.1)
+    fasterer (0.11.0)
+      ruby_parser (>= 3.19.1)
+    fuubar (2.5.1)
+      rspec-core (~> 3.0)
+      ruby-progressbar (~> 1.4)
+    highline (3.0.1)
+    i18n (1.14.8)
+      concurrent-ruby (~> 1.0)
+    io-console (0.8.2)
+    irb (1.16.0)
+      pp (>= 0.6.0)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    json (2.18.0)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    minitest (6.0.1)
+      prism (~> 1.5)
+    parallel (1.27.0)
+    parlour (9.1.2)
+      commander (~> 5.0)
+      parser
+      rainbow (~> 3.0)
+      sorbet-runtime (>= 0.5)
+    parser (3.3.10.0)
+      ast (~> 2.4.1)
+      racc
+    pp (0.6.3)
+      prettyprint
+    prettyprint (0.2.0)
+    prism (1.8.0)
+    psych (5.3.1)
+      date
+      stringio
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.3.1)
+    rbs (3.10.2)
+      logger
+    rdoc (7.1.0)
+      erb
+      psych (>= 4.0.0)
+      tsort
+    regexp_parser (2.11.3)
+    reline (0.6.3)
+      io-console (~> 0.5)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.7)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.6)
+    rubocop (1.82.1)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.48.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-performance (1.26.1)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.75.0, < 2.0)
+      rubocop-ast (>= 1.47.1, < 2.0)
+    rubocop-rake (0.7.1)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.72.1)
+    rubocop-rspec (3.9.0)
+      lint_roller (~> 1.1)
+      rubocop (~> 1.81)
+    rubocop-thread_safety (0.7.3)
+      lint_roller (~> 1.1)
+      rubocop (~> 1.72, >= 1.72.1)
+      rubocop-ast (>= 1.44.0, < 2.0)
+    ruby-progressbar (1.13.0)
+    ruby_parser (3.22.0)
+      racc (~> 1.5)
+      sexp_processor (~> 4.16)
+    securerandom (0.4.1)
+    sexp_processor (4.17.5)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.13.2)
+    simplecov-tailwindcss (2.3.0)
+      simplecov (~> 0.16)
+    simplecov_json_formatter (0.1.4)
+    sorbet-runtime (0.6.12885)
+    sord (7.1.0)
+      commander (~> 5.0)
+      parlour (~> 9.1)
+      parser
+      rbs (>= 3.0, < 5)
+      sorbet-runtime
+      yard
+    stringio (3.2.0)
+    thor (1.5.0)
+    timeout (0.6.0)
+    tsort (0.2.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+    uri (1.1.1)
+    yard (0.9.38)
+
+PLATFORMS
+  arm64-darwin-23
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 8.1.0)
+  activerecord-duckdb!
+  appraisal
+  debug
+  fasterer
+  fuubar
+  irb
+  rake (~> 13.0)
+  rspec (~> 3.13)
+  rubocop (~> 1.76)
+  rubocop-performance (~> 1.25)
+  rubocop-rake (~> 0.7)
+  rubocop-rspec (~> 3.6)
+  rubocop-thread_safety
+  simplecov
+  simplecov-tailwindcss
+  sord
+
+BUNDLED WITH
+   2.6.9

data/lib/active_record/connection_adapters/duckdb/database_statements.rb

@@ -5,64 +5,71 @@ module ActiveRecord
   module ConnectionAdapters
     module Duckdb
       module DatabaseStatements
-        # Determines if a SQL query is a write operation
-        # @param _sql [String] The SQL query to check (unused in DuckDB implementation)
-        # @return [Boolean] always returns false for DuckDB
-        def write_query?(_sql)
-          false
+        # SQL statements that are considered read-only (SELECT, EXPLAIN, etc.)
+        READ_QUERY_PATTERN = /\A\s*(SELECT|SHOW|DESCRIBE|EXPLAIN|PRAGMA)\b/i
+
+        # Begins a database transaction.
+        # @return [void]
+        def begin_db_transaction
+          log('BEGIN', 'TRANSACTION') do
+            with_raw_connection do |conn|
+              conn.query('BEGIN TRANSACTION')
+            end
+          end
         end
 
-        # Executes a SQL statement against the DuckDB database
+        # Commits the current database transaction.
+        # @return [void]
+        def commit_db_transaction
+          log('COMMIT', 'TRANSACTION') do
+            with_raw_connection do |conn|
+              conn.query('COMMIT')
+            end
+          end
+        end
+
+        # Rolls back the current database transaction.
+        # @return [void]
+        def exec_rollback_db_transaction
+          log('ROLLBACK', 'TRANSACTION') do
+            with_raw_connection do |conn|
+              conn.query('ROLLBACK')
+            end
+          end
+        end
+
+        # Determines if a SQL query is a write operation (INSERT, UPDATE, DELETE, etc.)
+        # Used for read replica support and transaction tracking.
+        # @param sql [String] The SQL query to check
+        # @return [Boolean] true if the query modifies data
+        def write_query?(sql)
+          !READ_QUERY_PATTERN.match?(sql)
+        end
+
+        # Executes a SQL statement against the DuckDB database.
+        # Used for DDL and raw SQL execution.
         # @param sql [String] The SQL statement to execute
         # @param name [String, nil] Optional name for logging purposes
         # @return [DuckDB::Result] The result of the query execution
         def execute(sql, name = nil) # :nodoc:
-          # In case a query is being executed before the connection is open, reconnect.
-          reconnect unless raw_connection
+          # Check for write queries on read-only connections (replica support)
+          # Rails 8.1+ uses ensure_writes_are_allowed, earlier versions use check_if_write_query
+          ensure_write_query_allowed(sql)
 
           log(sql, name) do
-            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-              raw_connection.query(sql)
+            with_raw_connection do |conn|
+              conn.query(sql)
             end
           end
         end
 
-        # Performs a query with optional bind parameters
-        # @param raw_connection [DuckDB::Connection] The raw database connection
-        # @param sql [String] The SQL query to execute
-        # @param binds [Array] Array of bind parameters
-        # @param type_casted_binds [Array] Type-casted bind parameters
-        # @param prepare [Boolean] Whether to prepare the statement (unused)
-        # @param notification_payload [Hash, nil] Payload for notifications (unused)
-        # @param batch [Boolean] Whether this is a batch operation (unused)
-        # @param async [Boolean] Whether to execute asynchronously (unused)
-        # @param kwargs [Hash] Additional keyword arguments
-        # @return [DuckDB::Result] The query result
-        def perform_query(raw_connection,
-                          sql,
-                          binds,
-                          type_casted_binds,
-                          prepare: false,
-                          notification_payload: nil,
-                          batch: false,
-                          async: false,
-                          **kwargs)
-          result = if binds.any?
-                     # Use the modern parameter binding approach
-                     exec_query_with_binds(sql, binds)
-                   else
-                     # Fallback to direct execution with quoted values
-                     # Your existing quote method will handle any unquoted values
-                     raw_connection.query(sql)
-                   end
-          result
-        end
-
-        # Casts a DuckDB result to ActiveRecord::Result format
+        # Casts a DuckDB result to ActiveRecord::Result format.
+        # Used by Rails 8.0+ internal_exec_query which calls cast_result(raw_execute(...)).
+        # Also called by Rails 7.2's internal_exec_query implementation in DatabaseStatementsRails72.
         # @param result [DuckDB::Result, nil] The DuckDB result to cast
         # @return [ActiveRecord::Result] The ActiveRecord-compatible result
         def cast_result(result)
-          return ActiveRecord::Result.empty(affected_rows: @affected_rows_before_warnings) if result.nil?
+          return ActiveRecord::Result.empty if result.nil?
 
           columns = result.columns.map do |col|
             if col.respond_to?(:name)
@@ -77,72 +84,13 @@ module ActiveRecord
           ActiveRecord::Result.new(columns, result.to_a)
         end
 
-        # Executes a query and returns an ActiveRecord::Result
-        # @param sql [String] The SQL query to execute
-        # @param name [String, nil] Optional name for logging
-        # @param binds [Array] Array of bind parameters
-        # @param prepare [Boolean] Whether to prepare the statement (unused)
-        # @return [ActiveRecord::Result] The query result
-        def exec_query(sql, name = nil, binds = [], prepare: false)
-          reconnect unless raw_connection
-
-          log(sql, name, binds) do
-            result = if binds.any?
-                       # Use the modern parameter binding approach
-                       exec_query_with_binds(sql, binds)
-                     else
-                       # Fallback to direct execution with quoted values
-                       # Your existing quote method will handle any unquoted values
-                       raw_connection.query(sql)
-                     end
-
-            build_result(result)
-          end
-        end
-
-        # Executes a DELETE statement and returns the number of affected rows
-        # @param sql [String] The DELETE SQL statement
-        # @param name [String, nil] Optional name for logging
-        # @param binds [Array] Array of bind parameters
-        # @return [Integer] Number of rows affected by the delete
-        def exec_delete(sql, name = nil, binds = []) # :nodoc:
-          reconnect unless raw_connection
-
-          if binds.any?
-            # For bound queries, handle them with proper logging
-            log(sql, name, binds) do
-              bind_values = binds.map(&:value_for_database)
-              raw_connection.query(sql, *bind_values)
-            end.rows_changed
-          else
-            # For non-bound queries, use execute directly
-            result = execute(sql, name)
-            result.rows_changed
-          end
-        end
-        alias exec_update exec_delete
-
-        # Executes an INSERT statement with optional RETURNING clause
-        # @param sql [String] The INSERT SQL statement
-        # @param name [String, nil] Optional name for logging
-        # @param binds [Array] Array of bind parameters
-        # @param pk [String, nil] Primary key column name
-        # @param sequence_name [String, nil] Sequence name (unused)
-        # @param returning [Array, nil] Columns to return after insert
-        # @return [ActiveRecord::Result] The insert result with returned values
-        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil)
-          # Rails 8 will pass returning: [pk] when it wants the ID back
-          if returning&.any?
-            returning_columns = returning.map { |c| quote_column_name(c) }.join(', ')
-            sql = "#{sql} RETURNING #{returning_columns}" unless sql.include?('RETURNING')
-          elsif pk && !sql.include?('RETURNING')
-            # Add RETURNING for the primary key
-            sql = "#{sql} RETURNING #{quote_column_name(pk)}"
-          end
-
-          # Execute the query and return the result
-          # Rails 8 will handle extracting the ID from the result
-          exec_query(sql, name, binds)
+        # Returns the number of affected rows from a raw DuckDB result.
+        # Required by Rails 8.0+ for exec_delete/exec_update via internal_execute.
+        # The base class calls affected_rows(raw_execute(...)) for DELETE/UPDATE operations.
+        # @param raw_result [DuckDB::Result] The raw DuckDB result
+        # @return [Integer] Number of rows affected
+        def affected_rows(raw_result)
+          raw_result.rows_changed
         end
 
         # Returns columns that should be included in INSERT statements
@@ -176,88 +124,21 @@ module ActiveRecord
           super
         end
 
-        # Builds an ActiveRecord::Result from a DuckDB result
-        # @param result [DuckDB::Result, nil] The DuckDB result to convert
-        # @return [ActiveRecord::Result] The converted ActiveRecord result
-        def build_result(result)
-          # Handle DuckDB result format
-          return ActiveRecord::Result.empty if result.nil?
-
-          # DuckDB results have .columns and .to_a, not .rows
-          columns = result.columns.map do |col|
-            if col.respond_to?(:name)
-              col.name
-            elsif col.respond_to?(:column_name)
-              col.column_name
-            else
-              col.to_s
-            end
-          end
-
-          rows = result.to_a
-          ActiveRecord::Result.new(columns, rows)
-        end
-
-        # Fetches type metadata for a SQL type string
-        # @param sql_type [String] The SQL type to get metadata for
-        # @return [ActiveRecord::ConnectionAdapters::SqlTypeMetadata] The type metadata
-        def fetch_type_metadata(sql_type)
-          # Parse DuckDB types and map to Rails types
-          type, limit, precision, scale = parse_type_info(sql_type)
-
-          ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(
-            sql_type: sql_type,
-            type: type.to_sym,
-            limit: limit,
-            precision: precision,
-            scale: scale
-          )
-        end
-
         private
 
-        # Executes a query with bind parameters using positional parameters
-        # @param sql [String] The SQL query with bind placeholders
-        # @param binds [Array] Array of bind parameters
-        # @return [DuckDB::Result] The query result
-        def exec_query_with_binds(sql, binds)
-          # For DuckDB, use positional parameters instead of named parameters
-          bind_values = binds.map do |bind|
-            if bind.respond_to?(:value_for_database)
-              bind.value_for_database
-            elsif bind.is_a?(Symbol)
-              bind.to_s
-            else
-              bind
-            end
-          end
-          raw_connection.query(sql, *bind_values)
-        end
-
-        # Parses SQL type information to extract Rails type, limit, precision, and scale
-        # @param sql_type [String] The SQL type string to parse
-        # @return [Array] Array containing [type, limit, precision, scale]
-        def parse_type_info(sql_type)
-          case sql_type.to_s.upcase
-          when /^INTEGER(\((\d+),(\d+)\))?/i
-            precision, scale = ::Regexp.last_match(2)&.to_i, ::Regexp.last_match(3)&.to_i
-            [:integer, nil, precision, scale]
-          when /^VARCHAR(\((\d+)\))?/i, /^TEXT/i
-            limit = ::Regexp.last_match(2)&.to_i
-            [:string, limit, nil, nil]
-          when /^DOUBLE/i, /^REAL/i
-            [:float, nil, nil, nil]
-          when /^BOOLEAN/i
-            [:boolean, nil, nil, nil]
-          when /^DATE$/i
-            [:date, nil, nil, nil]
-          when /^TIMESTAMP/i, /^DATETIME/i
-            [:datetime, nil, nil, nil]
-          when /^DECIMAL(\((\d+),(\d+)\))?/i, /^NUMERIC(\((\d+),(\d+)\))?/i
-            precision, scale = ::Regexp.last_match(2)&.to_i, ::Regexp.last_match(3)&.to_i
-            [:decimal, nil, precision, scale]
+        # Ensures write queries are allowed on the current connection.
+        # Handles API differences between Rails versions:
+        # - Rails 8.1+: Uses ensure_writes_are_allowed
+        # - Rails 7.2-8.0: Uses check_if_write_query + mark_transaction_written_if_write
+        # @param sql [String] The SQL query to check
+        def ensure_write_query_allowed(sql)
+          if respond_to?(:ensure_writes_are_allowed, true)
+            # Rails 8.1+
+            ensure_writes_are_allowed(sql)
           else
-            [:string, nil, nil, nil] # Default fallback
+            # Rails 7.2-8.0
+            check_if_write_query(sql)
+            mark_transaction_written_if_write(sql)
           end
         end
 
@@ -284,19 +165,6 @@ module ActiveRecord
             default
           end
         end
-
-        # Substitutes bind parameters in SQL with quoted values
-        # @param sql [String] The SQL string with bind placeholders
-        # @param binds [Array] Array of bind parameters
-        # @return [String] SQL with substituted values
-        def substitute_binds(sql, binds)
-          bind_index = 0
-          sql.gsub('?') do
-            value = quote(binds[bind_index].value)
-            bind_index += 1
-            value
-          end
-        end
       end
     end
   end

data/lib/active_record/connection_adapters/duckdb/database_statements_rails72.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Rails 7.2 specific database statements.
+# In Rails 7.2, the base class internal_exec_query raises NotImplementedError,
+# so we must provide a complete implementation.
+module ActiveRecord
+  module ConnectionAdapters
+    module Duckdb
+      module DatabaseStatementsRails72
+        # Executes a query and returns an ActiveRecord::Result.
+        # Required for Rails 7.2 where the base class raises NotImplementedError.
+        #
+        # @param sql [String] The SQL query to execute
+        # @param name [String] Query name for logging
+        # @param binds [Array] Array of bind parameters
+        # @param prepare [Boolean] Whether to prepare the statement (unused - DuckDB doesn't cache)
+        # @param async [Boolean] Whether to execute asynchronously (unused)
+        # @param allow_retry [Boolean] Whether to allow retrying on failure
+        # @return [ActiveRecord::Result] The query result
+        def internal_exec_query(sql, name = 'SQL', binds = [], prepare: false, async: false, allow_retry: false)
+          # Check for write queries on read-only connections (replica support)
+          ensure_write_query_allowed(sql)
+
+          casted_binds = type_casted_binds(binds)
+
+          log(sql, name, binds, casted_binds, async:) do
+            with_raw_connection(allow_retry:) do |conn|
+              result = if casted_binds.empty?
+                         conn.query(sql)
+                       else
+                         conn.query(sql, *casted_binds)
+                       end
+              cast_result(result)
+            end
+          end
+        end
+
+        # Executes a DELETE statement and returns the number of affected rows.
+        # Rails 7.2's base class returns ActiveRecord::Result, but we need an integer.
+        # DuckDB's DELETE returns the count in the result set as rows[0][0].
+        # @param sql [String] The DELETE SQL statement
+        # @param name [String, nil] Optional name for logging
+        # @param binds [Array] Array of bind parameters
+        # @return [Integer] Number of rows affected by the delete
+        def exec_delete(sql, name = nil, binds = [])
+          result = internal_exec_query(sql, name, binds)
+          result.rows.first&.first || 0
+        end
+        alias exec_update exec_delete
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/duckdb/database_statements_rails8.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Rails 8.0+ specific database statements.
+# In Rails 8.0+, the base class internal_exec_query delegates to raw_execute + cast_result,
+# so we implement raw_execute and let Rails handle the rest.
+# This allows Rails' built-in query execution infrastructure (logging, retries, etc.) to work.
+module ActiveRecord
+  module ConnectionAdapters
+    module Duckdb
+      module DatabaseStatementsRails8
+        # Executes raw SQL and returns the native DuckDB result.
+        # Called by Rails 8's internal_execute → raw_execute chain.
+        #
+        # @param sql [String] The SQL query to execute
+        # @param name [String] Query name for logging
+        # @param binds [Array] Array of bind parameters
+        # @param prepare [Boolean] Whether to use prepared statement (unused by DuckDB)
+        # @param async [Boolean] Whether to execute asynchronously (unused by DuckDB)
+        # @param allow_retry [Boolean] Whether to allow retrying on failure
+        # @param materialize_transactions [Boolean] Whether to materialize transactions
+        # @param batch [Boolean] Whether this is a batch operation (unused by DuckDB)
+        # @return [DuckDB::Result] The raw DuckDB result
+        def raw_execute(sql, name = nil, binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true, batch: false)
+          casted_binds = type_casted_binds(binds)
+
+          log(sql, name, binds, casted_binds, async: async) do
+            with_raw_connection(allow_retry:, materialize_transactions:) do |conn|
+              if casted_binds.empty?
+                conn.query(sql)
+              else
+                conn.query(sql, *casted_binds)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/duckdb/schema_definitions.rb

@@ -58,7 +58,11 @@ module ActiveRecord
         # @example Create an address struct
         #   t.struct :address, fields: { street: :string, city: :string, zip: :integer }
         def struct(name, fields: {}, **)
-          field_definitions = fields.map { |field_name, field_type| "#{field_name} #{field_type.to_s.upcase}" }
+          # Quote field names as identifiers and validate field types
+          field_definitions = fields.map do |field_name, field_type|
+            quoted_name = %("#{field_name.to_s.gsub('"', '""')}")
+            "#{quoted_name} #{field_type.to_s.upcase}"
+          end
           column(name, "STRUCT(#{field_definitions.join(", ")})", **)
         end
 
@@ -80,7 +84,8 @@ module ActiveRecord
         # @example Create a status enum
         #   t.enum :status, values: ['active', 'inactive', 'pending']
         def enum(name, values: [], **)
-          enum_values = values.map { |v| "'#{v}'" }.join(', ')
+          # Escape single quotes in enum values to prevent SQL injection
+          enum_values = values.map { |v| "'#{v.to_s.gsub("'", "''")}'" }.join(', ')
           column(name, "ENUM(#{enum_values})", **)
         end
       end