rubydb 0.1.0

data/lib/rubydb/catalog/table.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Catalog
+    # Table - contains columns, indexes, constraints
+    class Table
+      attr_reader :name, :columns, :indexes, :constraints, :database
+      attr_accessor :row_count, :storage_size
+
+      def initialize(name, database = nil)
+        @name = name
+        @database = database
+        @columns = []
+        @columns_by_name = {}
+        @indexes = {}
+        @constraints = []
+        @row_count = 0
+        @storage_size = 0
+        @created_at = Time.now
+        @modified_at = Time.now
+        @options = {}
+      end
+
+      # --- Column Methods ---
+
+      def add_column(column)
+        if @columns_by_name.key?(column.name)
+          raise DatabaseError, "Column '#{column.name}' already exists in table '#{@name}'"
+        end
+
+        @columns << column
+        @columns_by_name[column.name] = column
+        @modified_at = Time.now
+        column
+      end
+
+      def drop_column(name)
+        column = @columns_by_name.delete(name)
+        @columns.delete(column) if column
+        @modified_at = Time.now
+        column
+      end
+
+      def find_column(name)
+        @columns_by_name[name]
+      end
+
+      def column_exists?(name)
+        @columns_by_name.key?(name)
+      end
+
+      def columns
+        @columns.dup
+      end
+
+      # --- Index Methods ---
+
+      def add_index(index)
+        if @indexes.key?(index.name)
+          raise DatabaseError, "Index '#{index.name}' already exists in table '#{@name}'"
+        end
+
+        @indexes[index.name] = index
+        @modified_at = Time.now
+        index
+      end
+
+      def drop_index(name)
+        index = @indexes.delete(name)
+        @modified_at = Time.now
+        index
+      end
+
+      def find_index(name)
+        @indexes[name]
+      end
+
+      def indexes
+        @indexes.values
+      end
+
+      # --- Constraint Methods ---
+
+      def add_constraint(constraint)
+        @constraints << constraint
+        @modified_at = Time.now
+        constraint
+      end
+
+      def drop_constraint(name)
+        constraint = @constraints.find { |c| c.name == name }
+        @constraints.delete(constraint) if constraint
+        @modified_at = Time.now
+        constraint
+      end
+
+      def constraints
+        @constraints.dup
+      end
+
+      def primary_key
+        @constraints.find { |c| c.is_a?(PrimaryKeyConstraint) }
+      end
+
+      def foreign_keys
+        @constraints.select { |c| c.is_a?(ForeignKeyConstraint) }
+      end
+
+      def unique_constraints
+        @constraints.select { |c| c.is_a?(UniqueConstraint) }
+      end
+
+      # --- Helpers ---
+
+      def primary_key_column
+        pk = primary_key
+        return nil unless pk
+        find_column(pk.columns.first)
+      end
+
+      def column_names
+        @columns.map(&:name)
+      end
+
+      def column_types
+        @columns.map { |c| [c.name, c.type] }.to_h
+      end
+
+      def to_s
+        "#{@name}(#{@columns.map(&:name).join(", ")})"
+      end
+
+      # --- Serialization ---
+
+      def serialize
+        {
+          name: @name,
+          created_at: @created_at.iso8601,
+          modified_at: @modified_at.iso8601,
+          columns: @columns.map(&:serialize),
+          indexes: @indexes.transform_values(&:serialize),
+          constraints: @constraints.map(&:serialize),
+          row_count: @row_count,
+          storage_size: @storage_size,
+          options: @options
+        }
+      end
+
+      def self.deserialize(data)
+        table = new(data[:name])
+
+        data[:columns]&.each do |col_data|
+          table.add_column(Column.deserialize(col_data))
+        end
+
+        data[:indexes]&.each do |name, idx_data|
+          table.indexes[name] = Index.deserialize(idx_data)
+        end
+
+        data[:constraints]&.each do |con_data|
+          table.constraints << Constraint.deserialize(con_data)
+        end
+
+        table.row_count = data[:row_count] if data[:row_count]
+        table.storage_size = data[:storage_size] if data[:storage_size]
+        table.send(:options=, data[:options]) if data[:options]
+        table.send(:created_at=, Time.parse(data[:created_at])) if data[:created_at]
+        table.send(:modified_at=, Time.parse(data[:modified_at])) if data[:modified_at]
+
+        table
+      end
+
+      protected
+
+      attr_writer :created_at, :modified_at, :options
+    end
+  end
+end

data/lib/rubydb/catalog/trigger.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Catalog
+    # Trigger - executes a function on table events
+    class Trigger
+      attr_reader :name, :event, :table_name, :definition
+      attr_reader :timing, :condition, :function_name
+      attr_accessor :enabled
+
+      def initialize(name, event, table_name, definition, options = {})
+        @name = name
+        @event = event  # :insert, :update, :delete, or array of these
+        @table_name = table_name
+        @definition = definition
+        @timing = options[:timing] || :after  # :before, :after, :instead_of
+        @condition = options[:condition]
+        @function_name = options[:function_name]
+        @enabled = options.fetch(:enabled, true)
+        @created_at = Time.now
+        @modified_at = Time.now
+      end
+
+      def event_types
+        @event.is_a?(Array) ? @event : [@event]
+      end
+
+      def on_insert?
+        event_types.include?(:insert)
+      end
+
+      def on_update?
+        event_types.include?(:update)
+      end
+
+      def on_delete?
+        event_types.include?(:delete)
+      end
+
+      def before?
+        @timing == :before
+      end
+
+      def after?
+        @timing == :after
+      end
+
+      def instead_of?
+        @timing == :instead_of
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def to_s
+        "TRIGGER #{@name} #{@timing} #{@event} ON #{@table_name}"
+      end
+
+      def inspect
+        "#<Trigger name=#{@name} event=#{@event} table=#{@table_name} timing=#{@timing} enabled=#{@enabled}>"
+      end
+
+      # --- Serialization ---
+
+      def serialize
+        {
+          name: @name,
+          event: @event,
+          table_name: @table_name,
+          definition: @definition,
+          timing: @timing,
+          condition: @condition,
+          function_name: @function_name,
+          enabled: @enabled,
+          created_at: @created_at.iso8601,
+          modified_at: @modified_at.iso8601
+        }
+      end
+
+      def self.deserialize(data)
+        trigger = new(
+          data[:name],
+          data[:event],
+          data[:table_name],
+          data[:definition],
+          timing: data[:timing] || :after,
+          condition: data[:condition],
+          function_name: data[:function_name],
+          enabled: data[:enabled] != false
+        )
+        trigger.send(:created_at=, Time.parse(data[:created_at])) if data[:created_at]
+        trigger.send(:modified_at=, Time.parse(data[:modified_at])) if data[:modified_at]
+        trigger
+      end
+
+      protected
+
+      attr_writer :created_at, :modified_at
+    end
+  end
+end

data/lib/rubydb/catalog/view.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Catalog
+    # View - represents a database view (virtual table)
+    class View
+      attr_reader :name, :query, :columns
+      attr_accessor :materialized
+
+      def initialize(name, query, materialized: false)
+        @name = name
+        @query = query
+        @columns = []
+        @materialized = materialized
+        @created_at = Time.now
+        @modified_at = Time.now
+      end
+
+      def add_column(name, type)
+        @columns << { name: name, type: type }
+        @modified_at = Time.now
+      end
+
+      def column_names
+        @columns.map { |c| c[:name] }
+      end
+
+      def to_s
+        if @materialized
+          "MATERIALIZED VIEW #{@name}"
+        else
+          "VIEW #{@name}"
+        end
+      end
+
+      def inspect
+        "#<View name=#{@name} materialized=#{@materialized} columns=#{@columns.size}>"
+      end
+
+      # --- Serialization ---
+
+      def serialize
+        {
+          name: @name,
+          query: @query,
+          columns: @columns,
+          materialized: @materialized,
+          created_at: @created_at.iso8601,
+          modified_at: @modified_at.iso8601
+        }
+      end
+
+      def self.deserialize(data)
+        view = new(data[:name], data[:query], materialized: data[:materialized] || false)
+        view.send(:columns=, data[:columns]) if data[:columns]
+        view.send(:created_at=, Time.parse(data[:created_at])) if data[:created_at]
+        view.send(:modified_at=, Time.parse(data[:modified_at])) if data[:modified_at]
+        view
+      end
+
+      protected
+
+      attr_writer :created_at, :modified_at, :columns
+    end
+  end
+end

data/lib/rubydb/cli/application.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyDB
+  module CLI
+    # Application - Main CLI application
+    class Application
+      def self.start(argv = ARGV)
+        new.run(argv)
+      end
+
+      def initialize
+        @output = Output.new
+        @formatter = Formatter.new(@output)
+        @commands = {}
+        @global_options = {
+          config: nil,
+          env: "development",
+          verbose: false,
+          quiet: false,
+          no_color: false
+        }
+
+        register_commands
+      end
+
+      def run(argv = ARGV)
+        parse_global_options(argv)
+
+        command_name = argv.shift
+
+        if command_name.nil? || command_name == "help"
+          print_help
+          return 0
+        end
+
+        command = @commands[command_name.to_sym]
+        if command.nil?
+          @output.error("Unknown command: #{command_name}")
+          print_help
+          return 1
+        end
+
+        begin
+          command.call(argv, @global_options)
+          0
+        rescue => e
+          @output.error(e.message)
+          @output.debug(e.backtrace.join("\n"))
+          1
+        end
+      end
+
+      private
+
+      def register_commands
+        @commands[:init] = Commands::Init.new(@output, @formatter).method(:execute)
+        @commands[:create] = Commands::Create.new(@output, @formatter).method(:execute)
+        @commands[:drop] = Commands::Drop.new(@output, @formatter).method(:execute)
+        @commands[:start] = Commands::Start.new(@output, @formatter).method(:execute)
+        @commands[:stop] = Commands::Stop.new(@output, @formatter).method(:execute)
+        @commands[:restart] = Commands::Restart.new(@output, @formatter).method(:execute)
+        @commands[:status] = Commands::Status.new(@output, @formatter).method(:execute)
+        @commands[:shell] = Commands::Shell.new(@output, @formatter).method(:execute)
+        @commands[:migrate] = Commands::Migrate.new(@output, @formatter).method(:execute)
+        @commands[:backup] = Commands::Backup.new(@output, @formatter).method(:execute)
+        @commands[:restore] = Commands::Restore.new(@output, @formatter).method(:execute)
+        @commands[:snapshot] = Commands::Snapshot.new(@output, @formatter).method(:execute)
+        @commands[:branch] = Commands::Branch.new(@output, @formatter).method(:execute)
+        @commands[:checkout] = Commands::Checkout.new(@output, @formatter).method(:execute)
+        @commands[:merge] = Commands::Merge.new(@output, @formatter).method(:execute)
+        @commands[:diff] = Commands::Diff.new(@output, @formatter).method(:execute)
+        @commands[:inspect] = Commands::Inspect.new(@output, @formatter).method(:execute)
+        @commands[:vacuum] = Commands::Vacuum.new(@output, @formatter).method(:execute)
+        @commands[:doctor] = Commands::Doctor.new(@output, @formatter).method(:execute)
+      end
+
+      def parse_global_options(argv)
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: rubydb [global_options] command [args]"
+
+          opts.on("-c", "--config FILE", "Configuration file") do |file|
+            @global_options[:config] = file
+          end
+
+          opts.on("-e", "--env ENV", "Environment (development, test, production)") do |env|
+            @global_options[:env] = env
+          end
+
+          opts.on("-v", "--verbose", "Verbose output") do
+            @global_options[:verbose] = true
+          end
+
+          opts.on("-q", "--quiet", "Quiet output") do
+            @global_options[:quiet] = true
+          end
+
+          opts.on("--no-color", "Disable colored output") do
+            @global_options[:no_color] = true
+          end
+
+          opts.on("-h", "--help", "Show help") do
+            print_help
+            exit(0)
+          end
+
+          opts.on("--version", "Show version") do
+            puts "RubyDB v#{RubyDB::VERSION}"
+            exit(0)
+          end
+        end
+
+        begin
+          parser.parse!(argv)
+        rescue OptionParser::ParseError => e
+          @output.error(e.message)
+          print_help
+          exit(1)
+        end
+      end
+
+      def print_help
+        @output.puts "RubyDB - Developer-first relational database", :bold
+        @output.puts "Version: #{RubyDB::VERSION}"
+        @output.puts
+        @output.puts "Usage: rubydb [global_options] <command> [args]"
+        @output.puts
+        @output.puts "Global Options:"
+        @output.puts "  -c, --config FILE        Configuration file"
+        @output.puts "  -e, --env ENV            Environment (development, test, production)"
+        @output.puts "  -v, --verbose            Verbose output"
+        @output.puts "  -q, --quiet              Quiet output"
+        @output.puts "  --no-color               Disable colored output"
+        @output.puts "  -h, --help               Show this help"
+        @output.puts "  --version                Show version"
+        @output.puts
+        @output.puts "Commands:"
+        @output.puts "  init                     Initialize a new database"
+        @output.puts "  create                   Create a database"
+        @output.puts "  drop                     Drop a database"
+        @output.puts "  start                    Start the database server"
+        @output.puts "  stop                     Stop the database server"
+        @output.puts "  restart                  Restart the database server"
+        @output.puts "  status                   Show database status"
+        @output.puts "  shell                    Open an interactive SQL shell"
+        @output.puts "  migrate                  Run database migrations"
+        @output.puts "  backup                   Create a database backup"
+        @output.puts "  restore                  Restore a database backup"
+        @output.puts "  snapshot                 Create a database snapshot"
+        @output.puts "  branch                   Manage database branches"
+        @output.puts "  checkout                 Switch to a branch"
+        @output.puts "  merge                    Merge a branch"
+        @output.puts "  diff                     Show differences between branches"
+        @output.puts "  inspect                  Inspect database internals"
+        @output.puts "  vacuum                   Vacuum the database"
+        @output.puts "  doctor                   Run health checks"
+        @output.puts
+        @output.puts "Run 'rubydb <command> --help' for more information on a command."
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/backup.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      class Backup
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb backup [options]"
+            opts.on("-t", "--type TYPE", "Backup type (full, incremental, differential)") do |type|
+              options[:type] = type.to_sym
+            end
+            opts.on("-d", "--dir DIR", "Backup directory") do |dir|
+              options[:dir] = dir
+            end
+            opts.on("--compress", "Compress backup") do
+              options[:compress] = true
+            end
+            opts.on("--no-verify", "Skip verification") do
+              options[:no_verify] = true
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          # Get real config
+          config = RubyDB::Configuration::Config.instance
+          db_path = options[:database] || config.get("storage.data_dir") || "data/rubydb.rdb"
+          backup_dir = options[:dir] || config.get("backup.backup_dir") || "backups"
+
+          # Create backup instance
+          engine = RubyDB::Storage::Engine.new(db_path, {})
+          backup = RubyDB::Backup::Backup.new(engine,
+            backup_dir: backup_dir,
+            compress: options[:compress] != false,
+            verify_after_backup: !options[:no_verify]
+          )
+
+          @output.spinner("Creating #{options[:type] || 'full'} backup...") do
+            result = backup.create_backup(type: options[:type] || :full)
+
+            if result[:success]
+              @output.success("Backup created successfully")
+              @output.puts("  Name: #{result[:backup_name]}")
+              @output.puts("  Size: #{format_size(result[:size])}")
+              @output.puts("  Path: #{result[:backup_path]}")
+              @output.puts("  Time: #{result[:elapsed_ms].round(2)}ms")
+            else
+              @output.error("Backup failed: #{result[:error]}")
+              return 1
+            end
+          end
+
+          0
+        ensure
+          engine&.close if engine&.open?
+        end
+
+        private
+
+        def format_size(bytes)
+          return "0 B" if bytes.to_i == 0
+          units = ["B", "KB", "MB", "GB", "TB"]
+          exp = (Math.log(bytes) / Math.log(1024)).floor
+          size = bytes / (1024.0 ** exp)
+          "#{size.round(2)} #{units[exp]}"
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/branch.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyDB
+  module CLI
+    module Commands
+      # Branch - Manage database branches
+      class Branch
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb branch [options]"
+            opts.on("-l", "--list", "List branches") do
+              options[:list] = true
+            end
+            opts.on("-c", "--create NAME", "Create branch") do |name|
+              options[:create] = name
+            end
+            opts.on("-d", "--delete NAME", "Delete branch") do |name|
+              options[:delete] = name
+            end
+            opts.on("--from BRANCH", "Create from branch") do |branch|
+              options[:from] = branch
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--branch-dir DIR", "Branch metadata directory") { |path| options[:branch_dir] = path }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          database = RubyDB::Database.new(options[:database] || "data/rubydb.rdb", auto_connect: false).connect
+          manager = RubyDB::Branching::BranchManager.new(
+            database.engine,
+            branch_dir: options[:branch_dir] || "branches"
+          )
+
+          if options[:list] || (args.empty? && !options[:create] && !options[:delete])
+            @formatter.format_branches(manager.list_branches)
+            return 0
+          end
+
+          if options[:create]
+            from = options[:from] || "main"
+            result = manager.create_branch(options[:create], from: from)
+            raise result[:error] unless result[:success]
+            @output.success("Branch #{options[:create]} created")
+            return 0
+          end
+
+          if options[:delete]
+            result = manager.delete_branch(options[:delete])
+            raise result[:error] unless result[:success]
+            @output.success("Branch #{options[:delete]} deleted")
+            return 0
+          end
+          raise "Specify --list, --create, or --delete"
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end