rubydb 0.1.4 → 0.1.6

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

@@ -1,20 +1,22 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module SQL
-    module AST
-      class SetOperation < Node
-        attr_reader :left, :right, :operator, :all
-
-        def initialize(left, right, operator, all: false, location: nil)
-          super(location: location)
-          @left, @right, @operator, @all = left, right, operator, all
-        end
-
-        def accept(visitor) = visitor.visit_set_operation(self)
-        def clone = SetOperation.new(@left.clone, @right.clone, @operator, all: @all, location: @location)
-        def to_sql = "#{@left.to_sql} #{@operator.to_s.upcase}#{@all ? ' ALL' : ''} #{@right.to_sql}"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      class SetOperation < Node
+        attr_reader :left, :right, :operator, :all
+
+        def initialize(left, right, operator, all: false, location: nil)
+          super(location: location)
+          @left, @right, @operator, @all = left, right, operator, all
+        end
+
+        def accept(visitor) = visitor.visit_set_operation(self)
+
+        def clone = SetOperation.new(@left.clone, @right.clone, @operator, all: @all, location: @location)
+
+        def to_sql = "#{@left.to_sql} #{@operator.to_s.upcase}#{@all ? " ALL" : ""} #{@right.to_sql}"
+      end
+    end
+  end
+end

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

@@ -1,29 +1,35 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module SQL
-    module AST
-      class CreateTrigger < Node
-        attr_reader :name, :timing, :event, :table_name, :function_name
-        def initialize(name, timing, event, table_name, function_name, location: nil)
-          super(location: location)
-          @name, @timing, @event, @table_name, @function_name = name, timing, event, table_name, function_name
-        end
-        def accept(visitor) = visitor.visit_create_trigger(self)
-        def clone = self.class.new(@name, @timing, @event, @table_name, @function_name, location: @location)
-        def to_sql = "CREATE TRIGGER #{@name} #{@timing.to_s.upcase} #{@event.to_s.upcase} ON #{@table_name} EXECUTE FUNCTION #{@function_name}()"
-      end
-
-      class DropTrigger < Node
-        attr_reader :name, :if_exists
-        def initialize(name, if_exists: false, location: nil)
-          super(location: location)
-          @name, @if_exists = name, if_exists
-        end
-        def accept(visitor) = visitor.visit_drop_trigger(self)
-        def clone = self.class.new(@name, if_exists: @if_exists, location: @location)
-        def to_sql = "DROP TRIGGER #{@name}"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      class CreateTrigger < Node
+        attr_reader :name, :timing, :event, :table_name, :function_name
+        def initialize(name, timing, event, table_name, function_name, location: nil)
+          super(location: location)
+          @name, @timing, @event, @table_name, @function_name = name, timing, event, table_name, function_name
+        end
+
+        def accept(visitor) = visitor.visit_create_trigger(self)
+
+        def clone = self.class.new(@name, @timing, @event, @table_name, @function_name, location: @location)
+
+        def to_sql = "CREATE TRIGGER #{@name} #{@timing.to_s.upcase} #{@event.to_s.upcase} ON #{@table_name} EXECUTE FUNCTION #{@function_name}()"
+      end
+
+      class DropTrigger < Node
+        attr_reader :name, :if_exists
+        def initialize(name, if_exists: false, location: nil)
+          super(location: location)
+          @name, @if_exists = name, if_exists
+        end
+
+        def accept(visitor) = visitor.visit_drop_trigger(self)
+
+        def clone = self.class.new(@name, if_exists: @if_exists, location: @location)
+
+        def to_sql = "DROP TRIGGER #{@name}"
+      end
+    end
+  end
+end

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

@@ -1,88 +1,88 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module SQL
-    module AST
-      # UPDATE statement AST node
-      class Update < Node
-        attr_reader :table, :assignments, :where
-
-        def initialize(table, assignments, where = nil, location: nil)
-          super(location: location)
-          @table = table
-          @assignments = assignments
-          @where = where
-        end
-
-        def accept(visitor)
-          visitor.visit_update(self)
-        end
-
-        def clone
-          Update.new(
-            @table,
-            @assignments.map(&:clone),
-            @where&.clone,
-            location: @location
-          )
-        end
-
-        def to_sql
-          parts = []
-          parts << "UPDATE #{@table}"
-          parts << "SET #{@assignments.map(&:to_sql).join(", ")}"
-          parts << "WHERE #{@where.to_sql}" if @where
-          parts.join(" ")
-        end
-
-        def inspect
-          ass = @assignments.map(&:inspect).join(", ")
-          str = "Update(table: #{@table}, assignments: [#{ass}]"
-          str << ", where: #{@where.inspect}" if @where
-          str << ")"
-          str
-        end
-
-        # Helper methods
-        def assignment_count
-          @assignments.size
-        end
-
-        def has_where?
-          !@where.nil?
-        end
-
-        def updated_columns
-          @assignments.map(&:column)
-        end
-      end
-
-      # Assignment in UPDATE statement
-      class Assignment < Node
-        attr_reader :column, :value
-
-        def initialize(column, value, location: nil)
-          super(location: location)
-          @column = column
-          @value = value
-        end
-
-        def accept(visitor)
-          visitor.visit_assignment(self)
-        end
-
-        def clone
-          Assignment.new(@column, @value.clone, location: @location)
-        end
-
-        def to_sql
-          "#{@column} = #{@value.to_sql}"
-        end
-
-        def inspect
-          "Assignment(#{@column} = #{@value.inspect})"
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # UPDATE statement AST node
+      class Update < Node
+        attr_reader :table, :assignments, :where
+
+        def initialize(table, assignments, where = nil, location: nil)
+          super(location: location)
+          @table = table
+          @assignments = assignments
+          @where = where
+        end
+
+        def accept(visitor)
+          visitor.visit_update(self)
+        end
+
+        def clone
+          Update.new(
+            @table,
+            @assignments.map(&:clone),
+            @where&.clone,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = []
+          parts << "UPDATE #{@table}"
+          parts << "SET #{@assignments.map(&:to_sql).join(", ")}"
+          parts << "WHERE #{@where.to_sql}" if @where
+          parts.join(" ")
+        end
+
+        def inspect
+          ass = @assignments.map(&:inspect).join(", ")
+          str = "Update(table: #{@table}, assignments: [#{ass}]"
+          str << ", where: #{@where.inspect}" if @where
+          str << ")"
+          str
+        end
+
+        # Helper methods
+        def assignment_count
+          @assignments.size
+        end
+
+        def has_where?
+          !@where.nil?
+        end
+
+        def updated_columns
+          @assignments.map(&:column)
+        end
+      end
+
+      # Assignment in UPDATE statement
+      class Assignment < Node
+        attr_reader :column, :value
+
+        def initialize(column, value, location: nil)
+          super(location: location)
+          @column = column
+          @value = value
+        end
+
+        def accept(visitor)
+          visitor.visit_assignment(self)
+        end
+
+        def clone
+          Assignment.new(@column, @value.clone, location: @location)
+        end
+
+        def to_sql
+          "#{@column} = #{@value.to_sql}"
+        end
+
+        def inspect
+          "Assignment(#{@column} = #{@value.inspect})"
+        end
+      end
+    end
+  end
+end

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

@@ -1,19 +1,19 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module SQL
-    module AST
-      class Vacuum < Node
-        def accept(visitor)
-          visitor.visit_vacuum(self)
-        end
-
-        def clone
-          self.class.new(location: @location)
-        end
-
-        def to_sql = "VACUUM"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      class Vacuum < Node
+        def accept(visitor)
+          visitor.visit_vacuum(self)
+        end
+
+        def clone
+          self.class.new(location: @location)
+        end
+
+        def to_sql = "VACUUM"
+      end
+    end
+  end
+end

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

@@ -1,32 +1,38 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module SQL
-    module AST
-      class CreateView < Node
-        attr_reader :name, :query, :if_not_exists
-        def initialize(name, query, if_not_exists: false, location: nil)
-          super(location: location)
-          @name = name
-          @query = query
-          @if_not_exists = if_not_exists
-        end
-        def accept(visitor) = visitor.visit_create_view(self)
-        def clone = self.class.new(@name, @query.clone, if_not_exists: @if_not_exists, location: @location)
-        def to_sql = "CREATE VIEW #{@name} AS #{@query.to_sql}"
-      end
-
-      class DropView < 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_view(self)
-        def clone = self.class.new(@name, if_exists: @if_exists, location: @location)
-        def to_sql = "DROP VIEW #{@name}"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      class CreateView < Node
+        attr_reader :name, :query, :if_not_exists
+        def initialize(name, query, if_not_exists: false, location: nil)
+          super(location: location)
+          @name = name
+          @query = query
+          @if_not_exists = if_not_exists
+        end
+
+        def accept(visitor) = visitor.visit_create_view(self)
+
+        def clone = self.class.new(@name, @query.clone, if_not_exists: @if_not_exists, location: @location)
+
+        def to_sql = "CREATE VIEW #{@name} AS #{@query.to_sql}"
+      end
+
+      class DropView < 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_view(self)
+
+        def clone = self.class.new(@name, if_exists: @if_exists, location: @location)
+
+        def to_sql = "DROP VIEW #{@name}"
+      end
+    end
+  end
+end

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

@@ -1,32 +1,32 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module SQL
-    module AST
-      # A materialized WITH query. Recursive CTEs are evaluated iteratively by
-      # the executor with a bounded working set.
-      class With < Node
-        attr_reader :ctes, :query, :recursive
-
-        def initialize(ctes, query, recursive: false, location: nil)
-          super(location: location)
-          @ctes = ctes
-          @query = query
-          @recursive = recursive
-        end
-
-        def accept(visitor) = visitor.visit_with(self)
-
-        def clone
-          With.new(@ctes.map { |name, query| [name, query.clone] }, @query.clone, recursive: @recursive, location: @location)
-        end
-
-        def to_sql
-          definitions = @ctes.map { |name, query| "#{name} AS (#{query.to_sql})" }.join(", ")
-          prefix = @recursive ? "WITH RECURSIVE" : "WITH"
-          "#{prefix} #{definitions} #{@query.to_sql}"
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # A materialized WITH query. Recursive CTEs are evaluated iteratively by
+      # the executor with a bounded working set.
+      class With < Node
+        attr_reader :ctes, :query, :recursive
+
+        def initialize(ctes, query, recursive: false, location: nil)
+          super(location: location)
+          @ctes = ctes
+          @query = query
+          @recursive = recursive
+        end
+
+        def accept(visitor) = visitor.visit_with(self)
+
+        def clone
+          With.new(@ctes.map { |name, query| [name, query.clone] }, @query.clone, recursive: @recursive, location: @location)
+        end
+
+        def to_sql
+          definitions = @ctes.map { |name, query| "#{name} AS (#{query.to_sql})" }.join(", ")
+          prefix = @recursive ? "WITH RECURSIVE" : "WITH"
+          "#{prefix} #{definitions} #{@query.to_sql}"
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/sql/grammar.rb

@@ -1,86 +1,86 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module SQL
-    # SQL Grammar definitions - used for validation and reference
-    module Grammar
-      # SQL statement types
-      STATEMENT_TYPES = {
-        select: "SELECT ... FROM ... [WHERE ...] [ORDER BY ...] [LIMIT ...] [OFFSET ...]",
-        insert: "INSERT INTO table [(columns)] VALUES (values)[, (values)...]",
-        update: "UPDATE table SET column = value [WHERE ...]",
-        delete: "DELETE FROM table [WHERE ...]",
-        create_table: "CREATE TABLE name (column_definitions [, constraints])",
-        create_index: "CREATE [UNIQUE] INDEX name ON table (columns)",
-        create_database: "CREATE DATABASE name",
-        drop_table: "DROP TABLE name",
-        drop_index: "DROP INDEX name",
-        drop_database: "DROP DATABASE name",
-        alter_table: "ALTER TABLE name ADD/DROP column/constraint",
-        begin: "BEGIN [TRANSACTION]",
-        commit: "COMMIT [TRANSACTION]",
-        rollback: "ROLLBACK [TRANSACTION] [TO SAVEPOINT name]",
-        savepoint: "SAVEPOINT name",
-        release_savepoint: "RELEASE [SAVEPOINT] name",
-        explain: "EXPLAIN [ANALYZE] statement",
-        vacuum: "VACUUM",
-        create_view: "CREATE VIEW name AS SELECT ...",
-        create_trigger: "CREATE TRIGGER name BEFORE|AFTER event ON table EXECUTE FUNCTION name()"
-      }.freeze
-
-      # Column data types
-      DATA_TYPES = {
-        integer: "INTEGER",
-        bigint: "BIGINT",
-        smallint: "SMALLINT",
-        float: "FLOAT",
-        decimal: "DECIMAL(precision, scale)",
-        numeric: "NUMERIC(precision, scale)",
-        boolean: "BOOLEAN",
-        text: "TEXT",
-        varchar: "VARCHAR(length)",
-        char: "CHAR(length)",
-        blob: "BLOB",
-        date: "DATE",
-        time: "TIME",
-        timestamp: "TIMESTAMP",
-        json: "JSON",
-        uuid: "UUID"
-      }.freeze
-
-      # Operators
-      OPERATORS = {
-        comparison: ["=", "!=", "<>", "<", "<=", ">", ">="],
-        logical: ["AND", "OR", "NOT"],
-        arithmetic: ["+", "-", "*", "/", "%"],
-        bitwise: ["&", "|", "^", "~"],
-        other: ["LIKE", "ILIKE", "BETWEEN", "IN", "IS", "IS NOT"]
-      }.freeze
-
-      # Constraint types
-      CONSTRAINT_TYPES = {
-        primary_key: "PRIMARY KEY (columns)",
-        foreign_key: "FOREIGN KEY (columns) REFERENCES table (columns)",
-        unique: "UNIQUE (columns)",
-        check: "CHECK (condition)",
-        not_null: "NOT NULL"
-      }.freeze
-
-      def self.validate_statement_type(type)
-        STATEMENT_TYPES.key?(type) ? true : false
-      end
-
-      def self.validate_data_type(type)
-        DATA_TYPES.key?(type) ? true : false
-      end
-
-      def self.validate_operator(op)
-        OPERATORS.values.flatten.include?(op.to_s.upcase)
-      end
-
-      def self.validate_constraint_type(type)
-        CONSTRAINT_TYPES.key?(type) ? true : false
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    # SQL Grammar definitions - used for validation and reference
+    module Grammar
+      # SQL statement types
+      STATEMENT_TYPES = {
+        select: "SELECT ... FROM ... [WHERE ...] [ORDER BY ...] [LIMIT ...] [OFFSET ...]",
+        insert: "INSERT INTO table [(columns)] VALUES (values)[, (values)...]",
+        update: "UPDATE table SET column = value [WHERE ...]",
+        delete: "DELETE FROM table [WHERE ...]",
+        create_table: "CREATE TABLE name (column_definitions [, constraints])",
+        create_index: "CREATE [UNIQUE] INDEX name ON table (columns)",
+        create_database: "CREATE DATABASE name",
+        drop_table: "DROP TABLE name",
+        drop_index: "DROP INDEX name",
+        drop_database: "DROP DATABASE name",
+        alter_table: "ALTER TABLE name ADD/DROP column/constraint",
+        begin: "BEGIN [TRANSACTION]",
+        commit: "COMMIT [TRANSACTION]",
+        rollback: "ROLLBACK [TRANSACTION] [TO SAVEPOINT name]",
+        savepoint: "SAVEPOINT name",
+        release_savepoint: "RELEASE [SAVEPOINT] name",
+        explain: "EXPLAIN [ANALYZE] statement",
+        vacuum: "VACUUM",
+        create_view: "CREATE VIEW name AS SELECT ...",
+        create_trigger: "CREATE TRIGGER name BEFORE|AFTER event ON table EXECUTE FUNCTION name()"
+      }.freeze
+
+      # Column data types
+      DATA_TYPES = {
+        integer: "INTEGER",
+        bigint: "BIGINT",
+        smallint: "SMALLINT",
+        float: "FLOAT",
+        decimal: "DECIMAL(precision, scale)",
+        numeric: "NUMERIC(precision, scale)",
+        boolean: "BOOLEAN",
+        text: "TEXT",
+        varchar: "VARCHAR(length)",
+        char: "CHAR(length)",
+        blob: "BLOB",
+        date: "DATE",
+        time: "TIME",
+        timestamp: "TIMESTAMP",
+        json: "JSON",
+        uuid: "UUID"
+      }.freeze
+
+      # Operators
+      OPERATORS = {
+        comparison: ["=", "!=", "<>", "<", "<=", ">", ">="],
+        logical: ["AND", "OR", "NOT"],
+        arithmetic: ["+", "-", "*", "/", "%"],
+        bitwise: ["&", "|", "^", "~"],
+        other: ["LIKE", "ILIKE", "BETWEEN", "IN", "IS", "IS NOT"]
+      }.freeze
+
+      # Constraint types
+      CONSTRAINT_TYPES = {
+        primary_key: "PRIMARY KEY (columns)",
+        foreign_key: "FOREIGN KEY (columns) REFERENCES table (columns)",
+        unique: "UNIQUE (columns)",
+        check: "CHECK (condition)",
+        not_null: "NOT NULL"
+      }.freeze
+
+      def self.validate_statement_type(type)
+        STATEMENT_TYPES.key?(type)
+      end
+
+      def self.validate_data_type(type)
+        DATA_TYPES.key?(type)
+      end
+
+      def self.validate_operator(op)
+        OPERATORS.values.flatten.include?(op.to_s.upcase)
+      end
+
+      def self.validate_constraint_type(type)
+        CONSTRAINT_TYPES.key?(type)
+      end
+    end
+  end
+end