agnostic_backend 0.9.0

data/lib/agnostic_backend/queryable/criteria/ternary.rb

@@ -0,0 +1,36 @@
+module AgnosticBackend
+  module Queryable
+    module Criteria
+      class Ternary < Criterion
+        attr_reader :attribute, :left_value, :right_value
+
+        def initialize(attribute:, left_value:, right_value:, context: nil)
+          @attribute, @left_value, @right_value = attribute, left_value, right_value
+          super([attribute, left_value, right_value], context)
+        end
+      end
+
+      class Between < Ternary
+        def initialize(attribute:, left_value:, right_value:, context: nil)
+          attribute = attribute_component(attribute: attribute, context: context)
+          left_value = value_component(value: left_value, context: context, type: attribute.type)
+          right_value = value_component(value: right_value, context: context, type: attribute.type)
+          super(attribute: attribute, left_value: left_value, right_value: right_value, context: context)
+        end
+      end
+
+      class GreaterAndLess < Between;
+      end
+
+      class GreaterEqualAndLess < Between;
+      end
+
+      class GreaterAndLessEqual < Between;
+      end
+
+      class GreaterEqualAndLessEqual < Between;
+      end
+
+    end
+  end
+end

data/lib/agnostic_backend/queryable/criteria_builder.rb

@@ -0,0 +1,83 @@
+module AgnosticBackend
+  module Queryable
+    class CriteriaBuilder
+
+      attr_reader :context
+
+      def initialize(query_builder)
+        @context = query_builder
+      end
+
+      def eq(attribute, value)
+        Criteria::Equal.new(attribute: attribute, value: value, context: context)
+      end
+
+      def neq(attribute, value)
+        Criteria::NotEqual.new(attribute: attribute, value: value, context: context)
+      end
+
+      def gt(attribute, value)
+        Criteria::Greater.new(attribute: attribute, value: value, context: context)
+      end
+
+      def lt(attribute, value)
+        Criteria::Less.new(attribute: attribute, value: value, context: context)
+      end
+
+      def ge(attribute, value)
+        Criteria::GreaterEqual.new(attribute: attribute, value: value, context: context)
+      end
+
+      def le(attribute, value)
+        Criteria::LessEqual.new(attribute: attribute, value: value, context: context)
+      end
+
+      def gt_and_lt(attribute, left_limit, right_limit)
+        Criteria::GreaterAndLess.new(attribute: attribute, left_value: left_limit, right_value: right_limit, context: context)
+      end
+
+      def gt_and_le(attribute, left_limit, right_limit)
+        Criteria::GreaterAndLessEqual.new(attribute: attribute, left_value: left_limit, right_value: right_limit, context: context)
+      end
+
+      def ge_and_lt(attribute, left_limit, right_limit)
+        Criteria::GreaterEqualAndLess.new(attribute: attribute, left_value: left_limit, right_value: right_limit, context: context)
+      end
+
+      def ge_and_le(attribute, left_limit, right_limit)
+        Criteria::GreaterEqualAndLessEqual.new(attribute: attribute, left_value: left_limit, right_value: right_limit, context: context)
+      end
+
+      def contains(attribute, value)
+        Criteria::Contains.new(attribute: attribute, value: value, context: context)
+      end
+
+      def starts(attribute, value)
+        Criteria::Starts.new(attribute: attribute, value: value, context: context)
+      end
+
+      def asc(attribute)
+        Operations::Ascending.new(attribute: attribute, context: context)
+      end
+
+      def desc(attribute)
+        Operations::Descending.new(attribute: attribute, context: context)
+      end
+
+      def not(criterion)
+        Operations::Not.new(operand: criterion, context: context)
+      end
+
+      def and(*criteria)
+        Operations::And.new(operands: criteria, context: context)
+      end
+
+      def or(*criteria)
+        Operations::Or.new(operands: criteria, context: context)
+      end
+
+      alias_method :all, :and
+      alias_method :any, :or
+    end
+  end
+end

data/lib/agnostic_backend/queryable/executor.rb

@@ -0,0 +1,43 @@
+module AgnosticBackend
+  module Queryable
+    class Executor
+
+      attr_reader :query
+      attr_reader :visitor
+
+      def initialize(query, visitor)
+        @query, @visitor = query, visitor
+      end
+
+      def execute
+        raise NotImplementedError, 'Abstract method'
+      end
+
+      private
+
+      def order_expression
+        query.children.find { |e| e.is_a? Expressions::Order }
+      end
+
+      def where_expression
+        query.children.find { |e| e.is_a? Expressions::Where }
+      end
+
+      def select_expression
+        query.children.find { |e| e.is_a? Expressions::Select }
+      end
+
+      def limit_expression
+        query.children.find { |e| e.is_a? Expressions::Limit }
+      end
+
+      def offset_expression
+        query.children.find { |e| e.is_a? Expressions::Offset }
+      end
+
+      def scroll_cursor_expression
+        query.children.find { |e| e.is_a? Expressions::ScrollCursor }
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/expressions/expression.rb

@@ -0,0 +1,65 @@
+module AgnosticBackend
+  module Queryable
+    module Expressions
+      class Expression < TreeNode
+      end
+
+      class Where < Expression
+        def initialize(criterion:, context:)
+          super([criterion], context)
+        end
+
+        def criterion
+          children.first
+        end
+      end
+
+      class Select < Expression
+        def initialize(attributes:, context:)
+          super(attributes.map { |a| Attribute.new(a, parent: self, context: context) }, context)
+        end
+
+        alias_method :projections, :children
+      end
+
+      class Order < Expression
+        def initialize(attributes:, context:)
+          super(attributes, context)
+        end
+
+        alias_method :qualifiers, :children
+      end
+
+      class Limit < Expression
+        def initialize(value:, context:)
+          super([Value.new(value, parent: self, context: context)], context)
+        end
+
+        def limit
+          children.first
+        end
+      end
+
+      class Offset < Expression
+        def initialize(value:, context:)
+          super([Value.new(value, parent: self, context: context)], context)
+        end
+
+        def offset
+          children.first
+        end
+      end
+
+      class ScrollCursor < Expression
+        def initialize(value:, context:)
+          super([Value.new(value, parent: self, context: context)], context)
+        end
+
+        def scroll_cursor
+          children.first
+        end
+      end
+
+    end
+  end
+end

data/lib/agnostic_backend/queryable/operations/n_ary.rb

@@ -0,0 +1,18 @@
+module AgnosticBackend
+  module Queryable
+    module Operations
+      class NAry < Operation
+
+        def initialize(operands:, context: nil)
+          super(operands, context)
+        end
+      end
+
+      class And < NAry;
+      end
+
+      class Or < NAry;
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/operations/operation.rb

@@ -0,0 +1,13 @@
+module AgnosticBackend
+  module Queryable
+    module Operations
+      class Operation < TreeNode
+        def initialize(operands = [], context = nil)
+          super
+        end
+
+        alias_method :operands, :children
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/operations/unary.rb

@@ -0,0 +1,35 @@
+module AgnosticBackend
+  module Queryable
+    module Operations
+      class Unary < Operation
+        attr_reader :operand
+
+        def initialize(operand:, context: nil)
+          @operand = operand
+          super([operand], context)
+        end
+      end
+
+      class Not < Unary
+        def initialize(operand:, context:)
+          super(operand: operand, context: context)
+        end
+      end
+
+      class OrderQualifier < Unary
+        def initialize(attribute:, context: nil)
+          attribute = attribute_component(attribute: attribute, context: context)
+          super(operand: attribute, context: context)
+        end
+
+        alias_method :attribute, :operand
+      end
+
+      class Ascending < OrderQualifier;
+      end
+
+      class Descending < OrderQualifier;
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/query.rb

@@ -0,0 +1,27 @@
+module AgnosticBackend
+  module Queryable
+    class Query < TreeNode
+      attr_accessor :errors
+      attr_reader :context
+
+      def initialize(context)
+        super()
+        @errors ||= Hash.new { |hash, key| hash[key] = Array.new }
+        @context = context
+      end
+
+      def execute
+        raise NotImplementedError
+      end
+
+      def valid?
+        self.accept(AgnosticBackend::Queryable::Validator.new)
+      end
+
+     def set_scroll_cursor(value)
+        context.scroll_cursor(value)
+        context.build
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/query_builder.rb

@@ -0,0 +1,98 @@
+module AgnosticBackend
+  module Queryable
+    class QueryBuilder
+
+      attr_reader :index
+      attr_reader :query
+
+      def initialize(index)
+        @index = index
+      end
+
+      def criteria_builder
+        CriteriaBuilder.new(self)
+      end
+
+      def where(criterion)
+        @criterion = criterion
+        self
+      end
+
+      def select(*attributes)
+        (@projections ||= []).push(*attributes)
+        self
+      end
+
+      def order(attribute, direction)
+        (@order_qualifiers ||= []).push build_order_qualifier(attribute, direction)
+        self
+      end
+
+      def limit(value)
+        @limit = value
+        self
+      end
+
+      def offset(value)
+        @offset = value
+        self
+      end
+
+      def scroll_cursor(value)
+        @scroll_cursor = value
+        self
+      end
+
+      def build
+        query = create_query(self)
+        query.children << build_where_expression if @criterion
+        query.children << build_select_expression if @projections
+        query.children << build_order_expression if @order_qualifiers
+        query.children << build_limit_expression if @limit
+        query.children << build_offset_expression if @offset
+        query.children << build_scroll_cursor_expression if @scroll_cursor
+
+        @query = query
+      end
+
+      private
+
+      def create_query(context)
+        raise NotImplementedError, 'AbstractMethod'
+      end
+
+      def build_where_expression
+        Expressions::Where.new(criterion: @criterion, context: self)
+      end
+
+      def build_select_expression
+        Expressions::Select.new(attributes: @projections, context: self)
+      end
+
+      def build_order_expression
+        Expressions::Order.new(attributes: @order_qualifiers, context: self)
+      end
+
+      def build_limit_expression
+        Expressions::Limit.new(value: @limit, context: self)
+      end
+
+      def build_offset_expression
+        Expressions::Offset.new(value: @offset, context: self)
+      end
+
+      def build_scroll_cursor_expression
+        Expressions::ScrollCursor.new(value: @scroll_cursor, context: self)
+      end
+
+      def build_order_qualifier(attribute, direction)
+        case direction
+          when :asc
+            Operations::Ascending.new(attribute: attribute, context: self)
+          when :desc
+            Operations::Descending.new(attribute: attribute, context: self)
+        end
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/result_set.rb

@@ -0,0 +1,42 @@
+module AgnosticBackend
+  module Queryable
+    class ResultSet
+
+      include Enumerable
+
+      attr_reader :raw_results, :query
+
+      def initialize(raw_results, query)
+        @raw_results, @query = raw_results, query
+      end
+
+      def each(&block)
+        filtered_results.each do |result|
+          block.call(transform(result))
+        end
+      end
+
+      def empty?
+        none?
+      end
+
+      def total_count
+        raise NotImplementedError
+      end
+
+      def offset
+        raise NotImplementedError
+      end
+
+      private
+
+      def filtered_results
+        raise NotImplementedError
+      end
+
+      def transform(result)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/tree_node.rb

@@ -0,0 +1,48 @@
+module AgnosticBackend
+  module Queryable
+    class TreeNode
+      include AgnosticBackend::Utilities
+      # include Enumerable
+
+      attr_reader :children
+      attr_reader :context
+
+      def initialize(children = [], context = nil)
+        @children, @context = children, context
+      end
+
+      # def each(&block)
+      #   block.call(self)
+      #   children.each{|child| child.each(&block)  }
+      # end
+
+      def ==(other)
+        return true if self.__id__ == other.__id__
+        return false if other.nil?
+        return false unless other.is_a? AgnosticBackend::Queryable::TreeNode
+
+        return false unless other.children.size == children.size
+        children_pairs = other.children.zip(children)
+
+        other.class == self.class &&
+          children_pairs.all? do |first_child, second_child|
+            first_child == second_child
+          end
+      end
+
+      def accept(visitor)
+        visitor.visit(self)
+      end
+
+     private
+
+      def attribute_component(attribute:, context: nil)
+        Attribute.new(attribute, parent: self, context: context)
+      end
+
+      def value_component(value:, context: nil, type:)
+        Value.new(convert_to(type, value), parent: self, context: context)
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/validator.rb

@@ -0,0 +1,174 @@
+module AgnosticBackend
+  module Queryable
+    class Validator < AgnosticBackend::Queryable::Visitor
+
+      include AgnosticBackend::Utilities
+
+      def initialize
+        @valid = true
+      end
+
+      private
+
+      def visit_query(subject)
+        subject.children.each { |c| visit(c) }
+        @valid
+      end
+
+      def visit_criteria_equal(subject)
+        visit(subject.attribute)
+        visit(subject.value)
+      end
+
+      def visit_criteria_not_equal(subject)
+        visit(subject.attribute)
+        visit(subject.value)
+      end
+
+      def visit_criteria_greater(subject)
+        visit(subject.attribute)
+        visit(subject.value)
+      end
+
+      def visit_criteria_less(subject)
+        visit(subject.attribute)
+        visit(subject.value)
+      end
+
+      def visit_criteria_greater_equal(subject)
+        visit(subject.attribute)
+        visit(subject.value)
+      end
+
+      def visit_criteria_less_equal(subject)
+        visit(subject.attribute)
+        visit(subject.value)
+      end
+
+      def visit_criteria_contains(subject)
+        visit(subject.attribute)
+        visit(subject.value)
+      end
+
+      def visit_criteria_starts(subject)
+        visit(subject.attribute)
+        visit(subject.value)
+      end
+
+      def visit_criteria_greater_and_less(subject)
+        visit(subject.attribute)
+        visit(subject.left_value)
+        visit(subject.right_value)
+      end
+
+      def visit_criteria_greater_equal_and_less(subject)
+        visit(subject.attribute)
+        visit(subject.left_value)
+        visit(subject.right_value)
+      end
+
+      def visit_criteria_greater_and_less_equal(subject)
+        visit(subject.attribute)
+        visit(subject.left_value)
+        visit(subject.right_value)
+      end
+
+      def visit_criteria_greater_equal_and_less_equal(subject)
+        visit(subject.attribute)
+        visit(subject.left_value)
+        visit(subject.right_value)
+      end
+
+      def visit_operations_not(subject)
+        visit(subject.operand)
+      end
+
+      def visit_operations_and(subject)
+        subject.operands.each { |o| visit(o) }
+      end
+
+      def visit_operations_or(subject)
+        subject.operands.each { |o| visit(o) }
+      end
+
+      def visit_operations_ascending(subject)
+        visit(subject.attribute)
+      end
+
+      def visit_operations_descending(subject)
+        visit(subject.attribute)
+      end
+
+      def visit_expressions_where(subject)
+        visit(subject.criterion)
+      end
+
+      def visit_expressions_select(subject)
+        subject.projections.each { |c| visit(c) }
+      end
+
+      def visit_expressions_order(subject)
+        subject.qualifiers.each { |c| visit(c) }
+      end
+
+      def visit_expressions_limit(subject)
+        visit(subject.limit)
+      end
+
+      def visit_expressions_offset(subject)
+        visit(subject.offset)
+      end
+
+      def visit_expressions_scroll_cursor(subject)
+        visit(subject.scroll_cursor)
+      end
+
+      def visit_attribute(subject)
+        if value_for_key(subject.context.index.schema, subject.name).nil?
+          subject.context.query.errors[subject.class.name] << attribute_error(subject)
+          @valid = false
+        end
+      end
+
+      def visit_value(subject)
+        case subject.type
+        when :integer
+          unless subject.value.is_a?(Fixnum)
+            subject.context.query.errors[subject.class.name] << value_error(subject)
+            @valid = false
+          end
+        when :double
+          unless subject.value.is_a?(Float)
+            subject.context.query.errors[subject.class.name] << value_error(subject)
+            @valid = false
+          end
+        when :string,:string_array,:text,:text_array
+          unless subject.value.is_a?(String)
+            subject.context.query.errors[subject.class.name] << value_error(subject)
+            @valid = false
+          end
+        when :date
+          unless subject.value.is_a?(Time)
+            subject.context.query.errors[subject.class.name] << value_error(subject)
+            @valid = false
+          end
+        when :boolean
+          unless subject.value.is_a?(TrueClass) || subject.value.is_a?(FalseClass)
+            subject.context.query.errors[subject.class.name] << value_error(subject)
+            @valid = false
+          end
+        else
+          true
+        end
+      end
+
+      def value_error(subject)
+        "Value #{subject.value} for #{subject.associated_attribute.name} in #{subject.parent.class.name} is defined as #{subject.type} type in schema"
+      end
+
+      def attribute_error(subject)
+        "Attribute '#{subject.name}' in #{subject.parent.class.name} missing from schema"
+      end
+    end
+  end
+end