rubydb 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b474095677d024d7aae488865411803476f0c5040d75fba89b063f0e9679a3d9
-  data.tar.gz: 18a4bbf0d5744c8e980a50ee4b6ee6a75133f299a96eabd458ca1bf40554bb78
+  metadata.gz: 5cfc85dc4d3cfca89bd7d89335e4bf887fbfca212836f8a62d92a70a63f0f284
+  data.tar.gz: 9869f03b9da1a7e0cfd0c01f1f22ae9b5ba0e2b12eedaeac72e1b4deab878a0b
 SHA512:
-  metadata.gz: a719c2d1f1de9e98ac56a45ab3956ce5b216dd1987e510688af3d71cfe131f98463cbab9525ca96ef2cc34a4457d3475b65016f8595a9f4f3c9b5f621a503247
-  data.tar.gz: b0f0d139f3da9c4eb8bea8805cbefeff6c11dae8dcf47853b8a157b402e4c10103bbf8b94a84a8ef1d80c7fe07a63e2effa042bff21d6ac3591b7340ff6c1b55
+  metadata.gz: 76650c2403e26244619687eb6146bb7a1561d3764d664094a6deb94e02566924c60979f481aca972be026987775f8c9b68ed02804d15e583f885528e02833613
+  data.tar.gz: 60c894fde163c1a47ed84aa2c2d8b374a9b6c70f3d810feb7ca419a06aa2cb5e6026d8aa278d27ed89ad4a83b48405c31137671f1d2dab7240d0efc36b367de8

data/CHANGELOG.md

@@ -3,7 +3,7 @@
 All notable changes to RubyDB are documented here. Versions follow
 [Semantic Versioning](https://semver.org/).
 
-## Unreleased
+## Unreleased
 
 - Added full developer, troubleshooting, debugging, production operations,
   Rails compatibility, and SQL compatibility guides with repository maps,
@@ -21,9 +21,25 @@ All notable changes to RubyDB are documented here. Versions follow
 - Added a full CLI guide and cheat sheet covering lifecycle, server operation,
   shell, migrations, backup/restore, snapshots, branches, inspection, doctor,
   vacuum, maintenance, and release workflows.
-- Clarified the tested common SQLite-style profile and production limits.
-
-## 0.1.0 - 2026-09-07
+- Clarified the tested common SQLite-style profile and production limits.
+
+## 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
+  paths and `rubydb://`/`rubydbs://` connection URLs.
+- Kept the patch release compatible with the RubyDB 0.1.x adapter dependency
+  range.
+
+## 0.1.0 - 2026-09-07
 
 - Initial public release candidate.
 - Includes the embedded engine, ActiveRecord adapter, backup/recovery, WAL,

data/adapters/activerecord/README.md

@@ -1,9 +1,133 @@
-# RubyDB ActiveRecord adapter
-
-The `rubydb-activerecord` gem connects Rails applications to RubyDB through
-ActiveRecord. It supports embedded RubyDB engines and network connections.
-
-For an executable Rails 7.2 example, see
-[`examples/rails_app`](../../examples/rails_app). The example includes a
-database configuration, migration, model/controller, browser form, and a
-smoke test that exercises the adapter against a real RubyDB engine.
+# rubydb-activerecord
+
+`rubydb-activerecord` is the ActiveRecord adapter for [RubyDB](https://github.com/aldanedev-create/rubydb). It lets Rails applications use RubyDB through the normal model, relation, transaction, migration, schema, and connection-pool APIs.
+
+This gem is an adapter to RubyDB's SQL engine. It is not a PostgreSQL, MySQL, or SQLite wire-protocol compatibility layer, and it does not make arbitrary dialect-specific SQL portable. Validate your application's queries and migrations against the exact Ruby, Rails, RubyDB, operating-system, and deployment versions you will run.
+
+## Requirements
+
+- Ruby 3.3 or newer
+- RubyDB 0.1.x
+- ActiveRecord 7.1, 7.2, or 8.0 (the dependency range is `>= 7.1`, `< 8.1`)
+
+## Install
+
+Add both gems to the Rails application's `Gemfile`:
+
+```ruby
+gem "rubydb"
+gem "rubydb-activerecord"
+```
+
+Then run:
+
+```sh
+bundle install
+```
+
+The adapter registers itself under the `rubydb` adapter name when it is
+required by Bundler. For a manually loaded application, require it explicitly:
+
+```ruby
+require "rubydb"
+require "active_record/connection_adapters/rubydb_adapter"
+```
+
+## Development: embedded database
+
+Embedded mode is convenient for local development and a controlled
+single-process application. The process owns the database file:
+
+```yaml
+# config/database.yml
+development:
+  adapter: rubydb
+  embedded: true
+  database: <%= Rails.root.join("tmp/development.rdb") %>
+```
+
+Run migrations normally:
+
+```sh
+bin/rails db:migrate
+bin/rails console
+bin/rails server
+```
+
+Do not open the same embedded path from multiple independent Rails processes.
+For multiple web workers, job workers, or hosts, use a managed RubyDB server.
+
+## Production: managed server
+
+Use a network connection when the application has more than one process or
+when the database must be operated independently from the application. Keep
+credentials in the platform secret manager and map them into `database.yml`:
+
+```yaml
+# config/database.yml
+production:
+  adapter: rubydb
+  embedded: false
+  url: <%= ENV.fetch("RUBYDB_URL") %>
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS", "5") %>
+  timeout: <%= ENV.fetch("RUBYDB_TIMEOUT", "30") %>
+```
+
+Use `rubydb://` for a plain private-network connection or `rubydbs://` for TLS:
+
+```text
+rubydbs://app_user:URL_ENCODED_PASSWORD@db.internal.example:7432/app?verify_peer=true&ca_file=%2Fetc%2Frubydb%2Ftls%2Fca.crt
+```
+
+The server must be deployed separately with persistent storage,
+authentication, TLS, backups, monitoring, resource limits, and a tested
+restore procedure. Size its connection limit for the total Rails pool across
+all application processes, with headroom for administration and replication.
+See the repository's [Rails database configuration](../../docs/rails/database-yml.md)
+and [production guidance](../../docs/rails/production.md).
+
+## Adapter surface
+
+The release test suite exercises:
+
+- ActiveRecord CRUD, binds, quoted identifiers, type casting, and false/zero values
+- transactions and savepoints
+- `joins`, qualified filters, ordering, eager loading, and nested associations
+- table/column/index/foreign-key introspection
+- Rails migrations, defaults, indexes, schema dumps, and populated-table changes
+- embedded and network connection setup paths
+
+RubyDB currently has documented SQL and schema boundaries. Features outside
+the tested surface—such as dialect-specific extensions, generated columns,
+complex table rebuilds, or application-specific Arel—need explicit tests
+before deployment.
+
+## Validation
+
+Run the adapter's integration suite from this directory:
+
+```sh
+bundle install
+bundle exec rspec spec
+```
+
+Run the repository's Rails-focused checks from the repository root:
+
+```sh
+bundle exec rspec spec/rails_adapter_live_engine_spec.rb spec/rails_adapter_schema_dump_spec.rb spec/rails_schema_statements_spec.rb
+```
+
+Before a production release, run a real migration and smoke query through the
+same server URL, TLS settings, pool size, and secret-management path used by
+the deployment. Keep a verified backup before migrations and rehearse restore
+and rollback on a representative copy.
+
+## Support and release policy
+
+The adapter version is coupled to the RubyDB 0.1.x release line. Pin both gems
+in the application lockfile, upgrade them together, and run the adapter suite
+before upgrading Rails. Report reproducible adapter or engine issues at the
+project's [issue tracker](https://github.com/aldanedev-create/rubydb/issues)
+with Ruby/Rails/RubyDB versions, the SQL or migration involved, and a redacted
+configuration summary. Never include passwords, connection URLs, database
+files, or private keys in reports.

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)
@@ -775,9 +780,15 @@ module ActiveRecord
             column.is_a?(Hash) ? (column[:name] || column["name"] || column) : column
           end.map(&:to_s)
         end
-        values = rows.map do |row|
-          columns.map { |column| row[column] || row[column.to_sym] }
-        end
+        values = rows.map do |row|
+          columns.map do |column|
+            if row.respond_to?(:key?) && row.key?(column)
+              row[column]
+            elsif row.respond_to?(:key?) && row.key?(column.to_sym)
+              row[column.to_sym]
+            end
+          end
+        end
         ActiveRecord::Result.new(columns, values)
       end
 

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"]
 
@@ -10,12 +10,17 @@ Gem::Specification.new do |spec|
   spec.description = "ActiveRecord adapter for the RubyDB database"
   spec.homepage = "https://github.com/aldanedev-create/rubydb"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.2.0"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-
-  spec.files = Dir.glob("lib/**/*.rb") + %w[README.md]
+  # rubydb itself requires Ruby 3.3 or newer. Keep the adapter's runtime
+  # contract aligned so Bundler cannot select an unsupported combination.
+  spec.required_ruby_version = ">= 3.3.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "#{spec.homepage}/tree/main/adapters/activerecord"
+  spec.metadata["bug_tracker_uri"] = "https://github.com/aldanedev-create/rubydb/issues"
+  spec.metadata["changelog_uri"] = "https://github.com/aldanedev-create/rubydb/blob/main/CHANGELOG.md"
+  spec.metadata["documentation_uri"] = "https://github.com/aldanedev-create/rubydb/tree/main/docs"
+
+  spec.files = Dir.glob("lib/**/*.rb") + %w[README.md rubydb-activerecord.gemspec]
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activerecord", ">= 7.1", "< 8.1"

data/adapters/activerecord/spec/rubydb_adapter_integration_spec.rb

@@ -31,17 +31,27 @@ RSpec.describe ActiveRecord::ConnectionAdapters::RubyDBAdapter do
     end
   end
 
-  it "creates and finds an ActiveRecord model through the embedded engine" do
+  it "creates and finds an ActiveRecord model through the embedded engine" do
     connection = ActiveRecord::Base.connection
     connection.execute("CREATE TABLE accounts (id INTEGER PRIMARY KEY, email VARCHAR(255) NOT NULL, active BOOLEAN NOT NULL)")
 
     created = model.create!(id: 1, email: "ada@example.test", active: true)
     loaded = model.find(created.id)
 
-    expect(loaded.attributes).to include("id" => 1, "email" => "ada@example.test", "active" => true)
-  end
-
-  it "runs a Rails migration that creates a table, adds a column, and adds an index" do
+    expect(loaded.attributes).to include("id" => 1, "email" => "ada@example.test", "active" => true)
+  end
+
+  it "preserves false and zero values in ActiveRecord results" do
+    connection = ActiveRecord::Base.connection
+    connection.execute("CREATE TABLE flags (id INTEGER PRIMARY KEY, enabled BOOLEAN NOT NULL, attempts INTEGER NOT NULL)")
+    connection.execute("INSERT INTO flags (id, enabled, attempts) VALUES (1, FALSE, 0)")
+
+    result = connection.exec_query("SELECT enabled, attempts FROM flags WHERE id = 1")
+
+    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
     migration = Class.new(ActiveRecord::Migration[migration_version]) do
       def change
         create_table :projects do |table|
@@ -64,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/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.0"
+  VERSION = "0.1.2"
 
   # Version components for easy access
   module Version
     MAJOR = 0
     MINOR = 1
-    PATCH = 0
+    PATCH = 2
     PRE = nil  # e.g., "alpha", "beta", "rc1"
 
     def self.to_s
@@ -30,4 +30,4 @@ module RubyDB
       version
     end
   end
-end
+end

metadata

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