activerecord-duckdb 0.1.0 → 0.1.1

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Duckdb
+      # Rails 7.2 and 8.0 specific schema statement implementations.
+      # Column constructor: (name, default, sql_type_metadata, null, default_function, **options)
+      module SchemaStatementsRails80
+        # Creates a new Column object from DuckDB field information.
+        # @param table_name [String] The name of the table
+        # @param field [Array] Array containing column field information from PRAGMA table_info
+        # @param definitions [Hash] Additional column definitions (unused)
+        # @return [ActiveRecord::ConnectionAdapters::Duckdb::Column] The created column object
+        def new_column_from_field(table_name, field, _definitions)
+          info = column_info_from_field(table_name, field)
+
+          Column.new(
+            info[:name],
+            info[:default],
+            info[:sql_type_metadata],
+            info[:null],
+            info[:default_function],
+            collation: info[:collation],
+            comment: info[:comment],
+            auto_increment: info[:auto_increment],
+            rowid: info[:rowid]
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Duckdb
+      # Rails 8.1+ specific schema statement implementations.
+      # Column constructor: (name, cast_type, default, sql_type_metadata, null, default_function, **options)
+      module SchemaStatementsRails81
+        # Creates a new Column object from DuckDB field information.
+        # @param table_name [String] The name of the table
+        # @param field [Array] Array containing column field information from PRAGMA table_info
+        # @param definitions [Hash] Additional column definitions (unused)
+        # @return [ActiveRecord::ConnectionAdapters::Duckdb::Column] The created column object
+        def new_column_from_field(table_name, field, _definitions)
+          info = column_info_from_field(table_name, field)
+          cast_type = lookup_cast_type_from_column(info[:sql_type_metadata])
+
+          Column.new(
+            info[:name],
+            cast_type,
+            info[:default],
+            info[:sql_type_metadata],
+            info[:null],
+            info[:default_function],
+            collation: info[:collation],
+            comment: info[:comment],
+            auto_increment: info[:auto_increment],
+            rowid: info[:rowid]
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# Monkey patch DuckDB::Converter to respect ActiveRecord.default_timezone.
+# Based on: https://github.com/suketa/ruby-duckdb/blob/master/lib/duckdb/converter.rb
+# Change: Use Time.utc instead of Time.local when ActiveRecord.default_timezone is :utc
+# This fixes an issue where timestamps are interpreted in local timezone instead of UTC.
+#
+# Run `bin/verify_timestamp_patch` to test compatibility with new versions.
+module DuckDBConverterTimestampMonkeyPatch
+  # Version range verified by bin/verify_timestamp_patch
+  TESTED_VERSION_MIN = '1.0.0.0'
+  TESTED_VERSION_MAX = '1.5.4.0'
+
+  EXPECTED_METHODS = {
+    _to_time: { arity: 7 },
+    _to_time_from_duckdb_time: { arity: 4 },
+    _to_time_from_duckdb_timestamp_s: { arity: 1 },
+    _to_time_from_duckdb_timestamp_ms: { arity: 1 },
+    _to_time_from_duckdb_timestamp_ns: { arity: 1 }
+  }.freeze
+
+  class << self
+    def apply_patch
+      const = find_const
+      verify_methods!(const)
+
+      unless duckdb_version_ok?
+        version = Gem.loaded_specs['duckdb']&.version
+        puts "WARNING: duckdb gem version #{version} is outside tested range " \
+             "(#{TESTED_VERSION_MIN} - #{TESTED_VERSION_MAX}). " \
+             'Please run bin/verify_timestamp_patch and update the range if compatible.'
+      end
+
+      const.singleton_class.prepend(ClassMethods)
+    end
+
+    private
+
+    def find_const
+      Kernel.const_get('DuckDB::Converter')
+    rescue NameError
+      raise 'Could not find DuckDB::Converter when applying timestamp patch. Please investigate.'
+    end
+
+    def verify_methods!(const)
+      EXPECTED_METHODS.each do |method_name, expectations|
+        mtd = const.method(method_name)
+        unless mtd && mtd.arity == expectations[:arity]
+          raise "Could not find method #{method_name} with arity #{expectations[:arity]} " \
+                'when patching DuckDB::Converter. Please investigate.'
+        end
+      rescue NameError
+        raise "Could not find method #{method_name} when patching DuckDB::Converter. Please investigate."
+      end
+    end
+
+    def duckdb_version_ok?
+      version = Gem.loaded_specs['duckdb']&.version
+      return false unless version
+
+      min = Gem::Version.new(TESTED_VERSION_MIN)
+      max = Gem::Version.new(TESTED_VERSION_MAX)
+      version.between?(min, max)
+    end
+  end
+end
+
+module ClassMethods
+  EPOCH_UTC = Time.utc(1970, 1, 1).freeze
+
+  def _to_time(year, month, day, hour, minute, second, microsecond)
+    if ActiveRecord.default_timezone == :utc
+      Time.utc(year, month, day, hour, minute, second, microsecond)
+    else
+      super
+    end
+  end
+
+  def _to_time_from_duckdb_time(hour, minute, second, microsecond)
+    if ActiveRecord.default_timezone == :utc
+      Time.utc(1970, 1, 1, hour, minute, second, microsecond)
+    else
+      super
+    end
+  end
+
+  def _to_time_from_duckdb_timestamp_s(time)
+    if ActiveRecord.default_timezone == :utc
+      EPOCH_UTC + time
+    else
+      super
+    end
+  end
+
+  def _to_time_from_duckdb_timestamp_ms(time)
+    if ActiveRecord.default_timezone == :utc
+      tm = EPOCH_UTC + (time / 1000)
+      Time.utc(tm.year, tm.month, tm.day, tm.hour, tm.min, tm.sec, time % 1000 * 1000)
+    else
+      super
+    end
+  end
+
+  def _to_time_from_duckdb_timestamp_ns(time)
+    if ActiveRecord.default_timezone == :utc
+      tm = EPOCH_UTC + (time / 1_000_000_000)
+      Time.utc(tm.year, tm.month, tm.day, tm.hour, tm.min, tm.sec, time % 1_000_000_000 / 1000)
+    else
+      super
+    end
+  end
+end
+
+DuckDBConverterTimestampMonkeyPatch.apply_patch

data/lib/active_record/connection_adapters/duckdb/type/interval.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'active_support/duration'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Duckdb
+      module Type
+        # Type for DuckDB INTERVAL columns
+        # Converts between DuckDB::Interval and ActiveSupport::Duration
+        #
+        # @example Reading an interval from the database
+        #   # DuckDB returns: DuckDB::Interval with months=0, days=1, micros=3600000000
+        #   # Ruby receives: ActiveSupport::Duration of "1 day and 1 hour"
+        #
+        # @example Writing an interval to the database
+        #   # Ruby sends: 2.hours + 30.minutes (ActiveSupport::Duration)
+        #   # DuckDB receives: "INTERVAL '2 hours 30 minutes'"
+        class Interval < ActiveRecord::Type::Value
+          def type
+            :interval
+          end
+
+          # Deserialize from database value to Ruby object
+          # @param value [DuckDB::Interval, String, nil] The database value
+          # @return [ActiveSupport::Duration, nil] The Ruby duration
+          def deserialize(value)
+            return nil if value.nil?
+
+            case value
+            when ::DuckDB::Interval
+              interval_to_duration(value)
+            when ::ActiveSupport::Duration
+              value
+            when ::String
+              parse_interval_string(value)
+            end
+          end
+
+          # Cast from user input to Ruby object
+          # @param value [Object] The user input
+          # @return [ActiveSupport::Duration, nil] The Ruby duration
+          def cast(value)
+            return nil if value.nil?
+
+            case value
+            when ::ActiveSupport::Duration
+              value
+            when ::DuckDB::Interval
+              interval_to_duration(value)
+            when ::Numeric
+              # Treat numeric as seconds
+              ActiveSupport::Duration.build(value)
+            when ::String
+              parse_interval_string(value)
+            when ::Hash
+              # Allow hash like { hours: 2, minutes: 30 }
+              hash_to_duration(value)
+            end
+          end
+
+          # Serialize from Ruby object to database value
+          # @param value [ActiveSupport::Duration, Numeric, nil] The Ruby value
+          # @return [String, nil] The SQL interval literal
+          def serialize(value)
+            return nil if value.nil?
+
+            case value
+            when ::ActiveSupport::Duration
+              duration_to_interval_string(value)
+            when ::Numeric
+              duration_to_interval_string(ActiveSupport::Duration.build(value))
+            when ::String
+              value
+            end
+          end
+
+          private
+
+          # Convert DuckDB::Interval to ActiveSupport::Duration
+          def interval_to_duration(interval)
+            parts = []
+
+            if interval.interval_months != 0
+              years, months = interval.interval_months.divmod(12)
+              parts << years.years if years != 0
+              parts << months.months if months != 0
+            end
+
+            parts << interval.interval_days.days if interval.interval_days != 0
+
+            if interval.interval_micros != 0
+              total_seconds = interval.interval_micros / 1_000_000.0
+              hours, remainder = total_seconds.divmod(3600)
+              minutes, seconds = remainder.divmod(60)
+
+              parts << hours.to_i.hours if hours >= 1
+              parts << minutes.to_i.minutes if minutes >= 1
+              parts << seconds.seconds if seconds.positive?
+            end
+
+            return 0.seconds if parts.empty?
+
+            parts.sum
+          end
+
+          # Convert ActiveSupport::Duration to DuckDB interval string
+          def duration_to_interval_string(duration)
+            parts = []
+            remaining = duration.in_seconds
+
+            # Extract components
+            parts << "#{duration.parts[:years]} years" if duration.parts[:years]
+
+            parts << "#{duration.parts[:months]} months" if duration.parts[:months]
+
+            parts << "#{duration.parts[:weeks]} weeks" if duration.parts[:weeks]
+
+            parts << "#{duration.parts[:days]} days" if duration.parts[:days]
+
+            parts << "#{duration.parts[:hours]} hours" if duration.parts[:hours]
+
+            parts << "#{duration.parts[:minutes]} minutes" if duration.parts[:minutes]
+
+            parts << "#{duration.parts[:seconds]} seconds" if duration.parts[:seconds]
+
+            # If no parts but has value, convert from total seconds
+            if parts.empty? && remaining.positive?
+              hours, remainder = remaining.divmod(3600)
+              minutes, seconds = remainder.divmod(60)
+
+              parts << "#{hours.to_i} hours" if hours >= 1
+              parts << "#{minutes.to_i} minutes" if minutes >= 1
+              parts << "#{seconds} seconds" if seconds.positive?
+            end
+
+            parts.empty? ? '0 seconds' : parts.join(' ')
+          end
+
+          # Parse interval string to Duration
+          def parse_interval_string(str)
+            return nil if str.nil? || str.empty?
+
+            # Try ISO8601 format first
+            begin
+              return ActiveSupport::Duration.parse(str)
+            rescue ActiveSupport::Duration::ISO8601Parser::ParsingError
+              # Continue to try other formats
+            end
+
+            # Parse DuckDB-style interval strings like "1 day 2 hours"
+            parts = []
+            str.scan(/(\d+)\s*(year|month|week|day|hour|minute|second)s?/i) do |amount, unit|
+              parts << amount.to_i.public_send(unit.downcase.pluralize)
+            end
+
+            parts.empty? ? nil : parts.sum
+          end
+
+          # Convert hash to Duration
+          def hash_to_duration(hash)
+            parts = []
+            hash.each do |unit, amount|
+              next if amount.nil? || amount.zero?
+
+              parts << amount.public_send(unit.to_s.singularize.pluralize)
+            end
+            parts.empty? ? 0.seconds : parts.sum
+          end
+        end
+      end
+    end
+  end
+end