rubydb 0.1.0

data/lib/rubydb/catalog/column.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Catalog
+    # Column - represents a table column
+    class Column
+      attr_reader :name, :type, :options
+      attr_accessor :default, :nullable, :position
+
+      def initialize(name, type, **options)
+        @name = name
+        @type = type
+        @options = options
+        @default = options[:default]
+        @nullable = options.fetch(:null, true)
+        @position = options[:position]
+        @primary_key = options[:primary_key] || false
+        @unique = options[:unique] || false
+        @precision = options[:precision]
+        @scale = options[:scale]
+        @limit = options[:limit]
+        @created_at = Time.now
+        @modified_at = Time.now
+      end
+
+      def primary_key?
+        @primary_key
+      end
+
+      def unique?
+        @unique
+      end
+
+      def nullable?
+        @nullable
+      end
+
+      def has_default?
+        !@default.nil?
+      end
+
+      def type_class
+        case @type
+        when Symbol
+          @type
+        when Hash
+          @type[:type]
+        else
+          @type
+        end
+      end
+
+      def type_params
+        case @type
+        when Hash
+          @type.reject { |k| k == :type }
+        else
+          {}
+        end
+      end
+
+      def to_s
+        "#{@name} #{@type.to_s.upcase}"
+      end
+
+      def inspect
+        "#<Column name=#{@name} type=#{@type} primary_key=#{@primary_key} nullable=#{@nullable}>"
+      end
+
+      # --- Serialization ---
+
+      def serialize
+        {
+          name: @name,
+          type: @type,
+          default: @default,
+          nullable: @nullable,
+          position: @position,
+          primary_key: @primary_key,
+          unique: @unique,
+          precision: @precision,
+          scale: @scale,
+          limit: @limit,
+          created_at: @created_at.iso8601,
+          modified_at: @modified_at.iso8601
+        }
+      end
+
+      def self.deserialize(data)
+        column = new(
+          data[:name],
+          data[:type],
+          default: data[:default],
+          null: data[:nullable],
+          position: data[:position],
+          primary_key: data[:primary_key] || false,
+          unique: data[:unique] || false,
+          precision: data[:precision],
+          scale: data[:scale],
+          limit: data[:limit]
+        )
+        column.send(:created_at=, Time.parse(data[:created_at])) if data[:created_at]
+        column.send(:modified_at=, Time.parse(data[:modified_at])) if data[:modified_at]
+        column
+      end
+
+      protected
+
+      attr_writer :created_at, :modified_at
+    end
+  end
+end

data/lib/rubydb/catalog/constraint.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Catalog
+    # Base constraint class
+    class Constraint
+      attr_reader :name, :type
+
+      def initialize(name, type)
+        @name = name
+        @type = type
+        @created_at = Time.now
+      end
+
+      def to_s
+        "#{@type} CONSTRAINT #{@name}"
+      end
+
+      def serialize
+        {
+          name: @name,
+          type: @type,
+          created_at: @created_at.iso8601
+        }
+      end
+
+      def self.deserialize(data)
+        case data[:type]
+        when "PRIMARY_KEY"
+          PrimaryKeyConstraint.deserialize(data)
+        when "FOREIGN_KEY"
+          ForeignKeyConstraint.deserialize(data)
+        when "UNIQUE"
+          UniqueConstraint.deserialize(data)
+        when "NOT_NULL"
+          NotNullConstraint.deserialize(data)
+        when "CHECK"
+          CheckConstraint.deserialize(data)
+        else
+          new(data[:name], data[:type])
+        end
+      end
+
+      protected
+
+      attr_writer :created_at
+    end
+
+    # PRIMARY KEY constraint
+    class PrimaryKeyConstraint < Constraint
+      attr_reader :columns
+
+      def initialize(name, columns)
+        super(name, "PRIMARY_KEY")
+        @columns = columns.is_a?(Array) ? columns : [columns]
+      end
+
+      def to_s
+        "PRIMARY KEY (#{@columns.join(", ")})"
+      end
+
+      def serialize
+        super.merge(columns: @columns)
+      end
+
+      def self.deserialize(data)
+        new(data[:name], data[:columns])
+      end
+    end
+
+    # FOREIGN KEY constraint
+    class ForeignKeyConstraint < Constraint
+      attr_reader :columns, :reference_table, :reference_columns
+      attr_reader :on_delete, :on_update
+
+      def initialize(name, columns, reference_table, reference_columns: [:id], on_delete: nil, on_update: nil)
+        super(name, "FOREIGN_KEY")
+        @columns = columns.is_a?(Array) ? columns : [columns]
+        @reference_table = reference_table
+        @reference_columns = reference_columns.is_a?(Array) ? reference_columns : [reference_columns]
+        @on_delete = on_delete
+        @on_update = on_update
+      end
+
+      def to_s
+        sql = "FOREIGN KEY (#{@columns.join(", ")}) REFERENCES #{@reference_table}(#{@reference_columns.join(", ")})"
+        sql << " ON DELETE #{@on_delete}" if @on_delete
+        sql << " ON UPDATE #{@on_update}" if @on_update
+        sql
+      end
+
+      def serialize
+        super.merge(
+          columns: @columns,
+          reference_table: @reference_table,
+          reference_columns: @reference_columns,
+          on_delete: @on_delete,
+          on_update: @on_update
+        )
+      end
+
+      def self.deserialize(data)
+        new(
+          data[:name],
+          data[:columns],
+          data[:reference_table],
+          reference_columns: data[:reference_columns] || [:id],
+          on_delete: data[:on_delete],
+          on_update: data[:on_update]
+        )
+      end
+    end
+
+    # UNIQUE constraint
+    class UniqueConstraint < Constraint
+      attr_reader :columns
+
+      def initialize(name, columns)
+        super(name, "UNIQUE")
+        @columns = columns.is_a?(Array) ? columns : [columns]
+      end
+
+      def to_s
+        "UNIQUE (#{@columns.join(", ")})"
+      end
+
+      def serialize
+        super.merge(columns: @columns)
+      end
+
+      def self.deserialize(data)
+        new(data[:name], data[:columns])
+      end
+    end
+
+    # NOT NULL constraint
+    class NotNullConstraint < Constraint
+      attr_reader :column
+
+      def initialize(name, column)
+        super(name, "NOT_NULL")
+        @column = column
+      end
+
+      def to_s
+        "#{@column} NOT NULL"
+      end
+
+      def serialize
+        super.merge(column: @column)
+      end
+
+      def self.deserialize(data)
+        new(data[:name], data[:column])
+      end
+    end
+
+    # CHECK constraint
+    class CheckConstraint < Constraint
+      attr_reader :expression
+
+      def initialize(name, expression)
+        super(name, "CHECK")
+        @expression = expression
+      end
+
+      def to_s
+        "CHECK (#{@expression})"
+      end
+
+      def serialize
+        super.merge(expression: @expression.to_s)
+      end
+
+      def self.deserialize(data)
+        new(data[:name], data[:expression])
+      end
+    end
+  end
+end

data/lib/rubydb/catalog/database.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Catalog
+    # Database - contains schemas, tables, sequences, views, triggers
+    class Database
+      attr_reader :name, :tables, :schemas, :sequences, :views, :triggers, :created_at, :modified_at
+
+      def initialize(name)
+        @name = name
+        @tables = {}
+        @schemas = { "public" => PublicSchema.new }
+        @sequences = {}
+        @views = {}
+        @triggers = {}
+        @created_at = Time.now
+        @modified_at = Time.now
+        @options = {}
+      end
+
+      # --- Table Methods ---
+
+      def add_table(table)
+        @tables[table.name] = table
+        @modified_at = Time.now
+        table
+      end
+
+      def drop_table(name)
+        table = @tables.delete(name)
+        @modified_at = Time.now
+        table
+      end
+
+      def find_table(name)
+        @tables[name]
+      end
+
+      def table_exists?(name)
+        @tables.key?(name)
+      end
+
+      def tables
+        @tables.values
+      end
+
+      def create_schema(name, if_not_exists: false, authorization: nil)
+        if @schemas.key?(name)
+          return if if_not_exists
+          raise DatabaseError, "Schema '#{name}' already exists"
+        end
+        @schemas[name] = Schema.new(name, owner: authorization)
+      end
+
+      def drop_schema(name, if_exists: false, cascade: false)
+        unless @schemas.key?(name)
+          return if if_exists
+          raise DatabaseError, "Schema '#{name}' does not exist"
+        end
+        schema = @schemas[name]
+        if !cascade && schema.tables.any?
+          raise DatabaseError, "Schema '#{name}' is not empty"
+        end
+        @schemas.delete(name)
+      end
+
+      def find_schema(name)
+        @schemas[name]
+      end
+
+      # --- Sequence Methods ---
+
+      def add_sequence(sequence)
+        @sequences[sequence.name] = sequence
+        @modified_at = Time.now
+        sequence
+      end
+
+      def drop_sequence(name)
+        sequence = @sequences.delete(name)
+        @modified_at = Time.now
+        sequence
+      end
+
+      def find_sequence(name)
+        @sequences[name]
+      end
+
+      def sequence_exists?(name)
+        @sequences.key?(name)
+      end
+
+      # --- View Methods ---
+
+      def add_view(view)
+        @views[view.name] = view
+        @modified_at = Time.now
+        view
+      end
+
+      def drop_view(name)
+        view = @views.delete(name)
+        @modified_at = Time.now
+        view
+      end
+
+      def find_view(name)
+        @views[name]
+      end
+
+      def view_exists?(name)
+        @views.key?(name)
+      end
+
+      # --- Trigger Methods ---
+
+      def add_trigger(trigger)
+        @triggers[trigger.name] = trigger
+        @modified_at = Time.now
+        trigger
+      end
+
+      def drop_trigger(name)
+        trigger = @triggers.delete(name)
+        @modified_at = Time.now
+        trigger
+      end
+
+      def find_trigger(name)
+        @triggers[name]
+      end
+
+      def trigger_exists?(name)
+        @triggers.key?(name)
+      end
+
+      # --- Serialization ---
+
+      def serialize
+        {
+          name: @name,
+          created_at: @created_at.iso8601,
+          modified_at: @modified_at.iso8601,
+          tables: @tables.transform_values(&:serialize),
+          schemas: @schemas.transform_values(&:serialize),
+          sequences: @sequences.transform_values(&:serialize),
+          views: @views.transform_values(&:serialize),
+          triggers: @triggers.transform_values(&:serialize),
+          options: @options
+        }
+      end
+
+      def self.deserialize(data)
+        db = new(data[:name])
+        data[:schemas]&.each { |name, schema_data| db.schemas[name.to_s] = Schema.deserialize(schema_data) }
+        db.send(:created_at=, Time.parse(data[:created_at])) if data[:created_at]
+        db.send(:modified_at=, Time.parse(data[:modified_at])) if data[:modified_at]
+
+        data[:tables]&.each do |name, table_data|
+          db.instance_variable_get(:@tables)[name.to_s] = Table.deserialize(table_data)
+        end
+
+        data[:sequences]&.each do |name, seq_data|
+          db.sequences[name.to_s] = Sequence.deserialize(seq_data)
+        end
+
+        data[:views]&.each do |name, view_data|
+          db.views[name.to_s] = View.deserialize(view_data)
+        end
+
+        data[:triggers]&.each do |name, trigger_data|
+          db.triggers[name.to_s] = Trigger.deserialize(trigger_data)
+        end
+
+        db.send(:options=, data[:options]) if data[:options]
+        db
+      end
+
+      protected
+
+      attr_writer :created_at, :modified_at, :options
+    end
+  end
+end

data/lib/rubydb/catalog/index.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Catalog
+    # Index - represents a database index
+    class Index
+      attr_reader :name, :table_name, :columns, :unique, :options
+      attr_accessor :size
+
+      def initialize(name, table_name, columns, unique: false, **options)
+        @name = name
+        @table_name = table_name
+        @columns = columns.is_a?(Array) ? columns : [columns]
+        @unique = unique
+        @options = options
+        @size = 0
+        @created_at = Time.now
+        @modified_at = Time.now
+        @type = options[:type] || :btree
+        @where = options[:where]
+        @include_columns = options[:include] || []
+        @fills = options[:fills] || []
+      end
+
+      def btree?
+        @type == :btree
+      end
+
+      def hash?
+        @type == :hash
+      end
+
+      def gin?
+        @type == :gin
+      end
+
+      def gist?
+        @type == :gist
+      end
+
+      def partial?
+        !@where.nil?
+      end
+
+      def covering?
+        @include_columns.any?
+      end
+
+      def to_s
+        "#{@name} ON #{@table_name}(#{@columns.join(", ")})"
+      end
+
+      def inspect
+        "#<Index name=#{@name} table=#{@table_name} columns=[#{@columns.join(", ")}] unique=#{@unique}>"
+      end
+
+      # --- Serialization ---
+
+      def serialize
+        {
+          name: @name,
+          table_name: @table_name,
+          columns: @columns,
+          unique: @unique,
+          type: @type,
+          where: @where,
+          include: @include_columns,
+          fills: @fills,
+          size: @size,
+          created_at: @created_at.iso8601,
+          modified_at: @modified_at.iso8601
+        }
+      end
+
+      def self.deserialize(data)
+        index = new(
+          data[:name],
+          data[:table_name],
+          data[:columns],
+          unique: data[:unique] || false,
+          type: data[:type] || :btree,
+          where: data[:where],
+          include: data[:include] || [],
+          fills: data[:fills] || []
+        )
+        index.size = data[:size] if data[:size]
+        index.send(:created_at=, Time.parse(data[:created_at])) if data[:created_at]
+        index.send(:modified_at=, Time.parse(data[:modified_at])) if data[:modified_at]
+        index
+      end
+
+      protected
+
+      attr_writer :created_at, :modified_at
+    end
+  end
+end

data/lib/rubydb/catalog/schema.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Catalog
+    # Schema - contains tables, views, etc. (PostgreSQL-style schema)
+    class Schema
+      attr_reader :name, :tables, :views, :sequences, :owner
+
+      def initialize(name, owner: nil)
+        @name = name
+        @owner = owner
+        @tables = {}
+        @views = {}
+        @sequences = {}
+        @created_at = Time.now
+      end
+
+      def add_table(table)
+        @tables[table.name] = table
+        table
+      end
+
+      def drop_table(name)
+        @tables.delete(name)
+      end
+
+      def find_table(name)
+        @tables[name]
+      end
+
+      def table_exists?(name)
+        @tables.key?(name)
+      end
+
+      def add_view(view)
+        @views[view.name] = view
+        view
+      end
+
+      def drop_view(name)
+        @views.delete(name)
+      end
+
+      def find_view(name)
+        @views[name]
+      end
+
+      def add_sequence(sequence)
+        @sequences[sequence.name] = sequence
+        sequence
+      end
+
+      def drop_sequence(name)
+        @sequences.delete(name)
+      end
+
+      def find_sequence(name)
+        @sequences[name]
+      end
+
+      def serialize
+        {
+          name: @name,
+          owner: @owner,
+          created_at: @created_at.iso8601,
+          tables: @tables.transform_values(&:serialize),
+          views: @views.transform_values(&:serialize),
+          sequences: @sequences.transform_values(&:serialize)
+        }
+      end
+
+      def self.deserialize(data)
+        schema = new(data[:name], owner: data[:owner])
+        schema.send(:created_at=, Time.parse(data[:created_at])) if data[:created_at]
+
+        data[:tables]&.each do |name, table_data|
+          schema.tables[name.to_s] = Table.deserialize(table_data)
+        end
+
+        data[:views]&.each do |name, view_data|
+          schema.views[name.to_s] = View.deserialize(view_data)
+        end
+
+        data[:sequences]&.each do |name, seq_data|
+          schema.sequences[name.to_s] = Sequence.deserialize(seq_data)
+        end
+
+        schema
+      end
+
+      protected
+
+      attr_writer :created_at
+    end
+
+    # Default schemas
+    class PublicSchema < Schema
+      def initialize
+        super("public")
+      end
+    end
+  end
+end