rubydb 0.1.0

data/lib/rubydb/sql/ast/create_table.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # CREATE TABLE statement AST node
+      class CreateTable < Node
+        attr_reader :name, :columns, :constraints, :if_not_exists
+
+        def initialize(name, columns, constraints = [], if_not_exists: false, location: nil)
+          super(location: location)
+          @name = name
+          @columns = columns
+          @constraints = constraints
+          @if_not_exists = if_not_exists
+        end
+
+        def accept(visitor)
+          visitor.visit_create_table(self)
+        end
+
+        def clone
+          CreateTable.new(
+            @name,
+            @columns.map(&:clone),
+            @constraints.map(&:clone),
+            if_not_exists: @if_not_exists,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = []
+          parts << "CREATE TABLE"
+          parts << "IF NOT EXISTS" if @if_not_exists
+          parts << @name
+          parts << "("
+
+          definitions = @columns.map(&:to_sql)
+          definitions += @constraints.map(&:to_sql)
+          parts << definitions.join(", ")
+
+          parts << ")"
+          parts.join(" ")
+        end
+
+        def inspect
+          cols = @columns.map(&:inspect).join(", ")
+          cons = @constraints.map(&:inspect).join(", ")
+          str = "CreateTable(name: #{@name}, columns: [#{cols}]"
+          str << ", constraints: [#{cons}]" if @constraints.any?
+          str << ", if_not_exists: true" if @if_not_exists
+          str << ")"
+          str
+        end
+
+        # Helper methods
+        def column_count
+          @columns.size
+        end
+
+        def constraint_count
+          @constraints.size
+        end
+
+        def find_column(name)
+          @columns.find { |col| col.name == name }
+        end
+
+        def primary_key_columns
+          pk = @constraints.find { |c| c.is_a?(PrimaryKeyConstraint) }
+          pk ? pk.columns : []
+        end
+
+        def foreign_keys
+          @constraints.select { |c| c.is_a?(ForeignKeyConstraint) }
+        end
+
+        def unique_constraints
+          @constraints.select { |c| c.is_a?(UniqueConstraint) }
+        end
+      end
+
+      # Column definition in CREATE TABLE
+      class ColumnDefinition < Node
+        attr_reader :name, :type, :options
+
+        def initialize(name, type, options = {}, location: nil)
+          super(location: location)
+          @name = name
+          @type = type
+          @options = options
+        end
+
+        def accept(visitor)
+          visitor.visit_column_definition(self)
+        end
+
+        def clone
+          ColumnDefinition.new(
+            @name,
+            @type.is_a?(Hash) ? @type.dup : @type,
+            @options.dup,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = [@name]
+          parts << type_sql
+          parts << "PRIMARY KEY" if @options[:primary_key]
+          parts << "AUTOINCREMENT" if @options[:auto_increment]
+          parts << "UNIQUE" if @options[:unique]
+          parts << "NOT NULL" if @options[:null] == false
+          parts << "NULL" if @options[:null] == true
+          parts << "DEFAULT #{@options[:default].to_sql}" if @options[:default]
+          if @options[:references]
+            ref = @options[:references]
+            parts << "REFERENCES #{ref[:table]}(#{ref[:column]})"
+          end
+          parts.join(" ")
+        end
+
+        def inspect
+          "ColumnDefinition(name: #{@name}, type: #{type_sql}, options: #{@options.inspect})"
+        end
+
+        def type_sql
+          case @type
+          when Symbol
+            @type.to_s.upcase
+          when Hash
+            if @type[:type] == :decimal
+              "DECIMAL(#{@type[:precision]}, #{@type[:scale]})"
+            elsif @type[:type] == :varchar
+              "VARCHAR(#{@type[:limit]})"
+            else
+              @type[:type].to_s.upcase
+            end
+          else
+            @type.to_s
+          end
+        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 primary_key?
+          @options[:primary_key] == true
+        end
+
+        def unique?
+          @options[:unique] == true
+        end
+
+        def nullable?
+          @options[:null] != false
+        end
+
+        def has_default?
+          !@options[:default].nil?
+        end
+
+        def references?
+          !@options[:references].nil?
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/sql/ast/delete.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # DELETE statement AST node
+      class Delete < Node
+        attr_reader :table, :where
+
+        def initialize(table, where = nil, location: nil)
+          super(location: location)
+          @table = table
+          @where = where
+        end
+
+        def accept(visitor)
+          visitor.visit_delete(self)
+        end
+
+        def clone
+          Delete.new(
+            @table,
+            @where&.clone,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = []
+          parts << "DELETE FROM #{@table}"
+          parts << "WHERE #{@where.to_sql}" if @where
+          parts.join(" ")
+        end
+
+        def inspect
+          str = "Delete(table: #{@table}"
+          str << ", where: #{@where.inspect}" if @where
+          str << ")"
+          str
+        end
+
+        # Helper methods
+        def has_where?
+          !@where.nil?
+        end
+
+        # Check if this DELETE will affect all rows
+        def delete_all?
+          @where.nil?
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/sql/ast/drop_database.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # DROP DATABASE statement AST node
+      class DropDatabase < Node
+        attr_reader :name, :if_exists
+
+        def initialize(name, if_exists: false, location: nil)
+          super(location: location)
+          @name = name
+          @if_exists = if_exists
+        end
+
+        def accept(visitor)
+          visitor.visit_drop_database(self)
+        end
+
+        def clone
+          DropDatabase.new(@name, if_exists: @if_exists, location: @location)
+        end
+
+        def to_sql
+          parts = []
+          parts << "DROP DATABASE"
+          parts << "IF EXISTS" if @if_exists
+          parts << @name
+          parts.join(" ")
+        end
+
+        def inspect
+          str = "DropDatabase(name: #{@name}"
+          str << ", if_exists: true" if @if_exists
+          str << ")"
+          str
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/sql/ast/drop_index.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # DROP INDEX statement AST node
+      class DropIndex < Node
+        attr_reader :name, :if_exists
+
+        def initialize(name, if_exists: false, location: nil)
+          super(location: location)
+          @name = name
+          @if_exists = if_exists
+        end
+
+        def accept(visitor)
+          visitor.visit_drop_index(self)
+        end
+
+        def clone
+          DropIndex.new(@name, if_exists: @if_exists, location: @location)
+        end
+
+        def to_sql
+          parts = []
+          parts << "DROP INDEX"
+          parts << "IF EXISTS" if @if_exists
+          parts << @name
+          parts.join(" ")
+        end
+
+        def inspect
+          str = "DropIndex(name: #{@name}"
+          str << ", if_exists: true" if @if_exists
+          str << ")"
+          str
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/sql/ast/drop_schema.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # DROP SCHEMA statement AST node
+      class DropSchema < Node
+        attr_reader :name, :if_exists, :cascade
+
+        def initialize(name, if_exists: false, cascade: false, location: nil)
+          super(location: location)
+          @name = name
+          @if_exists = if_exists
+          @cascade = cascade
+        end
+
+        def accept(visitor)
+          visitor.visit_drop_schema(self)
+        end
+
+        def clone
+          DropSchema.new(
+            @name,
+            if_exists: @if_exists,
+            cascade: @cascade,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = []
+          parts << "DROP SCHEMA"
+          parts << "IF EXISTS" if @if_exists
+          parts << @name
+          parts << "CASCADE" if @cascade
+          parts.join(" ")
+        end
+
+        def inspect
+          str = "DropSchema(name: #{@name}"
+          str << ", if_exists: true" if @if_exists
+          str << ", cascade: true" if @cascade
+          str << ")"
+          str
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/sql/ast/drop_table.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # DROP TABLE statement AST node
+      class DropTable < Node
+        attr_reader :name, :if_exists, :cascade
+
+        def initialize(name, if_exists: false, cascade: false, location: nil)
+          super(location: location)
+          @name = name
+          @if_exists = if_exists
+          @cascade = cascade
+        end
+
+        def accept(visitor)
+          visitor.visit_drop_table(self)
+        end
+
+        def clone
+          DropTable.new(
+            @name,
+            if_exists: @if_exists,
+            cascade: @cascade,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = []
+          parts << "DROP TABLE"
+          parts << "IF EXISTS" if @if_exists
+          parts << @name
+          parts << "CASCADE" if @cascade
+          parts.join(" ")
+        end
+
+        def inspect
+          str = "DropTable(name: #{@name}"
+          str << ", if_exists: true" if @if_exists
+          str << ", cascade: true" if @cascade
+          str << ")"
+          str
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/sql/ast/explain.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # EXPLAIN statement AST node
+      class Explain < Node
+        attr_reader :statement, :analyze, :verbose, :costs, :buffers, :timing, :format
+
+        def initialize(statement, analyze: false, verbose: false, costs: true, buffers: false, timing: true, format: nil, location: nil)
+          super(location: location)
+          @statement = statement
+          @analyze = analyze
+          @verbose = verbose
+          @costs = costs
+          @buffers = buffers
+          @timing = timing
+          @format = format || :text
+        end
+
+        def accept(visitor)
+          visitor.visit_explain(self)
+        end
+
+        def clone
+          Explain.new(
+            @statement.clone,
+            analyze: @analyze,
+            verbose: @verbose,
+            costs: @costs,
+            buffers: @buffers,
+            timing: @timing,
+            format: @format,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = ["EXPLAIN"]
+          parts << "ANALYZE" if @analyze
+          parts << "VERBOSE" if @verbose
+          parts << "COSTS" if @costs
+          parts << "BUFFERS" if @buffers
+          parts << "TIMING" if @timing
+          parts << "(FORMAT #{@format.to_s.upcase})" if @format
+          parts << @statement.to_sql
+          parts.join(" ")
+        end
+
+        def inspect
+          str = "Explain(statement: #{@statement.inspect}"
+          str << ", analyze: true" if @analyze
+          str << ", verbose: true" if @verbose
+          str << ", costs: false" unless @costs
+          str << ", buffers: true" if @buffers
+          str << ", timing: false" unless @timing
+          str << ", format: #{@format}" if @format
+          str << ")"
+          str
+        end
+      end
+    end
+  end
+end