omg-activerecord 8.0.0.alpha1

data/lib/arel/nodes/case.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Case < Arel::Nodes::NodeExpression
+      attr_accessor :case, :conditions, :default
+
+      def initialize(expression = nil, default = nil)
+        @case = expression
+        @conditions = []
+        @default = default
+      end
+
+      def when(condition, expression = nil)
+        @conditions << When.new(Nodes.build_quoted(condition), expression)
+        self
+      end
+
+      def then(expression)
+        @conditions.last.right = Nodes.build_quoted(expression)
+        self
+      end
+
+      def else(expression)
+        @default = Else.new Nodes.build_quoted(expression)
+        self
+      end
+
+      def initialize_copy(other)
+        super
+        @case = @case.clone if @case
+        @conditions = @conditions.map { |x| x.clone }
+        @default = @default.clone if @default
+      end
+
+      def hash
+        [@case, @conditions, @default].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.case == other.case &&
+          self.conditions == other.conditions &&
+          self.default == other.default
+      end
+      alias :== :eql?
+    end
+
+    class When < Binary # :nodoc:
+    end
+
+    class Else < Unary # :nodoc:
+    end
+  end
+end

data/lib/arel/nodes/casted.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Casted < Arel::Nodes::NodeExpression # :nodoc:
+      attr_reader :value, :attribute
+      alias :value_before_type_cast :value
+
+      def initialize(value, attribute)
+        @value     = value
+        @attribute = attribute
+        super()
+      end
+
+      def nil?; value.nil?; end
+
+      def value_for_database
+        if attribute.able_to_type_cast?
+          attribute.type_cast_for_database(value)
+        else
+          value
+        end
+      end
+
+      def hash
+        [self.class, value, attribute].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.value == other.value &&
+          self.attribute == other.attribute
+      end
+      alias :== :eql?
+    end
+
+    class Quoted < Arel::Nodes::Unary # :nodoc:
+      alias :value_for_database :value
+      alias :value_before_type_cast :value
+
+      def nil?; value.nil?; end
+
+      def infinite?
+        value.respond_to?(:infinite?) && value.infinite?
+      end
+    end
+
+    def self.build_quoted(other, attribute = nil)
+      case other
+      when Arel::Nodes::Node, Arel::Attributes::Attribute, Arel::Table, Arel::SelectManager, Arel::Nodes::SqlLiteral, ActiveModel::Attribute
+        other
+      else
+        case attribute
+        when Arel::Attributes::Attribute
+          Casted.new other, attribute
+        else
+          Quoted.new other
+        end
+      end
+    end
+  end
+end

data/lib/arel/nodes/comment.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Comment < Arel::Nodes::Node
+      attr_reader :values
+
+      def initialize(values)
+        super()
+        @values = values
+      end
+
+      def initialize_copy(other)
+        super
+        @values = @values.clone
+      end
+
+      def hash
+        [@values].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.values == other.values
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/count.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Count < Arel::Nodes::Function
+      def initialize(expr, distinct = false, aliaz = nil)
+        super(expr, aliaz)
+        @distinct = distinct
+      end
+    end
+  end
+end

data/lib/arel/nodes/cte.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Cte < Arel::Nodes::Binary
+      alias :name :left
+      alias :relation :right
+      attr_reader :materialized
+
+      def initialize(name, relation, materialized: nil)
+        super(name, relation)
+        @materialized = materialized
+      end
+
+      def hash
+        [name, relation, materialized].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.name == other.name &&
+          self.relation == other.relation &&
+          self.materialized == other.materialized
+      end
+      alias :== :eql?
+
+      def to_cte
+        self
+      end
+
+      def to_table
+        Arel::Table.new(name)
+      end
+    end
+  end
+end

data/lib/arel/nodes/delete_statement.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class DeleteStatement < Arel::Nodes::Node
+      attr_accessor :relation, :wheres, :groups, :havings, :orders, :limit, :offset, :key
+
+      def initialize(relation = nil, wheres = [])
+        super()
+        @relation = relation
+        @wheres = wheres
+        @groups = []
+        @havings = []
+        @orders = []
+        @limit = nil
+        @offset = nil
+        @key = nil
+      end
+
+      def initialize_copy(other)
+        super
+        @relation = @relation.clone if @relation
+        @wheres = @wheres.clone if @wheres
+      end
+
+      def hash
+        [self.class, @relation, @wheres, @orders, @limit, @offset, @key].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.relation == other.relation &&
+          self.wheres == other.wheres &&
+          self.orders == other.orders &&
+          self.groups == other.groups &&
+          self.havings == other.havings &&
+          self.limit == other.limit &&
+          self.offset == other.offset &&
+          self.key == other.key
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/descending.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Descending < Ordering
+      def reverse
+        Ascending.new(expr)
+      end
+
+      def direction
+        :desc
+      end
+
+      def ascending?
+        false
+      end
+
+      def descending?
+        true
+      end
+    end
+  end
+end

data/lib/arel/nodes/equality.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Equality < Arel::Nodes::Binary
+      include FetchAttribute
+
+      def equality?; true; end
+
+      def invert
+        Arel::Nodes::NotEqual.new(left, right)
+      end
+    end
+  end
+end

data/lib/arel/nodes/extract.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Extract < Arel::Nodes::Unary
+      attr_accessor :field
+
+      def initialize(expr, field)
+        super(expr)
+        @field = field
+      end
+
+      def hash
+        super ^ @field.hash
+      end
+
+      def eql?(other)
+        super &&
+          self.field == other.field
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/false.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class False < Arel::Nodes::NodeExpression
+      def hash
+        self.class.hash
+      end
+
+      def eql?(other)
+        self.class == other.class
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/filter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Filter < Binary
+      include Arel::WindowPredications
+      include Arel::AliasPredication
+    end
+  end
+end

data/lib/arel/nodes/fragments.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Fragments < Arel::Nodes::Node
+      attr_reader :values
+
+      def initialize(values = [])
+        super()
+        @values = values
+      end
+
+      def initialize_copy(other)
+        super
+        @values = @values.clone
+      end
+
+      def hash
+        [@values].hash
+      end
+
+      def +(other)
+        raise ArgumentError, "Expected Arel node" unless Arel.arel_node?(other)
+
+        self.class.new([*@values, other])
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.values == other.values
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/full_outer_join.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class FullOuterJoin < Arel::Nodes::Join
+    end
+  end
+end

data/lib/arel/nodes/function.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Function < Arel::Nodes::NodeExpression
+      include Arel::WindowPredications
+      include Arel::FilterPredications
+      attr_accessor :expressions, :alias, :distinct
+
+      def initialize(expr, aliaz = nil)
+        super()
+        @expressions = expr
+        @alias       = aliaz && SqlLiteral.new(aliaz)
+        @distinct    = false
+      end
+
+      def as(aliaz)
+        self.alias = SqlLiteral.new(aliaz)
+        self
+      end
+
+      def hash
+        [@expressions, @alias, @distinct].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.expressions == other.expressions &&
+          self.alias == other.alias &&
+          self.distinct == other.distinct
+      end
+      alias :== :eql?
+    end
+
+    %w{
+      Sum
+      Exists
+      Max
+      Min
+      Avg
+    }.each do |name|
+      const_set(name, Class.new(Function))
+    end
+  end
+end

data/lib/arel/nodes/grouping.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Grouping < Unary
+      def fetch_attribute(&block)
+        expr.fetch_attribute(&block)
+      end
+    end
+  end
+end

data/lib/arel/nodes/homogeneous_in.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class HomogeneousIn < Node
+      attr_reader :attribute, :values, :type
+
+      def initialize(values, attribute, type)
+        @values = values
+        @attribute = attribute
+        @type = type
+      end
+
+      def hash
+        ivars.hash
+      end
+
+      def eql?(other)
+        super || (self.class == other.class && self.ivars == other.ivars)
+      end
+      alias :== :eql?
+
+      def equality?
+        type == :in
+      end
+
+      def invert
+        Arel::Nodes::HomogeneousIn.new(values, attribute, type == :in ? :notin : :in)
+      end
+
+      def left
+        attribute
+      end
+
+      def right
+        attribute.quoted_array(values)
+      end
+
+      def casted_values
+        type = attribute.type_caster
+
+        casted_values = values.map do |raw_value|
+          type.serialize(raw_value) if type.serializable?(raw_value)
+        end
+
+        casted_values.compact!
+        casted_values
+      end
+
+      def proc_for_binds
+        -> value { ActiveModel::Attribute.with_cast_value(attribute.name, value, ActiveModel::Type.default_value) }
+      end
+
+      def fetch_attribute(&block)
+        if attribute
+          yield attribute
+        else
+          expr.fetch_attribute(&block)
+        end
+      end
+
+      protected
+        def ivars
+          [@attribute, @values, @type]
+        end
+    end
+  end
+end

data/lib/arel/nodes/in.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class In < Arel::Nodes::Binary
+      include FetchAttribute
+
+      def equality?; true; end
+
+      def invert
+        Arel::Nodes::NotIn.new(left, right)
+      end
+    end
+  end
+end

data/lib/arel/nodes/infix_operation.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class InfixOperation < Binary
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::OrderPredications
+      include Arel::AliasPredication
+      include Arel::Math
+
+      attr_reader :operator
+
+      def initialize(operator, left, right)
+        super(left, right)
+        @operator = operator
+      end
+    end
+
+    class Multiplication < InfixOperation
+      def initialize(left, right)
+        super(:*, left, right)
+      end
+    end
+
+    class Division < InfixOperation
+      def initialize(left, right)
+        super(:/, left, right)
+      end
+    end
+
+    class Addition < InfixOperation
+      def initialize(left, right)
+        super(:+, left, right)
+      end
+    end
+
+    class Subtraction < InfixOperation
+      def initialize(left, right)
+        super(:-, left, right)
+      end
+    end
+
+    class Concat < InfixOperation
+      def initialize(left, right)
+        super(:"||", left, right)
+      end
+    end
+
+    class Contains < InfixOperation
+      def initialize(left, right)
+        super(:"@>", left, right)
+      end
+    end
+
+    class Overlaps < InfixOperation
+      def initialize(left, right)
+        super(:"&&", left, right)
+      end
+    end
+
+    class BitwiseAnd < InfixOperation
+      def initialize(left, right)
+        super(:&, left, right)
+      end
+    end
+
+    class BitwiseOr < InfixOperation
+      def initialize(left, right)
+        super(:|, left, right)
+      end
+    end
+
+    class BitwiseXor < InfixOperation
+      def initialize(left, right)
+        super(:^, left, right)
+      end
+    end
+
+    class BitwiseShiftLeft < InfixOperation
+      def initialize(left, right)
+        super(:<<, left, right)
+      end
+    end
+
+    class BitwiseShiftRight < InfixOperation
+      def initialize(left, right)
+        super(:>>, left, right)
+      end
+    end
+  end
+end

data/lib/arel/nodes/inner_join.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class InnerJoin < Arel::Nodes::Join
+    end
+  end
+end

data/lib/arel/nodes/insert_statement.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class InsertStatement < Arel::Nodes::Node
+      attr_accessor :relation, :columns, :values, :select
+
+      def initialize(relation = nil)
+        super()
+        @relation = relation
+        @columns  = []
+        @values   = nil
+        @select   = nil
+      end
+
+      def initialize_copy(other)
+        super
+        @columns = @columns.clone
+        @values =  @values.clone if @values
+        @select =  @select.clone if @select
+      end
+
+      def hash
+        [@relation, @columns, @values, @select].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.relation == other.relation &&
+          self.columns == other.columns &&
+          self.select == other.select &&
+          self.values == other.values
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/join_source.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    ###
+    # Class that represents a join source
+    #
+    #   https://www.sqlite.org/syntaxdiagrams.html#join-source
+
+    class JoinSource < Arel::Nodes::Binary
+      def initialize(single_source, joinop = [])
+        super
+      end
+
+      def empty?
+        !left && right.empty?
+      end
+    end
+  end
+end

data/lib/arel/nodes/leading_join.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class LeadingJoin < Arel::Nodes::InnerJoin
+    end
+  end
+end