rubydb 0.1.0

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      class Restore
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb restore [options]"
+            opts.on("-b", "--backup NAME", "Backup name") do |name|
+              options[:backup] = name
+            end
+            opts.on("-l", "--latest", "Restore latest backup") do
+              options[:latest] = true
+            end
+            opts.on("--point-in-time TIME", "Restore to point in time") do |time|
+              options[:point_in_time] = time
+            end
+            opts.on("--dry-run", "Show what would be restored") do
+              options[:dry_run] = true
+            end
+            opts.on("-f", "--force", "Force restore") do
+              options[:force] = true
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--dir DIR", "Backup directory") { |path| options[:backup_dir] = 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[:backup_dir] || config.get("backup.backup_dir") || "backups"
+
+          selected_path = if options[:backup]
+                            File.join(backup_dir, options[:backup])
+                          elsif options[:latest]
+                            nil
+                          end
+
+          if options[:dry_run]
+            available = RubyDB::Backup::Restore.new(nil, backup_dir: backup_dir).list_available_backups
+            selected = if selected_path
+                         available.find { |backup| backup[:path] == selected_path }
+                       else
+                         available.first
+                       end
+            raise "No matching backup available" unless selected
+            @output.info("Would restore #{selected[:name]} from #{selected[:path]}")
+            return 0
+          end
+
+          unless options[:force]
+            @output.warn("This will overwrite the current database")
+            @output.print("Are you sure? (yes/no): ", nil, false)
+            response = $stdin.gets.chomp
+            return 1 unless response.downcase == "yes"
+          end
+
+          # Create restore instance
+          engine = RubyDB::Storage::Engine.new(db_path, {})
+          restore = RubyDB::Backup::Restore.new(engine, backup_dir: backup_dir)
+
+          if options[:latest]
+            @output.spinner("Restoring latest backup...") do
+              result = restore.restore_latest
+
+              if result[:success]
+                @output.success("Backup restored successfully")
+              else
+                @output.error("Restore failed: #{result[:error]}")
+                return 1
+              end
+            end
+          elsif options[:backup]
+          backup_path = File.join(backup_dir, options[:backup])
+            @output.spinner("Restoring backup #{options[:backup]}...") do
+              result = restore.restore(backup_path)
+
+              if result[:success]
+                @output.success("Backup restored successfully")
+              else
+                @output.error("Restore failed: #{result[:error]}")
+                return 1
+              end
+            end
+          elsif options[:point_in_time]
+            @output.spinner("Restoring to point in time #{options[:point_in_time]}...") do
+              result = restore.restore_point_in_time(options[:point_in_time])
+
+              if result[:success]
+                @output.success("Database restored to #{options[:point_in_time]}")
+              else
+                @output.error("Restore failed: #{result[:error]}")
+                return 1
+              end
+            end
+          else
+            @output.error("Please specify --backup, --latest, or --point-in-time")
+            @output.puts parser
+            return 1
+          end
+
+          0
+        ensure
+          engine&.close if engine&.open?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+begin
+  require "readline"
+rescue LoadError
+  # The interactive shell is optional for library and adapter consumers.
+  # `execute` reports a focused error if the command is requested without it.
+end
+require "json"
+
+module RubyDB
+  module CLI
+    module Commands
+      class Shell
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+          @history_file = File.expand_path("~/.rubydb_history")
+          @connected = false
+          @engine = nil
+          @current_database = nil
+          @transaction = nil
+        end
+
+        def execute(args, options)
+          unless defined?(Readline)
+            raise RubyDB::Error, "The interactive shell requires the readline extension"
+          end
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb shell [options]"
+            opts.on("-d", "--database NAME", "Database name") do |name|
+              options[:database] = name
+            end
+            opts.on("-h", "--host HOST", "Server host") do |host|
+              options[:host] = host
+            end
+            opts.on("-p", "--port PORT", Integer, "Server port") do |port|
+              options[:port] = port
+            end
+            opts.on("-u", "--user USER", "Username") do |user|
+              options[:user] = user
+            end
+            opts.on("-w", "--password", "Prompt for password") do
+              options[:password] = true
+            end
+            opts.on("--csv", "Output in CSV format") do
+              options[:csv] = true
+            end
+            opts.on("--json", "Output in JSON format") do
+              options[:json] = true
+            end
+            opts.on("--table", "Output in table format") do
+              options[:table] = true
+            end
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+          @options = options
+
+          # Load history
+          load_history
+
+          # Connect to database
+          connect_to_database(options)
+
+          @output.puts "RubyDB Shell v#{RubyDB::VERSION}", :bold
+          @output.puts "Connected to: #{@current_database || 'rubydb'}"
+          @output.puts "Type '.help' for help, '.exit' to quit"
+          @output.puts
+
+          @connected = true
+
+          while @connected
+            begin
+              prompt = @current_database ? "#{@current_database}> " : "rubydb> "
+              input = Readline.readline(prompt, true)
+              break if input.nil?
+
+              input = input.strip
+              next if input.empty?
+
+              # Handle special commands
+              case input
+              when ".exit", ".quit"
+                break
+              when ".help", ".?"
+                print_help
+              when ".status"
+                print_status
+              when ".clear", ".cls"
+                system("clear") || system("cls")
+              when /\A\.db\s+(.+)/
+                switch_database($1)
+              when /\A\.(?:table|t)\s+(.+)/
+                describe_table($1)
+              when /\A\.tables/
+                list_tables
+              when /\A\.(?:schema|s)\s+(.+)/
+                show_schema($1)
+              when /\A\.(?:begin|txn|start)/
+                begin_transaction
+              when /\A\.commit/
+                commit_transaction
+              when /\A\.rollback/
+                rollback_transaction
+              when /\A\.explain\s+(.+)/
+                explain_query($1)
+              else
+                execute_query(input)
+              end
+            rescue Interrupt
+              @output.puts
+              @output.info("Type .exit to quit")
+            rescue => e
+              @output.error(e.message)
+              @output.debug(e.backtrace.join("\n")) if ENV["RUBYDB_DEBUG"]
+            end
+          end
+
+          # Cleanup
+          disconnect
+          save_history
+          @output.puts "Goodbye!"
+
+          0
+        end
+
+        private
+
+        def connect_to_database(options)
+          config = RubyDB::Configuration::Config.instance
+          
+          db_name = options[:database] || config.get("database.name") || "rubydb"
+          db_path = config.get("storage.data_dir") || "data"
+          db_file = File.join(db_path, "#{db_name}.rdb")
+
+          @engine = RubyDB::Storage::Engine.new(db_file, {})
+          @current_database = db_name
+          @connected = true
+        rescue => e
+          @output.error("Failed to connect: #{e.message}")
+          exit(1)
+        end
+
+        def disconnect
+          @engine.close if @engine
+          @connected = false
+        end
+
+        def execute_query(sql)
+          @output.spinner("Executing query...") do
+            # Parse SQL
+            parser = RubyDB::SQL::Parser.new(RubyDB::SQL::Lexer.new(sql).tokenize)
+            statements = parser.parse
+
+            statements.each do |stmt|
+              result = execute_statement(stmt)
+              display_result(result)
+            end
+          end
+        rescue => e
+          @output.error(e.message)
+        end
+
+        def execute_statement(statement)
+          # Plan and execute the statement
+          planner = RubyDB::Execution::Planner.new(@engine)
+          plan = planner.plan(statement)
+          
+          executor = RubyDB::Execution::Executor.new(@engine)
+          executor.execute(plan)
+        end
+
+        def display_result(result)
+          rows = result[:rows] || []
+          columns = result[:column_names] || []
+
+          if rows.empty?
+            @output.puts("0 rows returned", :gray)
+            return
+          end
+
+          if @options[:json]
+            @output.json(rows)
+          elsif @options[:csv]
+            # Output CSV
+            @output.puts columns.join(",")
+            rows.each { |row| @output.puts columns.map { |c| row[c].to_s }.join(",") }
+          elsif @options[:table] != false
+            # Table format
+            table_rows = rows.map { |row| columns.map { |c| row[c].to_s } }
+            @output.table(columns, table_rows, show_count: true)
+          else
+            # Default format
+            rows.each do |row|
+              @output.puts row.inspect
+            end
+            @output.puts "(#{rows.size} rows)", :gray
+          end
+        end
+
+        def switch_database(name)
+          db_path = File.join("data", "#{name}.rdb")
+          if File.exist?(db_path)
+            @engine.close if @engine
+            @engine = RubyDB::Storage::Engine.new(db_path, {})
+            @current_database = name
+            @output.success("Switched to database: #{name}")
+          else
+            @output.error("Database '#{name}' does not exist")
+          end
+        end
+
+        def list_tables
+          tables = @engine.list_tables
+          if tables.empty?
+            @output.puts("No tables found", :gray)
+          else
+            @output.puts("Tables in #{@current_database}:", :bold)
+            tables.each { |t| @output.puts("  - #{t}") }
+            @output.puts("Total: #{tables.size}", :gray)
+          end
+        end
+
+        def describe_table(name)
+          columns = @engine.table_columns(name)
+          if columns.empty?
+            @output.error("Table '#{name}' not found")
+            return
+          end
+
+          @output.puts("Table: #{name}", :bold)
+          @output.puts("-" * 40)
+          columns.each do |col|
+            pk = col.primary_key? ? " PK" : ""
+            null = col.nullable? ? "" : " NOT NULL"
+            default = col.has_default? ? " DEFAULT #{col.default}" : ""
+            @output.puts("  #{col.name}: #{col.type}#{pk}#{null}#{default}")
+          end
+          @output.puts("-" * 40)
+          @output.puts("Total columns: #{columns.size}", :gray)
+        end
+
+        def show_schema(name)
+          columns = @engine.table_columns(name)
+          if columns.empty?
+            @output.error("Table '#{name}' not found")
+            return
+          end
+
+          sql = "CREATE TABLE #{name} (\n"
+          cols = columns.map do |col|
+            "  #{col.name} #{col.type}#{col.primary_key? ? " PRIMARY KEY" : ""}"
+          end
+          sql << cols.join(",\n")
+          sql << "\n);"
+          @output.puts(sql, :cyan)
+        end
+
+        def begin_transaction
+          @transaction = @engine.begin_transaction
+          @output.success("Transaction started")
+        end
+
+        def commit_transaction
+          if @transaction
+            @engine.commit_transaction(@transaction)
+            @transaction = nil
+            @output.success("Transaction committed")
+          else
+            @output.error("No active transaction")
+          end
+        end
+
+        def rollback_transaction
+          if @transaction
+            @engine.rollback_transaction(@transaction)
+            @transaction = nil
+            @output.success("Transaction rolled back")
+          else
+            @output.error("No active transaction")
+          end
+        end
+
+        def explain_query(sql)
+          parser = RubyDB::SQL::Parser.new(RubyDB::SQL::Lexer.new(sql).tokenize)
+          stmt = parser.parse.first
+          planner = RubyDB::Execution::Planner.new(@engine)
+          plan = planner.plan(stmt)
+
+          @output.puts("EXPLAIN QUERY PLAN", :bold)
+          @output.puts("-" * 40)
+          @output.puts("  Scan Type: #{plan.scan_type}")
+          @output.puts("  Table: #{plan.table_name}")
+          @output.puts("  Estimated Cost: #{plan.estimated_cost}")
+          @output.puts("  Estimated Rows: #{plan.estimated_rows}")
+          @output.puts("  Predicate: #{plan.predicate.inspect}") if plan.predicate
+          @output.puts("  Order By: #{plan.order_by.inspect}") if plan.order_by&.any?
+          @output.puts("  Limit: #{plan.limit}") if plan.limit
+          @output.puts("-" * 40)
+        end
+
+        def print_help
+          @output.puts("\nAvailable Commands:", :bold)
+          @output.puts("  .help, .?           Show this help")
+          @output.puts("  .exit, .quit        Exit the shell")
+          @output.puts("  .status             Show connection status")
+          @output.puts("  .clear, .cls        Clear screen")
+          @output.puts("  .db <name>          Switch database")
+          @output.puts("  .tables             List all tables")
+          @output.puts("  .table <name>       Describe a table")
+          @output.puts("  .schema <name>      Show CREATE TABLE statement")
+          @output.puts("  .begin, .txn        Begin transaction")
+          @output.puts("  .commit             Commit transaction")
+          @output.puts("  .rollback           Rollback transaction")
+          @output.puts("  .explain <sql>      Explain query plan")
+          @output.puts("\nAny other input is treated as SQL", :gray)
+        end
+
+        def print_status
+          @output.puts("\nConnection Status:", :bold)
+          @output.puts("  Connected: #{@connected}")
+          @output.puts("  Database: #{@current_database}")
+          @output.puts("  Version: #{RubyDB::VERSION}")
+          @output.puts("  PID: #{Process.pid}")
+          @output.puts("  In Transaction: #{!@transaction.nil?}")
+          @output.puts("  Tables: #{@engine.list_tables.size}")
+          @output.puts("  Storage: #{format_size(get_db_size)}")
+        end
+
+        def get_db_size
+          db_path = File.join("data", "#{@current_database}.rdb")
+          File.exist?(db_path) ? File.size(db_path) : 0
+        end
+
+        def format_size(bytes)
+          return "0 B" if bytes == 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
+
+        def load_history
+          return unless File.exist?(@history_file)
+          File.readlines(@history_file).each { |line| Readline::HISTORY.push(line.chomp) }
+        rescue
+          # Ignore
+        end
+
+        def save_history
+          history = Readline::HISTORY.to_a
+          File.write(@history_file, history.join("\n"))
+        rescue
+          # Ignore
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Snapshot - Create a database snapshot
+      class Snapshot
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb snapshot [options]"
+            opts.on("-n", "--name NAME", "Snapshot name") do |name|
+              options[:name] = name
+            end
+            opts.on("-l", "--list", "List snapshots") do
+              options[:list] = true
+            end
+            opts.on("-d", "--delete NAME", "Delete snapshot") do |name|
+              options[:delete] = name
+            end
+            opts.on("-r", "--restore NAME", "Restore snapshot") do |name|
+              options[:restore] = name
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--dir DIR", "Snapshot directory") { |path| options[:snapshot_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
+          snapshots = RubyDB::Backup::Snapshot.new(
+            database.engine, snapshot_dir: options[:snapshot_dir] || "snapshots"
+          )
+
+          if options[:list]
+            @formatter.format_snapshots(snapshots.list_snapshots)
+            return 0
+          end
+
+          if options[:delete]
+            result = snapshots.delete_snapshot(options[:delete])
+            raise result[:error] unless result[:success]
+            @output.success("Snapshot #{options[:delete]} deleted")
+            return 0
+          end
+
+          if options[:restore]
+            @output.warn("This will overwrite the current database")
+            @output.print("Are you sure? (yes/no): ", nil, false)
+            response = $stdin.gets.chomp
+            return unless response.downcase == "yes"
+
+            result = snapshots.restore_snapshot(options[:restore])
+            raise result[:error] unless result[:success]
+            @output.success("Snapshot #{options[:restore]} restored")
+            return 0
+          end
+
+          name = options[:name] || "snapshot_#{Time.now.strftime('%Y%m%d_%H%M%S')}"
+
+          result = snapshots.create_snapshot(name)
+          raise result[:error] unless result[:success]
+          @output.success("Snapshot #{name} created")
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyDB
+  module CLI
+    module Commands
+      # Start - Start the database server
+      class Start
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb start [options]"
+            opts.on("-d", "--daemon", "Run as daemon") do
+              options[:daemon] = true
+            end
+            opts.on("-p", "--port PORT", Integer, "Server port") do |port|
+              options[:port] = port
+            end
+            opts.on("--data-dir DIR", "Database data directory") { |dir| options[:data_dir] = dir }
+            opts.on("--log-dir DIR", "Server log directory") { |dir| options[:log_dir] = dir }
+            opts.on("-H", "--host HOST", "Server host") do |host|
+              options[:host] = host
+            end
+            opts.on("--pid-file FILE", "PID file") do |file|
+              options[:pid_file] = file
+            end
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          configured = load_runtime_config(options)
+          server_config = configured[:server] || {}
+
+          server_options = {
+            host: options[:host] || server_config[:host] || "localhost",
+            port: options[:port] || server_config[:port] || 7432,
+            data_dir: options[:data_dir] || configured.dig(:storage, :data_dir) || "data",
+            log_dir: options[:log_dir] || configured.dig(:logging, :log_dir) || "log",
+            pid_file: options[:pid_file] || server_config[:pid_file] || "rubydb.pid",
+            daemonize: options[:daemon] == true || server_config[:daemonize] == true,
+            max_connections: server_config[:max_connections],
+            min_workers: server_config[:min_workers],
+            max_workers: server_config[:max_workers],
+            read_timeout: server_config[:read_timeout],
+            write_timeout: server_config[:write_timeout],
+            idle_timeout: server_config[:idle_timeout],
+            max_request_size: server_config[:max_request_size],
+            authentication: (options[:config] || options[:env].to_s == "production") ? configured[:auth] : { method: "none" },
+            ssl: configured[:ssl] || { enabled: false }
+          }.compact
+          server = RubyDB::Server::Server.new(server_options)
+          server.start
+          @output.success("RubyDB server started on #{server.config[:host]}:#{server.config[:port]}")
+          return 0 if options[:daemon]
+
+          trap("INT") { server.stop; exit(0) }
+          trap("TERM") { server.stop; exit(0) }
+          sleep
+        end
+
+        private
+
+        def load_runtime_config(options)
+          RubyDB::Configuration::Config.environment = options[:env] if options[:env]
+          config = RubyDB::Configuration::Config.load(options[:config])
+          raise "Invalid configuration: #{RubyDB::Configuration::Config.errors.join('; ')}" unless config && RubyDB::Configuration::Config.valid?
+
+          config
+        end
+      end
+    end
+  end
+end