rubydb 0.1.0

data/lib/rubydb/rails/result.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Rails
+    # Result - Query result adapter for Rails
+    class Result
+      include Enumerable
+
+      attr_reader :columns, :rows, :row_count, :affected_rows
+      attr_reader :command_tag, :statement_id, :row_id
+
+      def initialize(result)
+        @columns = result[:columns] || result[:column_names] || []
+        @rows = result[:rows] || []
+        @row_count = result[:row_count] || @rows.size
+        @affected_rows = result[:affected_rows] || 0
+        @command_tag = result[:command_tag] || "SELECT"
+        @statement_id = result[:statement_id]
+        @row_id = result[:row_id]
+        @transaction_id = result[:transaction_id]
+        @success = result[:success] != false
+        @error = result[:error]
+        @execution_time = result[:execution_time_ms] || 0
+        @position = 0
+      end
+
+      def success?
+        @success
+      end
+
+      def error?
+        @success == false && !@error.nil?
+      end
+
+      def empty?
+        @rows.empty?
+      end
+
+      def first
+        @rows.first
+      end
+
+      def last
+        @rows.last
+      end
+
+      def [](index)
+        @rows[index]
+      end
+
+      def each(&block)
+        @rows.each(&block)
+      end
+
+      def each_with_index(&block)
+        @rows.each_with_index(&block)
+      end
+
+      def each_row(&block)
+        @rows.each(&block)
+      end
+
+      def each_column(&block)
+        @columns.each(&block)
+      end
+
+      def column_names
+        @columns.map do |column|
+          column.is_a?(Hash) ? (column[:name] || column["name"] || column) : column
+        end
+      end
+
+      def column_types
+        @columns.map { |c| c[:type] || "text" }
+      end
+
+      def to_a
+        @rows
+      end
+
+      def to_hash
+        {
+          columns: @columns,
+          rows: @rows,
+          row_count: @row_count,
+          affected_rows: @affected_rows,
+          command_tag: @command_tag,
+          success: @success,
+          error: @error,
+          execution_time_ms: @execution_time
+        }
+      end
+
+      def to_ary
+        @rows
+      end
+
+      def size
+        @row_count
+      end
+
+      alias length size
+      alias count size
+
+      def inspect
+        rows_preview = @rows.first(3).map(&:inspect).join(", ")
+        more = @rows.size > 3 ? "..." : ""
+        "#<Result rows=#{@row_count} columns=#{@columns.size} data=[#{rows_preview}#{more}]>"
+      end
+
+      def to_s
+        if @rows.empty?
+          "Result: #{@command_tag} (0 rows)"
+        else
+          "Result: #{@command_tag} (#{@row_count} rows)"
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/rails/schema_statements.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Rails
+    # SchemaStatements - Schema statement methods for Rails
+    module SchemaStatements
+      # Collects a Rails-style create_table block into executable SQL.
+      class TableDefinition
+        TYPE_METHODS = %i[bigint binary boolean date datetime decimal float integer json smallint string text time timestamp uuid].freeze
+        attr_reader :columns, :constraints
+
+        def initialize(adapter, table_name, options = {})
+          @adapter = adapter
+          @table_name = table_name
+          @options = options
+          @columns = []
+          @constraints = []
+        end
+
+        def column(name, type, options = {})
+          @columns << RubyDB::Catalog::Column.new(name, type, **options)
+          self
+        end
+
+        def timestamps(options = {})
+          column(:created_at, :timestamp, options)
+          column(:updated_at, :timestamp, options)
+        end
+
+        def primary_key(name = :id, type = :integer, options = {})
+          column(name, type, options.merge(primary_key: true, null: false))
+        end
+
+        # Support Rails' common `t.references :repository, foreign_key: true`
+        # shorthand while keeping the generated SQL within RubyDB's schema
+        # contract. Index creation remains an explicit `add_index` operation.
+        def references(name, options = {})
+          reference_name = name.to_s
+          column_name = options[:column] || "#{reference_name}_id"
+          column_options = options.slice(:null, :default, :limit, :precision, :scale)
+          column(column_name, options[:type] || :integer, column_options)
+
+          return self unless options[:foreign_key]
+
+          reference_table = options[:to_table] || pluralize_reference(reference_name)
+          @constraints << RubyDB::Constraints::ForeignKeyConstraint.new(
+            @table_name,
+            column_name,
+            reference_table,
+            options[:primary_key] || :id,
+            options.slice(:name, :on_delete, :on_update)
+          )
+          self
+        end
+
+        def pluralize_reference(name)
+          return name if name.end_with?("s")
+          return "#{name[0...-1]}ies" if name.end_with?("y")
+
+          "#{name}s"
+        end
+        private :pluralize_reference
+
+        def method_missing(method, *args, &block)
+          if TYPE_METHODS.include?(method)
+            name = args.shift
+            options = args.shift || {}
+            return column(name, method, options)
+          end
+          super
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          TYPE_METHODS.include?(method) || method == :references || super
+        end
+      end
+
+      def create_table(table_name, options = {})
+        columns = []
+        constraints = []
+
+        # Rails creates an integer primary key unless a migration explicitly
+        # requests id: false. Keep the same default for both the standalone
+        # RubyDB adapter and ActiveRecord's migration DSL.
+        unless options[:id] == false
+          primary_key_name = options[:primary_key] || :id
+          primary_key_type = options[:id].is_a?(Symbol) ? options[:id] : :integer
+          columns << RubyDB::Catalog::Column.new(primary_key_name, primary_key_type, primary_key: true, null: false)
+        end
+
+        if block_given?
+          table_definition = TableDefinition.new(self, table_name, options)
+          yield table_definition
+          columns.concat(table_definition.columns)
+          constraints = table_definition.constraints
+        end
+
+        sql = build_create_table_sql(table_name, columns, constraints, options)
+        execute(sql)
+      end
+
+      def drop_table(table_name, options = {})
+        sql = "DROP TABLE"
+        sql << " IF EXISTS" if options[:if_exists]
+        sql << " #{quote_table_name(table_name)}"
+        sql << " CASCADE" if options[:cascade]
+        execute(sql)
+      end
+
+      def add_column(table_name, column_name, type, options = {})
+        sql = "ALTER TABLE #{quote_table_name(table_name)}"
+        sql << " ADD COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options)}"
+
+        if options[:null] == false
+          sql << " NOT NULL"
+        end
+
+        if options.key?(:default)
+          sql << " DEFAULT #{quote_default(options[:default])}"
+        end
+
+        if options[:primary_key]
+          sql << " PRIMARY KEY"
+        end
+
+        execute(sql)
+      end
+
+      def remove_column(table_name, column_name, type = nil, options = {})
+        sql = "ALTER TABLE #{quote_table_name(table_name)}"
+        sql << " DROP COLUMN #{quote_column_name(column_name)}"
+        sql << " CASCADE" if options[:cascade]
+        execute(sql)
+      end
+
+      def change_column(table_name, column_name, type, options = {})
+        sql = "ALTER TABLE #{quote_table_name(table_name)}"
+        sql << " ALTER COLUMN #{quote_column_name(column_name)}"
+        sql << " TYPE #{type_to_sql(type, options)}"
+        execute(sql)
+
+        if options[:null] == false
+          sql = "ALTER TABLE #{quote_table_name(table_name)}"
+          sql << " ALTER COLUMN #{quote_column_name(column_name)} SET NOT NULL"
+          execute(sql)
+        elsif options[:null] == true
+          sql = "ALTER TABLE #{quote_table_name(table_name)}"
+          sql << " ALTER COLUMN #{quote_column_name(column_name)} DROP NOT NULL"
+          execute(sql)
+        end
+
+        return unless options.key?(:default)
+
+        sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)}"
+        if options[:default].nil?
+          sql << " DROP DEFAULT"
+        else
+          sql << " SET DEFAULT #{quote_default(options[:default])}"
+        end
+        execute(sql)
+      end
+
+      def rename_column(table_name, column_name, new_column_name)
+        sql = "ALTER TABLE #{quote_table_name(table_name)}"
+        sql << " RENAME COLUMN #{quote_column_name(column_name)}"
+        sql << " TO #{quote_column_name(new_column_name)}"
+        execute(sql)
+      end
+
+      def add_index(table_name, column_name, options = {})
+        index_name = options[:name] || "idx_#{table_name}_#{Array(column_name).join('_')}"
+        sql = +"CREATE"
+        sql << " UNIQUE" if options[:unique]
+        sql << " INDEX #{quote_column_name(index_name)}"
+        sql << " ON #{quote_table_name(table_name)}"
+        sql << " (#{Array(column_name).map { |c| quote_column_name(c) }.join(', ')})"
+        execute(sql)
+      end
+
+      def remove_index(table_name, options = {})
+        index_name = options[:name]
+        if index_name.nil?
+          column_name = options[:column] || options[:columns]
+          index_name = "idx_#{table_name}_#{Array(column_name).join('_')}"
+        end
+
+        sql = "DROP INDEX #{quote_column_name(index_name)}"
+        sql << " ON #{quote_table_name(table_name)}"
+        execute(sql)
+      end
+
+      def add_foreign_key(from_table, to_table, options = {})
+        fk_name = options[:name] || "fk_#{from_table}_to_#{to_table}"
+        sql = "ALTER TABLE #{quote_table_name(from_table)}"
+        sql << " ADD CONSTRAINT #{quote_column_name(fk_name)}"
+        column = options[:column] || "#{to_table.to_s.sub(/s\z/, '')}_id"
+        sql << " FOREIGN KEY (#{quote_column_name(column)})"
+        sql << " REFERENCES #{quote_table_name(to_table)}"
+        sql << " (#{quote_column_name(options[:primary_key] || :id)})"
+        execute(sql)
+      end
+
+      def remove_foreign_key(from_table, options = {})
+        fk_name = options[:name] || "fk_#{from_table}_to_#{options[:to_table]}"
+        sql = "ALTER TABLE #{quote_table_name(from_table)}"
+        sql << " DROP CONSTRAINT #{quote_column_name(fk_name)}"
+        execute(sql)
+      end
+
+      def add_timestamps(table_name, options = {})
+        add_column(table_name, :created_at, :timestamp, options)
+        add_column(table_name, :updated_at, :timestamp, options)
+      end
+
+      def remove_timestamps(table_name, options = {})
+        remove_column(table_name, :updated_at, nil, options)
+        remove_column(table_name, :created_at, nil, options)
+      end
+
+      def change_column_null(table_name, column_name, null, default = nil)
+        if default
+          sql = "UPDATE #{quote_table_name(table_name)}"
+          sql << " SET #{quote_column_name(column_name)} = #{quote(default)}"
+          sql << " WHERE #{quote_column_name(column_name)} IS NULL"
+          execute(sql)
+        end
+
+        sql = "ALTER TABLE #{quote_table_name(table_name)}"
+        sql << " ALTER COLUMN #{quote_column_name(column_name)}"
+        sql << (null ? " DROP" : " SET") + " NOT NULL"
+        execute(sql)
+      end
+
+      def change_column_default(table_name, column_name, default)
+        sql = "ALTER TABLE #{quote_table_name(table_name)}"
+        sql << " ALTER COLUMN #{quote_column_name(column_name)}"
+        if default.nil?
+          sql << " DROP DEFAULT"
+        else
+          sql << " SET DEFAULT #{quote(default)}"
+        end
+        execute(sql)
+      end
+
+      private
+
+      def type_to_sql(type, options = {})
+        case type.to_sym
+        when :integer
+          "INTEGER"
+        when :bigint
+          "BIGINT"
+        when :smallint
+          "SMALLINT"
+        when :float
+          "FLOAT"
+        when :decimal
+          precision = options[:precision] || 10
+          scale = options[:scale] || 2
+          "DECIMAL(#{precision}, #{scale})"
+        when :boolean
+          "BOOLEAN"
+        when :text
+          "TEXT"
+        when :string
+          limit = options[:limit] || 255
+          "VARCHAR(#{limit})"
+        when :binary
+          "BLOB"
+        when :date
+          "DATE"
+        when :time
+          "TIME"
+        when :datetime, :timestamp
+          "TIMESTAMP"
+        when :json
+          "JSON"
+        when :uuid
+          "UUID"
+        else
+          "TEXT"
+        end
+      end
+
+      def build_create_table_sql(table_name, columns, constraints, options)
+        sql = +"CREATE TABLE"
+        sql << " IF NOT EXISTS" if options[:if_not_exists]
+        sql << " #{quote_table_name(table_name)} ("
+
+        col_defs = columns.map do |col|
+          definition = "#{quote_column_name(col.name)} #{type_to_sql(col.type, col.options)}"
+          definition << " PRIMARY KEY" if col.options[:primary_key]
+          definition << " NOT NULL" if col.options[:null] == false
+          definition << " DEFAULT #{quote(col.options[:default])}" if col.options.key?(:default)
+          definition
+        end
+
+        constraints.each do |constraint|
+          col_defs << constraint.to_sql
+        end
+
+        sql << col_defs.join(", ")
+        sql << ")"
+        sql
+      end
+
+      def quote(value)
+        case value
+        when String
+          "'#{value.gsub("'", "''")}'"
+        when Numeric
+          value.to_s
+        when TrueClass
+          "TRUE"
+        when FalseClass
+          "FALSE"
+        when nil
+          "NULL"
+        when Date, Time, DateTime
+          "'#{value.iso8601}'"
+        else
+          "'#{value.to_s.gsub("'", "''")}'"
+        end
+      end
+
+      def quote_table_name(name)
+        "\"#{name.to_s}\""
+      end
+
+      def quote_column_name(name)
+        "\"#{name.to_s}\""
+      end
+
+      def quote_default(value)
+        quote(value)
+      end
+    end
+  end
+end

data/lib/rubydb/rails/transaction.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Rails
+    # Transaction - Transaction management for Rails
+    class Transaction
+      attr_reader :connection, :depth, :state
+
+      def initialize(connection)
+        @connection = connection
+        @depth = 0
+        @state = :active
+        @savepoints = []
+        @lock = Mutex.new
+      end
+
+      def begin
+        @lock.synchronize do
+          return false if @state != :active
+
+          @connection.begin_db_transaction
+          @depth += 1
+          true
+        end
+      end
+
+      def commit
+        @lock.synchronize do
+          return false if @state == :committed || @state == :rolled_back
+
+          @connection.commit_db_transaction
+          @depth -= 1
+          @state = :committed if @depth == 0
+          true
+        end
+      end
+
+      def rollback
+        @lock.synchronize do
+          return false if @state == :committed || @state == :rolled_back
+
+          @connection.rollback_db_transaction
+          @depth = 0
+          @state = :rolled_back
+          true
+        end
+      end
+
+      def create_savepoint(name)
+        @lock.synchronize do
+          return false if @state != :active
+
+          @connection.execute("SAVEPOINT #{name}")
+          @savepoints << name
+          true
+        end
+      end
+
+      def rollback_to_savepoint(name)
+        @lock.synchronize do
+          return false if @state != :active
+
+          unless @savepoints.include?(name)
+            return false
+          end
+
+          @connection.execute("ROLLBACK TO SAVEPOINT #{name}")
+          @savepoints = @savepoints[0...@savepoints.index(name)]
+          true
+        end
+      end
+
+      def release_savepoint(name)
+        @lock.synchronize do
+          return false if @state != :active
+
+          unless @savepoints.include?(name)
+            return false
+          end
+
+          @connection.execute("RELEASE SAVEPOINT #{name}")
+          @savepoints.delete(name)
+          true
+        end
+      end
+
+      def active?
+        @state == :active
+      end
+
+      def in_progress?
+        @depth > 0
+      end
+
+      def to_hash
+        {
+          depth: @depth,
+          state: @state,
+          savepoints: @savepoints,
+          in_progress: in_progress?
+        }
+      end
+    end
+  end
+end

data/lib/rubydb/rails/type.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Rails
+    # Type - Maps Ruby/Rails types to RubyDB types
+    class Type
+      TYPE_MAPPING = {
+        integer: :integer,
+        bigint: :bigint,
+        smallint: :smallint,
+        float: :float,
+        decimal: :decimal,
+        boolean: :boolean,
+        text: :text,
+        string: :varchar,
+        blob: :blob,
+        date: :date,
+        time: :time,
+        datetime: :timestamp,
+        timestamp: :timestamp,
+        json: :json,
+        uuid: :uuid,
+        primary_key: :integer,
+        references: :integer
+      }
+
+      RUBYDB_TO_RAILS = {
+        integer: :integer,
+        bigint: :bigint,
+        smallint: :smallint,
+        float: :float,
+        decimal: :decimal,
+        boolean: :boolean,
+        text: :text,
+        varchar: :string,
+        char: :string,
+        blob: :binary,
+        date: :date,
+        time: :time,
+        timestamp: :datetime,
+        json: :json,
+        uuid: :uuid,
+        null: :null
+      }
+
+      def self.to_rubydb(rails_type, options = {})
+        type = TYPE_MAPPING[rails_type.to_sym]
+        return type if type
+
+        # Handle special cases
+        case rails_type.to_s
+        when "primary_key"
+          :integer
+        when "references"
+          :integer
+        when "jsonb"
+          :json
+        when "binary"
+          :blob
+        when "datetime"
+          :timestamp
+        when "timestamp"
+          :timestamp
+        else
+          :text
+        end
+      end
+
+      def self.to_rails(rubydb_type)
+        RUBYDB_TO_RAILS[rubydb_type.to_sym] || :string
+      end
+
+      def self.native_database_types
+        {
+          primary_key: "INTEGER PRIMARY KEY AUTOINCREMENT",
+          string: { name: "VARCHAR", limit: 255 },
+          text: { name: "TEXT" },
+          integer: { name: "INTEGER" },
+          bigint: { name: "BIGINT" },
+          float: { name: "FLOAT" },
+          decimal: { name: "DECIMAL", precision: 10, scale: 2 },
+          datetime: { name: "TIMESTAMP" },
+          timestamp: { name: "TIMESTAMP" },
+          time: { name: "TIME" },
+          date: { name: "DATE" },
+          binary: { name: "BLOB" },
+          boolean: { name: "BOOLEAN" },
+          json: { name: "JSON" },
+          uuid: { name: "UUID" }
+        }
+      end
+
+      def self.serialize(value, type)
+        case type.to_sym
+        when :integer, :bigint, :smallint
+          value.to_i if value
+        when :float, :decimal
+          value.to_f if value
+        when :boolean
+          !!value
+        when :json
+          value.is_a?(String) ? JSON.parse(value) : value
+        when :timestamp, :datetime
+          value.is_a?(String) ? Time.parse(value) : value
+        when :date
+          value.is_a?(String) ? Date.parse(value) : value
+        else
+          value
+        end
+      end
+
+      def self.deserialize(value, type)
+        case type.to_sym
+        when :json
+          value.is_a?(Hash) ? value.to_json : value
+        when :timestamp, :datetime
+          value.is_a?(Time) ? value.iso8601 : value
+        when :date
+          value.is_a?(Date) ? value.iso8601 : value
+        else
+          value
+        end
+      end
+    end
+  end
+end