activerecord-duckdb 0.1.0 → 0.1.1

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

@@ -3,9 +3,102 @@
 module ActiveRecord
   module ConnectionAdapters
     module Duckdb
-      # DuckDB-specific schema dumper functionality for generating schema.rb files
-      # Provides methods to properly dump DuckDB-specific column types and constraints
-      module SchemaDumper
+      # DuckDB-specific schema dumper class for generating schema.rb files
+      # Extends Rails' ConnectionAdapters::SchemaDumper to handle DuckDB-specific
+      # column types, constraints, and DuckLake features like partitioning
+      class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
+        # Valid DuckLake options that can be set via set_option
+        SETTABLE_DUCKLAKE_OPTIONS = %w[parquet_version parquet_compression].freeze
+
+        # Override table dumping to include DuckLake-specific features
+        # @param table [String] The table name
+        # @param stream [IO] The output stream
+        # @return [void]
+        def table(table, stream)
+          # Call the parent implementation first
+          super
+
+          # Add DuckLake partitioning if present
+          dump_partitioning(table, stream)
+
+          # Add DuckLake table-level options if present
+          dump_table_options(table, stream)
+        end
+
+        private
+
+        # Override Scenic's defined_views to return empty array for DuckDB
+        # This prevents Scenic's MySQL adapter from being called with DuckDB connections
+        # @return [Array] Empty array of views
+        def defined_views
+          []
+        end
+
+        # Override Scenic's dumpable_views_in_database to return empty array for DuckDB
+        # This prevents Scenic from calling Scenic.database.views which uses MySQL adapter
+        # @return [Array] Empty array of views
+        def dumpable_views_in_database
+          []
+        end
+
+        # Override extensions to also dump DuckLake options
+        # @param stream [IO] The output stream
+        # @return [void]
+        def extensions(stream)
+          super
+          dump_ducklake_options(stream)
+        end
+
+        # Dumps DuckLake options (parquet_version, parquet_compression, etc.)
+        # @param stream [IO] The output stream
+        # @return [void]
+        def dump_ducklake_options(stream)
+          return unless @connection.respond_to?(:ducklake_options)
+
+          options = @connection.ducklake_options
+          return if options.nil? || options.empty?
+
+          # Filter to only include settable options (not metadata like 'encrypted')
+          settable_options = options.slice(*SETTABLE_DUCKLAKE_OPTIONS)
+          return if settable_options.empty?
+
+          settable_options.sort.each do |name, value|
+            stream.puts "  set_ducklake_option #{name.inspect}, #{value.inspect}"
+          end
+          stream.puts
+        end
+
+        # Dumps DuckLake partitioning for a table
+        # @param table_name [String] The table name
+        # @param stream [IO] The output stream
+        # @return [void]
+        def dump_partitioning(table_name, stream)
+          return unless @connection.respond_to?(:partition_expressions)
+
+          expressions = @connection.partition_expressions(table_name)
+          return if expressions.nil? || expressions.empty?
+
+          # Format the expressions array as Ruby code
+          expressions_code = expressions.map(&:inspect).join(', ')
+          stream.puts "  set_partitioned_by #{table_name.inspect}, [#{expressions_code}]"
+        end
+
+        # Dumps DuckLake table-level options
+        # @param table_name [String] The table name
+        # @param stream [IO] The output stream
+        # @return [void]
+        def dump_table_options(table_name, stream)
+          return unless @connection.respond_to?(:ducklake_table_options)
+
+          options = @connection.ducklake_table_options(table_name)
+          return if options.nil? || options.empty?
+
+          options.sort.each do |name, value|
+            stream.puts "  set_ducklake_option #{name.inspect}, #{value.inspect}, #{table_name.inspect}"
+          end
+          stream.puts
+        end
+
         # Generates column specification for schema dumping
         # @param column [ActiveRecord::ConnectionAdapters::Column] The column to generate spec for
         # @return [Array] Array containing column type and options hash
@@ -49,6 +142,27 @@ module ActiveRecord
             :date
           when /^TIME$/i
             :time
+          # DuckDB-specific signed integer types
+          when /^TINYINT$/i
+            :tinyint
+          when /^SMALLINT$/i
+            :smallint
+          when /^HUGEINT$/i
+            :hugeint
+          # DuckDB-specific unsigned integer types
+          when /^UTINYINT$/i
+            :utinyint
+          when /^USMALLINT$/i
+            :usmallint
+          when /^UINTEGER$/i
+            :uinteger
+          when /^UBIGINT$/i
+            :ubigint
+          when /^UHUGEINT$/i
+            :uhugeint
+          # DuckDB interval type
+          when /^INTERVAL$/i
+            :interval
           else
             column.type
           end

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

@@ -22,6 +22,21 @@ module ActiveRecord
           result.to_a.map { |row| row[0] }
         end
 
+        # Returns a list of all views in the database
+        # @return [Array<String>] Array of view names
+        def views
+          result = execute(data_source_sql(type: 'VIEW'), 'SCHEMA')
+          result.to_a.map { |row| row[0] }
+        end
+
+        # Returns options for internal primary key columns (schema_migrations, ar_internal_metadata)
+        # DuckLake doesn't support PRIMARY KEY constraints, so we omit them in that mode
+        # @return [Hash] Options hash for string primary key columns
+        def internal_string_options_for_primary_key
+          # DuckLake doesn't support PRIMARY KEY/UNIQUE constraints
+          ducklake? ? {} : { primary_key: true }
+        end
+
         # Creates a DuckDB-specific table definition instance
         # @param name [String, Symbol] The table name
         # @return [ActiveRecord::ConnectionAdapters::Duckdb::TableDefinition] Table definition instance
@@ -72,8 +87,8 @@ module ActiveRecord
         # @return [void]
         def create_sequence(sequence_name, start_with: 1, increment_by: 1, **options)
           sql = "CREATE SEQUENCE #{quote_table_name(sequence_name)}"
-          sql << " START #{start_with}" if start_with != 1
-          sql << " INCREMENT #{increment_by}" if increment_by != 1
+          sql << " START #{start_with.to_i}" if start_with != 1
+          sql << " INCREMENT #{increment_by.to_i}" if increment_by != 1
           execute(sql, 'Create Sequence')
         end
 
@@ -115,7 +130,7 @@ module ActiveRecord
         # @param sequence_name [String] The name of the sequence
         # @return [String] SQL expression for getting next sequence value
         def next_sequence_value(sequence_name)
-          "nextval('#{sequence_name}')"
+          "nextval(#{quote(sequence_name)})"
         end
 
         # Resets a sequence to a specific value
@@ -123,7 +138,7 @@ module ActiveRecord
         # @param value [Integer] The value to reset the sequence to (default: 1)
         # @return [void]
         def reset_sequence!(sequence_name, value = 1)
-          execute("ALTER SEQUENCE #{quote_table_name(sequence_name)} RESTART WITH #{value}", 'Reset Sequence')
+          execute("ALTER SEQUENCE #{quote_table_name(sequence_name)} RESTART WITH #{value.to_i}", 'Reset Sequence')
         end
 
         # Returns a list of all sequences in the database
@@ -133,6 +148,179 @@ module ActiveRecord
           []
         end
 
+        # Sets partitioning for a DuckLake table
+        # DuckLake supports time-based partitioning using SQL functions
+        # @param table_name [String, Symbol] The name of the table to partition
+        # @param expressions [Array<String>] Array of SQL expressions for partitioning
+        # @return [void]
+        # @example Partition by year, month, day
+        #   set_partitioned_by(:datapoints, ['year(created_at)', 'month(created_at)', 'day(created_at)'])
+        # @see https://ducklake.select/docs/stable/sql/statements/alter_table.html
+        def set_partitioned_by(table_name, expressions)
+          sql = "ALTER TABLE #{quote_table_name(table_name)} SET PARTITIONED BY (#{expressions.join(", ")})"
+          execute(sql, 'Set Partitioned By')
+        end
+
+        # NOTE: DuckLake does not support removing partitioning after it has been set.
+        # Partitioning is a one-way operation. To change partitioning, you must recreate the table.
+
+        # Returns the partition expressions for a DuckLake table
+        # @param table_name [String, Symbol] The name of the table
+        # @return [Array<String>] Array of partition expressions (e.g., ['month(created_at)'])
+        # @return [nil] If the table is not partitioned or not in DuckLake mode
+        def partition_expressions(table_name)
+          return nil unless ducklake?
+
+          # Find the metadata schema for the current database
+          metadata_schema = ducklake_metadata_schema
+          return nil unless metadata_schema
+
+          # Query partition info from DuckLake metadata tables
+          # Schema:
+          #   ducklake_partition_column: partition_id, table_id, partition_key_index, column_id, transform
+          #   ducklake_column: column_id, table_id, column_name, ...
+          #   ducklake_table: table_id, table_name, ...
+          sql = <<~SQL
+            SELECT pc.partition_key_index, c.column_name, pc.transform
+            FROM #{quote_table_name(metadata_schema)}.ducklake_partition_column pc
+            JOIN #{quote_table_name(metadata_schema)}.ducklake_table t ON pc.table_id = t.table_id
+            JOIN #{quote_table_name(metadata_schema)}.ducklake_column c ON pc.column_id = c.column_id AND c.table_id = t.table_id
+            WHERE t.table_name = #{quote(table_name.to_s)}
+            ORDER BY pc.partition_key_index
+          SQL
+
+          result = execute(sql, 'Get Partition Expressions')
+          expressions = result.map do |row|
+            _index, column_name, transform = row
+            if transform && !transform.to_s.empty?
+              "#{transform}(#{column_name})"
+            else
+              column_name.to_s
+            end
+          end
+
+          expressions.empty? ? nil : expressions
+        rescue StandardError
+          # If metadata tables don't exist or query fails, return nil
+          nil
+        end
+
+        # Returns the DuckLake metadata schema name for the current database
+        # @return [String, nil] The metadata schema name or nil if not found
+        def ducklake_metadata_schema
+          # Don't memoize - current_database can change after USE DATABASE
+          # DuckLake metadata is stored in __ducklake_metadata_<database_name>
+          result = execute('SELECT current_database()', 'Get Current Database')
+          db_name = result.first&.first
+          return nil if db_name.nil? || db_name.empty?
+
+          "__ducklake_metadata_#{db_name}"
+        rescue StandardError
+          nil
+        end
+
+        # Sets a DuckLake-specific option using CALL set_option
+        # @param option_name [String] The name of the option to set
+        # @param value [String, Integer] The value to set
+        # @param table_name [String, Symbol, nil] Optional table name for table-scoped options
+        # @return [void]
+        # @example Set global parquet version
+        #   set_ducklake_option('parquet_version', '2')
+        # @example Set table-level parquet compression
+        #   set_ducklake_option('parquet_compression', 'zstd', :events)
+        def set_ducklake_option(option_name, value, table_name = nil)
+          formatted_value = value.is_a?(Integer) ? value.to_s : quote(value)
+          sql = if table_name
+                  "CALL set_option(#{quote(option_name)}, #{formatted_value}, #{quote(table_name.to_s)})"
+                else
+                  "CALL set_option(#{quote(option_name)}, #{formatted_value})"
+                end
+          execute(sql, 'Set DuckLake Option')
+        end
+
+        # DuckLake options that should be included in schema dumps
+        # These are user-configurable options, not internal metadata like 'version' or 'created_by'
+        # See: https://ducklake.select/docs/stable/specification/tables/ducklake_metadata.html
+        DUMPABLE_DUCKLAKE_OPTIONS = %w[
+          data_inlining_row_limit
+          target_file_size
+          parquet_row_group_size_bytes
+          parquet_row_group_size
+          parquet_compression
+          parquet_compression_level
+          parquet_version
+          hive_file_pattern
+          require_commit_message
+          rewrite_delete_threshold
+          delete_older_than
+          expire_older_than
+          per_thread_output
+          encrypted
+        ].freeze
+
+        # Returns DuckLake options for schema dumping
+        # @return [Hash] Hash of option_name => value for user-configurable options
+        # @return [nil] If not in DuckLake mode or no options set
+        def ducklake_options
+          return nil unless ducklake?
+
+          metadata_schema = ducklake_metadata_schema
+          return nil unless metadata_schema
+
+          # Query the ducklake_metadata table for global options (scope IS NULL)
+          sql = <<~SQL
+            SELECT key, value
+            FROM #{quote_table_name(metadata_schema)}.ducklake_metadata
+            WHERE scope IS NULL
+          SQL
+
+          result = execute(sql, 'Get DuckLake Options')
+          options = {}
+          result.each do |row|
+            key, value = row
+            # Only include user-configurable options, not internal metadata
+            options[key] = value if DUMPABLE_DUCKLAKE_OPTIONS.include?(key)
+          end
+
+          options.empty? ? nil : options
+        rescue StandardError
+          nil
+        end
+
+        # Returns DuckLake options for a specific table
+        # @param table_name [String, Symbol] The table name
+        # @return [Hash] Hash of option_name => value for table-scoped options
+        # @return [nil] If not in DuckLake mode or no table options set
+        def ducklake_table_options(table_name)
+          return nil unless ducklake?
+
+          metadata_schema = ducklake_metadata_schema
+          return nil unless metadata_schema
+
+          # Get the table_id first
+          table_sql = <<~SQL
+            SELECT table_id FROM #{quote_table_name(metadata_schema)}.ducklake_table
+            WHERE table_name = #{quote(table_name.to_s)}
+          SQL
+          table_result = execute(table_sql, 'Get Table ID')
+          table_id = table_result.first&.first
+          return nil unless table_id
+
+          # Query the ducklake_metadata table for table-scoped options
+          sql = <<~SQL
+            SELECT key, value
+            FROM #{quote_table_name(metadata_schema)}.ducklake_metadata
+            WHERE scope = 'table' AND scope_id = #{table_id.to_i}
+          SQL
+
+          result = execute(sql, 'Get DuckLake Table Options')
+          options = result.to_h { |key, value| DUMPABLE_DUCKLAKE_OPTIONS.include?(key) ? [key, value] : [] }
+
+          options.presence
+        rescue StandardError
+          nil
+        end
+
         # Returns indexes for a specific table
         # @param table_name [String, Symbol] The name of the table
         # @return [Array<ActiveRecord::ConnectionAdapters::IndexDefinition>] Array of index definitions
@@ -196,71 +384,6 @@ module ActiveRecord
           sql
         end
 
-        # 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)
-          column_name, formatted_type, column_default, not_null, _type_id, _type_modifier, collation_name, comment, _identity, _generated, pk = field
-
-          # Ensure we have required values with proper defaults
-          column_name = 'unknown_column' if column_name.nil? || column_name.empty?
-
-          formatted_type = formatted_type.to_s if formatted_type
-          formatted_type = 'VARCHAR' if formatted_type.nil? || formatted_type.empty?
-
-          # Create proper SqlTypeMetadata object
-          sql_type_metadata = fetch_type_metadata(formatted_type)
-
-          # For primary keys with integer types, check if sequence exists and set default_function
-          default_value = nil
-          default_function = nil
-
-          if pk && [true,
-                    1].include?(pk) && %w[INTEGER BIGINT].include?(formatted_type.to_s.upcase) && column_name == 'id'
-            # This is an integer primary key named 'id' - assume sequence exists
-            sequence_name = "#{table_name}_#{column_name}_seq"
-            default_function = "nextval('#{sequence_name}')"
-            default_value = nil
-          elsif column_default&.to_s&.include?('nextval(')
-            # This is a sequence - store it as default_function, not default_value
-            default_function = column_default.to_s
-            default_value = nil
-          else
-            default_value = extract_value_from_default(column_default)
-            default_function = nil
-          end
-
-          # Ensure boolean values are properly converted for null constraint
-          # In DuckDB PRAGMA: not_null=1 means NOT NULL, not_null=0 means NULL allowed
-          is_null = case not_null
-                    when 1, true
-                      false  # Column does NOT allow NULL
-                    else
-                      true   # Default to allowing NULL for unknown values
-                    end
-
-          # Clean up parameters for Column constructor
-          clean_column_name = column_name.to_s
-          clean_default_value = default_value
-          clean_default_function = default_function&.to_s
-          clean_collation = collation_name&.to_s
-          clean_comment = comment&.to_s
-
-          ActiveRecord::ConnectionAdapters::Duckdb::Column.new(
-            clean_column_name,       # name
-            clean_default_value,     # default (should be nil for sequences!)
-            sql_type_metadata,       # sql_type_metadata
-            is_null,                 # null (boolean - true if column allows NULL)
-            clean_default_function,  # default_function (this is where nextval goes!)
-            collation: clean_collation.presence,
-            comment: clean_comment.presence,
-            auto_increment: pk && %w[INTEGER BIGINT].include?(formatted_type.to_s.upcase),
-            rowid: pk && column_name == 'id'
-          )
-        end
-
         # Looks up the appropriate cast type for a column based on SQL type metadata
         # @param sql_type_metadata [ActiveRecord::ConnectionAdapters::SqlTypeMetadata] The SQL type metadata
         # @return [ActiveRecord::Type::Value] The appropriate cast type
@@ -275,6 +398,10 @@ module ActiveRecord
         def quoted_scope(name = nil, type: nil)
           schema, name = extract_schema_qualified_name(name)
 
+          # Default to 'main' schema if no schema specified to avoid returning
+          # tables from information_schema, pg_catalog, or other attached databases
+          schema ||= 'main'
+
           type_condition = case type
                            when 'BASE TABLE'
                              "table_type = 'BASE TABLE'"
@@ -285,7 +412,7 @@ module ActiveRecord
                            end
 
           {
-            schema: schema ? quote(schema) : nil,
+            schema: quote(schema),
             name: name ? quote(name) : nil,
             type: type_condition
           }
@@ -298,6 +425,7 @@ module ActiveRecord
         # @param scale [Integer, nil] Optional decimal scale
         # @param options [Hash] Additional type options
         # @return [String] The DuckDB SQL type string
+        # @see https://duckdb.org/docs/stable/sql/data_types/overview.html
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, **options)
           case type.to_s
           when 'primary_key'
@@ -313,8 +441,10 @@ module ActiveRecord
             integer_to_sql(limit)
           when 'bigint'
             'BIGINT'
-          when 'float'
+          when 'float', 'real'
             'REAL'
+          when 'double'
+            'DOUBLE'
           when 'decimal', 'numeric'
             if precision && scale
               "DECIMAL(#{precision},#{scale})"
@@ -339,6 +469,27 @@ module ActiveRecord
             'BLOB'
           when 'uuid'
             'UUID'
+          # DuckDB-specific signed integer types
+          when 'tinyint'
+            'TINYINT'
+          when 'smallint'
+            'SMALLINT'
+          when 'hugeint'
+            'HUGEINT'
+          # DuckDB-specific unsigned integer types
+          when 'utinyint'
+            'UTINYINT'
+          when 'usmallint'
+            'USMALLINT'
+          when 'uinteger'
+            'UINTEGER'
+          when 'ubigint'
+            'UBIGINT'
+          when 'uhugeint'
+            'UHUGEINT'
+          # DuckDB interval type for time periods
+          when 'interval'
+            'INTERVAL'
           else
             super
           end
@@ -362,7 +513,7 @@ module ActiveRecord
               # Only replace the first occurrence (the actual primary key)
               sql = sql.sub(pk_column_pattern) do |match|
                 # Inject the sequence default before PRIMARY KEY
-                match.sub(/(\s+)PRIMARY\s+KEY/i, "\\1DEFAULT nextval('#{pending[:sequence]}') PRIMARY KEY")
+                match.sub(/(\s+)PRIMARY\s+KEY/i, "\\1DEFAULT nextval(#{quote(pending[:sequence])}) PRIMARY KEY")
               end
             end
           end
@@ -372,6 +523,59 @@ module ActiveRecord
 
         private
 
+        # Parses DuckDB field information and returns a hash with all values needed
+        # to construct a Column object. Used by version-specific new_column_from_field.
+        # @param table_name [String] The name of the table
+        # @param field [Array] Array from PRAGMA table_info
+        # @return [Hash] Parsed column information
+        def column_info_from_field(table_name, field)
+          column_name, formatted_type, column_default, not_null, _type_id, _type_modifier,
+            collation_name, comment, _identity, _generated, pk = field
+
+          # Normalize values
+          column_name = column_name.presence || 'unknown_column'
+          formatted_type = formatted_type.to_s.presence || 'VARCHAR'
+          sql_type_metadata = fetch_type_metadata(formatted_type)
+
+          # Determine default value vs function
+          default_value, default_function = parse_column_default(
+            table_name, column_name, column_default, formatted_type, pk
+          )
+
+          # Parse null constraint (DuckDB: not_null=1 means NOT NULL)
+          is_null = !not_null.in?([1, true])
+
+          # Detect auto-increment columns
+          is_integer_pk = pk && formatted_type.upcase.in?(%w[INTEGER BIGINT])
+
+          {
+            name: column_name.to_s,
+            sql_type_metadata: sql_type_metadata,
+            default: default_value,
+            default_function: default_function&.to_s,
+            null: is_null,
+            collation: collation_name.to_s.presence,
+            comment: comment.to_s.presence,
+            auto_increment: is_integer_pk,
+            rowid: pk && column_name == 'id'
+          }
+        end
+
+        # Parses column default, separating static values from sequence functions.
+        # @return [Array<Object, String>] [default_value, default_function]
+        def parse_column_default(table_name, column_name, column_default, formatted_type, pk)
+          # Integer primary key named 'id' - assume sequence exists
+          if pk&.in?([true, 1]) && formatted_type.upcase.in?(%w[INTEGER BIGINT]) && column_name == 'id'
+            # Build the sequence name and quote it properly for the nextval expression
+            seq_name = "#{table_name}_#{column_name}_seq"
+            [nil, "nextval(#{quote(seq_name)})"]
+          elsif column_default.to_s.include?('nextval(')
+            [nil, column_default.to_s]
+          else
+            [extract_value_from_default(column_default), nil]
+          end
+        end
+
         # Parses index column names from DuckDB's string representation
         # @param column_names_str [String] The string representation of column names
         # @return [Array<String>] Array of cleaned column names
@@ -477,17 +681,33 @@ module ActiveRecord
         # Parses DuckDB SQL type strings into Rails type components
         # @param sql_type [String] The SQL type string to parse
         # @return [Array] Array containing [type, limit, precision, scale]
+        # @see https://duckdb.org/docs/stable/sql/data_types/overview.html
         def parse_type_info(sql_type)
           return [:string, nil, nil, nil] if sql_type.nil? || sql_type.empty?
 
-          # https://duckdb.org/docs/stable/sql/data_types/overview.html
           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]
-          # Map HUGEINT to bigint for Rails compatibility
+            [:integer, 4, precision, scale]
+          # BIGINT: 8 bytes (-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807)
+          # HUGEINT: 16 bytes - map to bigint with limit 8 for Rails compatibility
+          # Note: Rails doesn't support 16-byte integers natively, values may overflow
           when /^BIGINT/i, /^HUGEINT/i
-            [:bigint, nil, nil, nil]
+            [:bigint, 8, nil, nil]
+          # DuckDB-specific signed integer types - use specific type symbols for schema dumping
+          when /^SMALLINT/i
+            [:smallint, 2, nil, nil]
+          when /^TINYINT/i
+            [:tinyint, 1, nil, nil]
+          # DuckDB-specific unsigned integer types - use specific type symbols for schema dumping
+          when /^UBIGINT/i
+            [:ubigint, 8, nil, nil]
+          when /^UINTEGER/i
+            [:uinteger, 4, nil, nil]
+          when /^USMALLINT/i
+            [:usmallint, 2, nil, nil]
+          when /^UTINYINT/i
+            [:utinyint, 1, nil, nil]
           when /^VARCHAR(\((\d+)\))?/i, /^CHAR(\((\d+)\))?/i
             # Extract limit from VARCHAR(n) format
             limit = ::Regexp.last_match(2)&.to_i
@@ -502,18 +722,17 @@ module ActiveRecord
             [:boolean, nil, nil, nil]
           when /^DATE$/i
             [:date, nil, nil, nil]
-          when /^TIME/i
-            [:time, nil, nil, nil]
           when /^TIMESTAMP/i, /^DATETIME/i
             [:datetime, nil, nil, nil]
+          when /^TIME$/i
+            [:time, 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]
           when /^UUID/i
             [:uuid, nil, nil, nil]
-          when /^TINYINT/i, /^SMALLINT/i
-            # TODO: Determine if integer or smallint should be used here
-            [:integer, nil, nil, nil]
+          when /^INTERVAL/i
+            [:interval, nil, nil, nil]
           when /^BLOB/i, /^BYTEA/i, /^BINARY/i
             [:binary, nil, nil, nil]
           else
@@ -558,18 +777,18 @@ module ActiveRecord
         end
 
         # Returns the default primary key type definition for DuckDB
+        # DuckLake doesn't support PRIMARY KEY constraints, so we omit them in that mode
         # @return [String] SQL definition for the primary key type
         def primary_key_type_definition
-          case self.class.primary_key_type
-          when :uuid
-            'UUID PRIMARY KEY'
-          when :bigint
-            'BIGINT PRIMARY KEY'
-          when :string
-            'VARCHAR PRIMARY KEY'
-          else
-            'INTEGER PRIMARY KEY' # fallback
-          end
+          base_type = case self.class.primary_key_type
+                      when :uuid then 'UUID'
+                      when :bigint then 'BIGINT'
+                      when :string then 'VARCHAR'
+                      else 'INTEGER'
+                      end
+
+          # DuckLake doesn't support PRIMARY KEY/UNIQUE constraints
+          ducklake? ? base_type : "#{base_type} PRIMARY KEY"
         end
 
         # Converts integer limit to appropriate DuckDB integer SQL type