rubydb 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5005f9218456b8961e7cb6c61ea685d10cc327765f9509a49a766b3389634132
-  data.tar.gz: 878e67e40ece7e731e9aae8f412f3e0733f43e56202e83d77212d44c032ef191
+  metadata.gz: 3c076e3acf3d8cf15a98581eb92daafdbe2aba8a40805279c08c957aece8a601
+  data.tar.gz: 36eeb2c1ea39757ee1c759af4f1abefea987ba28f0929642258f289c3196df66
 SHA512:
-  metadata.gz: c81b88aa18802979d5320534cf7ee7270e84a6c48b2a9528b8bec135439f5c84c3a0b45a7e3012d6a3fbdbdb6b226f4ed29dc9a3edbe86333b2e0eb633214b5c
-  data.tar.gz: 1fe32bd686090053c717631b97a6e996094c5284c77c452ede991d18aefc248616d905c44f12a2dae725bb19aa7f603e235ba8c9fe6a97ca121cef38f24d3237
+  metadata.gz: 358853343b4781a04e72e1e9910ed4c8fe562f4e56a9d3b2c27bb6b962da78bc3eeabfca4efbfa3b83c8e8d0f3295b368701b38fbc2baab361109bfe173ca3b8
+  data.tar.gz: a0a90a0cd04781b3dd35bbd94a46513debdf69195e09fadd677d21d27b005db874d048b8281d432f68350f86f21c64ceb39b24fa4ae17ee6903034782ca8dc4a

data/CHANGELOG.md

@@ -23,6 +23,22 @@ All notable changes to RubyDB are documented here. Versions follow
   vacuum, maintenance, and release workflows.
 - Clarified the tested common SQLite-style profile and production limits.
 
+## 0.1.3 - 2026-09-09
+
+- Normalized numeric MVCC visibility-map keys after restart to prevent mixed
+  string/integer keys and duplicate-key warnings on Ruby 4.
+- Made visibility-map persistence failures raise `RubyDB::StorageError`
+  instead of silently reporting success.
+
+## 0.1.2 - 2026-09-09
+
+- Added SQLite/ActiveRecord-compatible `INSERT ... DEFAULT VALUES` parsing,
+  planning, execution, default materialization, and regression coverage.
+- Normalized literal schema defaults before they reach physical rows so empty
+  strings and other scalar defaults are not persisted as AST wrapper objects.
+- Released `rubydb-activerecord` 0.1.1 with scalar default unwrapping for
+  ActiveRecord column metadata.
+
 ## 0.1.1 - 2026-09-09
 
 - Published the Rails connection configuration fixes for embedded database

data/adapters/activerecord/lib/active_record/connection_adapters/rubydb_adapter.rb

@@ -756,10 +756,15 @@ module ActiveRecord
 
       # ActiveRecord's generic Column deduplication is string-oriented. RubyDB
       # persists typed defaults, so serialize scalar defaults at this boundary
-      # and let ActiveRecord cast them through the column type map.
-      def rails_default_value(value)
-        value.is_a?(String) ? value : value.to_s
-      end
+      # and let ActiveRecord cast them through the column type map.
+      def rails_default_value(value)
+        # RubyDB exposes SQL defaults as AST literals. ActiveRecord expects
+        # the scalar payload when it builds its Column metadata; calling
+        # `to_s` on the wrapper would leak the Ruby object inspection into
+        # newly instantiated records.
+        value = value.value if value.respond_to?(:value) && !value.is_a?(String)
+        value.is_a?(String) ? value : value.to_s
+      end
 
       def sql_for_execution(sql)
         sql = sql.to_sql if sql.respond_to?(:to_sql)

data/adapters/activerecord/rubydb-activerecord.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name = "rubydb-activerecord"
-  spec.version = "0.1.0"
+  spec.version = "0.1.1"
   spec.authors = ["Aldane Hutchinson"]
   spec.email = ["aldanehutchinson5@gmail.com"]
 

data/adapters/activerecord/spec/rubydb_adapter_integration_spec.rb

@@ -51,7 +51,7 @@ RSpec.describe ActiveRecord::ConnectionAdapters::RubyDBAdapter do
     expect(result.first).to include("enabled" => false, "attempts" => 0)
   end
 
-  it "runs a Rails migration that creates a table, adds a column, and adds an index" do
+  it "runs a Rails migration that creates a table, adds a column, and adds an index" do
     migration = Class.new(ActiveRecord::Migration[migration_version]) do
       def change
         create_table :projects do |table|
@@ -74,10 +74,22 @@ RSpec.describe ActiveRecord::ConnectionAdapters::RubyDBAdapter do
     expect(schema).not_to include('t.integer "id"')
 
     migration.new.migrate(:down)
-    expect(connection.table_exists?(:projects)).to be(false)
-  end
-
-  it "executes an ActiveRecord association join with qualified filtering" do
+    expect(connection.table_exists?(:projects)).to be(false)
+  end
+
+  it "exposes scalar schema defaults to ActiveRecord" do
+    connection = ActiveRecord::Base.connection
+    connection.execute("CREATE TABLE settings (id INTEGER PRIMARY KEY, label VARCHAR(255) NOT NULL DEFAULT '')")
+
+    settings_model = Class.new(ActiveRecord::Base) do
+      self.table_name = "settings"
+    end
+
+    expect(settings_model.new.label).to eq("")
+    expect(settings_model.create!.reload.label).to eq("")
+  end
+
+  it "executes an ActiveRecord association join with qualified filtering" do
     stub_const("RubydbAccount", Class.new(ActiveRecord::Base) do
       self.table_name = "accounts"
       has_many :rubydb_projects, class_name: "RubydbProject", foreign_key: :account_id

data/lib/rubydb/execution/plan.rb

@@ -124,14 +124,15 @@ module RubyDB
       end
 
       class Insert < Plan
-        attr_reader :values, :rows, :on_conflict
-
-        def initialize(table_name, columns = [], values = [], rows: nil, on_conflict: nil)
-          super(:insert, table_name, columns)
-          @rows = rows || [values]
-          @values = @rows.first || []
-          @on_conflict = on_conflict
-        end
+        attr_reader :values, :rows, :on_conflict, :default_values
+
+        def initialize(table_name, columns = [], values = [], rows: nil, on_conflict: nil, default_values: false)
+          super(:insert, table_name, columns)
+          @rows = rows || [values]
+          @values = @rows.first || []
+          @on_conflict = on_conflict
+          @default_values = default_values
+        end
       end
 
       class Update < Plan

data/lib/rubydb/execution/planner.rb

@@ -154,12 +154,13 @@ module RubyDB
 
       def plan_insert(statement)
         Plan::Insert.new(
-          statement.table,
-          statement.columns,
-          statement.values,
-          rows: statement.rows,
-          on_conflict: statement.on_conflict
-        )
+          statement.table,
+          statement.columns,
+          statement.values,
+          rows: statement.rows,
+          on_conflict: statement.on_conflict,
+          default_values: statement.default_values?
+        )
       end
 
       def plan_update(statement)
@@ -186,10 +187,13 @@ module RubyDB
         plan
       end
 
-      def plan_create_table(statement)
-        columns = statement.columns.map do |col|
-          Catalog::Column.new(col.name, col.type_class, **col.options)
-        end
+      def plan_create_table(statement)
+        columns = statement.columns.map do |col|
+          options = col.options.dup
+          default = options[:default]
+          options[:default] = default.value if default.respond_to?(:value) && !default.is_a?(String)
+          Catalog::Column.new(col.name, col.type_class, **options)
+        end
 
         Plan::CreateTable.new(
           statement.name,

data/lib/rubydb/sql/ast/insert.rb

@@ -5,15 +5,17 @@ module RubyDB
     module AST
       # INSERT statement AST node
       class Insert < Node
-        attr_reader :table, :columns, :values, :rows, :on_conflict
-
-        def initialize(table, columns = [], values = [], rows: nil, on_conflict: nil, location: nil)
-          super(location: location)
-          @table = table
-          @columns = columns
-          @rows = rows || [values]
-          @values = @rows.first || []
-          @on_conflict = on_conflict
+        attr_reader :table, :columns, :values, :rows, :on_conflict
+        attr_reader :default_values
+
+        def initialize(table, columns = [], values = [], rows: nil, on_conflict: nil, default_values: false, location: nil)
+          super(location: location)
+          @table = table
+          @columns = columns
+          @rows = rows || [values]
+          @values = @rows.first || []
+          @on_conflict = on_conflict
+          @default_values = default_values
         end
 
         def accept(visitor)
@@ -24,8 +26,9 @@ module RubyDB
           Insert.new(
             @table,
             @columns.dup,
-            @values.map(&:clone), rows: @rows.map { |row| row.map(&:clone) }, on_conflict: @on_conflict,
-            location: @location
+            @values.map(&:clone), rows: @rows.map { |row| row.map(&:clone) }, on_conflict: @on_conflict,
+            default_values: @default_values,
+            location: @location
           )
         end
 
@@ -37,8 +40,12 @@ module RubyDB
             parts << "(#{@columns.join(", ")})"
           end
 
-          parts << "VALUES"
-          parts << @rows.map { |row| "(#{row.map(&:to_sql).join(", ")})" }.join(", ")
+          if @default_values
+            parts << "DEFAULT VALUES"
+          else
+            parts << "VALUES"
+            parts << @rows.map { |row| "(#{row.map(&:to_sql).join(", ")})" }.join(", ")
+          end
           parts << "ON CONFLICT DO NOTHING" if @on_conflict == :nothing
           if @on_conflict.is_a?(Hash) && @on_conflict[:action] == :update
             target = @on_conflict[:target].any? ? " (#{@on_conflict[:target].join(', ')})" : ""
@@ -56,9 +63,13 @@ module RubyDB
         end
 
         # Helper methods
-        def has_columns?
-          @columns.any?
-        end
+        def has_columns?
+          @columns.any?
+        end
+
+        def default_values?
+          @default_values
+        end
 
         def value_count
           @values.size

data/lib/rubydb/sql/parser.rb

@@ -539,21 +539,30 @@ module RubyDB
           expect(Token::Type::RPAREN)
         end
 
-        expect(Token::Type::VALUES)
-        rows = []
-        loop do
-          expect(Token::Type::LPAREN)
-          values = []
-          while true
-            values << parse_expression
-            break unless current_token&.type == Token::Type::COMMA
-            advance
-          end
-          expect(Token::Type::RPAREN)
-          rows << values
-          break unless current_token&.type == Token::Type::COMMA
-          advance
-        end
+        default_values = false
+        if current_token&.type == Token::Type::DEFAULT
+          advance
+          expect(Token::Type::VALUES)
+          default_values = true
+        else
+          expect(Token::Type::VALUES)
+        end
+        rows = default_values ? [[]] : []
+        unless default_values
+          loop do
+            expect(Token::Type::LPAREN)
+            values = []
+            while true
+              values << parse_expression
+              break unless current_token&.type == Token::Type::COMMA
+              advance
+            end
+            expect(Token::Type::RPAREN)
+            rows << values
+            break unless current_token&.type == Token::Type::COMMA
+            advance
+          end
+        end
 
         on_conflict = nil
         if current_token&.type == Token::Type::ON
@@ -589,8 +598,9 @@ module RubyDB
             raise ParserError, "Expected NOTHING or UPDATE after ON CONFLICT DO"
           end
         end
-        AST::Insert.new(table, columns, rows.first || [], rows: rows, on_conflict: on_conflict)
-      end
+        AST::Insert.new(table, columns, rows.first || [], rows: rows, on_conflict: on_conflict,
+                        default_values: default_values)
+      end
 
       def parse_update
         expect(Token::Type::UPDATE)

data/lib/rubydb/storage/engine.rb

@@ -675,16 +675,32 @@ module RubyDB
       end
 
       # Row operations
-      def insert_row(table_name, columns, values)
-        ensure_writable!
-        table_name = resolve_table_name(table_name)
-        @lock.synchronize do
+      def insert_row(table_name, columns, values)
+        ensure_writable!
+        table_name = resolve_table_name(table_name)
+        @lock.synchronize do
           @stats[:row_inserts] += 1
           
-          metadata = @table_metadata[table_name]
-          raise DatabaseError, "Table '#{table_name}' does not exist" unless metadata
-
-          # Rails and other SQL clients omit an INTEGER primary key on insert
+          metadata = @table_metadata[table_name]
+          raise DatabaseError, "Table '#{table_name}' does not exist" unless metadata
+
+          # SQL INSERT may omit columns entirely (DEFAULT VALUES) or omit
+          # only selected columns. Materialize declared defaults before
+          # constraint validation so NOT NULL defaults are valid and the
+          # physical row contains scalar values rather than AST wrappers.
+          if values.is_a?(Hash)
+            values = values.dup
+            columns.each do |column|
+              present = values.key?(column.name) || values.key?(column.name.to_sym)
+              next if present || !column.has_default?
+
+              default = column.default
+              default = default.value if default.respond_to?(:value)
+              values[column.name] = default
+            end
+          end
+
+          # Rails and other SQL clients omit an INTEGER primary key on insert
           # and expect the database to allocate it. Keep allocation in the
           # engine so embedded and server connections have identical behavior.
           if values.is_a?(Hash)

data/lib/rubydb/storage/visibility_map.rb

@@ -686,11 +686,13 @@ module RubyDB
                 end
               end
               
-              @active_transactions = parsed[:active_transactions] || {}
-              @committed_transactions = Set.new(parsed[:committed_transactions] || [])
-              @aborted_transactions = Set.new(parsed[:aborted_transactions] || [])
-              @next_version_id = parsed[:next_version_id] || 1
-              @row_version_chains = parsed[:row_version_chains] || {}
+              @active_transactions = normalize_numeric_keyed_hash(parsed[:active_transactions])
+              @committed_transactions = Set.new(parsed[:committed_transactions] || [])
+              @aborted_transactions = Set.new(parsed[:aborted_transactions] || [])
+              @next_version_id = parsed[:next_version_id] || 1
+              @row_version_chains = normalize_numeric_keyed_hash(parsed[:row_version_chains]) do |versions|
+                Array(versions).map(&:to_i)
+              end
               
               # Clean up any invalid data
               @active_transactions.each do |tx_id, info|
@@ -727,24 +729,35 @@ module RubyDB
             
             # Write to a temp file first, then rename
             temp_path = "#{visibility_path}.tmp"
-            File.write(temp_path, JSON.generate(data))
-            FileUtils.mv(temp_path, visibility_path)
-            
-            true
-          rescue => e
-            false
-          end
-        end
-      end
+            File.write(temp_path, JSON.generate(data))
+            FileUtils.mv(temp_path, visibility_path)
+            
+            true
+          rescue => e
+            File.delete(temp_path) if defined?(temp_path) && File.file?(temp_path)
+            raise StorageError, "Failed to flush visibility map: #{e.message}"
+          end
+        end
+      end
 
       # Remove a row from disk storage
       def remove_row_from_disk(row_id)
         true
       end
 
-      def remember_version(row_id, info)
-        @version_history[row_id][info[:version].to_i] = info.dup
-      end
+      def remember_version(row_id, info)
+        @version_history[row_id][info[:version].to_i] = info.dup
+      end
+
+      # JSON object keys are strings. Normalize numeric-keyed runtime maps on
+      # load so a reopened database cannot accumulate both "1" and 1 keys.
+      def normalize_numeric_keyed_hash(value)
+        normalized = {}
+        (value || {}).each do |key, entry|
+          normalized[key.to_s.to_i] = block_given? ? yield(entry) : entry
+        end
+        normalized
+      end
 
       def normalize_loaded_info(info)
         info.each_with_object({}) do |(key, value), normalized|

data/lib/rubydb/version.rb

@@ -11,13 +11,13 @@ module RubyDB
   # - MAJOR: Incompatible API changes
   # - MINOR: Backwards-compatible new functionality
   # - PATCH: Backwards-compatible bug fixes
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 
   # Version components for easy access
   module Version
     MAJOR = 0
     MINOR = 1
-    PATCH = 1
+    PATCH = 3
     PRE = nil  # e.g., "alpha", "beta", "rc1"
 
     def self.to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubydb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Aldane Hutchinson