axiom-arango-adapter 0.0.1

data/lib/axiom/adapter/arango/visitor.rb

@@ -0,0 +1,100 @@
+module Axiom
+  module Adapter
+    module Arango
+      # Base class for relation specific visitors
+      class Visitor
+        include AbstractType, Adamantium::Flat, Concord.new(:input, :context), AQL
+
+        abstract_method :root
+
+        # Return an AQL node from the relation
+        #
+        # @param [Relation] relation
+        #
+        # @return [AQL::Node]
+        #
+        # @api private
+        #
+        def self.run(relation)
+          build(relation).root
+        end
+
+        REGISTRY = {}
+
+        # Register handler for the axiom relation
+        #
+        # @param [Class] klass
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def self.handle(klass)
+          REGISTRY[klass]=self
+        end
+
+        private_class_method :handle
+
+        # Return visitor for relation and context
+        #
+        # @param [Relation] relation
+        # @param [Visitor] context
+        #
+        # @return [Visitor]
+        #
+        # @api private
+        #
+        def self.build(relation, context = nil)
+          REGISTRY.fetch(relation.class).new(relation, context)
+        end
+
+      protected
+
+        # Return depth
+        #
+        # @return [Integer]
+        #
+        # @api private
+        #
+        def depth
+          context = self.context
+          if context
+            context.depth + 1
+          else
+            0
+          end
+        end
+        memoize :depth
+
+      private
+
+        # Return a visitor for the given relation
+        #
+        # @param [Relation] relation
+        # @param [Visitor] context
+        #
+        # @return [Visitor]
+        #
+        # @api private
+        #
+        def visitor(relation, context = self)
+          self.class.build(relation, context)
+        end
+
+        # Return an AQL node from visiting axiom a given relation
+        #
+        # @param [Relation] relation
+        # @param [Visitor] context
+        #
+        # @return [AQL::Node]
+        #
+        # @api private
+        #
+        def visit(relation, context = self)
+          visitor(relation, context).root
+        end
+
+      end
+    end
+  end
+end

data/lib/axiom/adapter/arango/visitor/aggregate.rb

@@ -0,0 +1,132 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        # Base class for aggregate visitors
+        class Aggregate < self
+
+          LOCAL_NAME = AQL.name_node('aggregate')
+
+          # Return root AQL node
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def root
+            Node::Call.new(self.class::FUNCTION, [mapped])
+          end
+          memoize :root
+
+        private
+
+          # Return attribute name used for mapping
+          #
+          # @return [AQL::Node::Name]
+          #
+          # @api private
+          #
+          def map_attribute_name
+            Node::Name.new(input.operand.name.to_s)
+          end
+          memoize :map_attribute_name
+
+          # Return summarization attribute
+          #
+          # @return [AQL::Node::Attribute]
+          #
+          # @api private
+          #
+          def summarization_attribute
+            Node::Attribute.new(For::Summarization::LOCAL_NAME, map_attribute_name)
+          end
+
+          # Return attribute used for mapping
+          #
+          # @return [AQL::Node::Attribute]
+          #
+          # @api private
+          #
+          def map_attribute
+            Node::Attribute.new(LOCAL_NAME, summarization_attribute)
+          end
+          memoize :map_attribute
+
+          # Return mapped collection
+          #
+          # @return [AQL::Node::Operation::For]
+          #
+          # @api private
+          #
+          def mapped
+            Node::Operation::For.new(
+              LOCAL_NAME,
+              For::Summarization::COLLECT_NAME,
+              map_body
+            )
+          end
+
+          # Return map filter operation
+          #
+          # @return [AQL::Node::Operation::Unary::Filter]
+          #
+          # @api private
+          #
+          def map_filter
+            Node::Operation::Unary::Filter.new(
+              Node::Operator::Binary::Inequality.new(map_attribute, Node::Literal::Singleton::NULL)
+            )
+          end
+
+          # Return map return operation
+          #
+          # @return [AQL::Node::Operation::Unary::Return]
+          #
+          # @api private
+          #
+          def map_return
+            Node::Operation::Unary::Return.new(map_attribute)
+          end
+
+          # Return map body
+          #
+          # @return [AQL::Node::Block]
+          #
+          # @api private
+          #
+          def map_body
+            Node::Block.new([
+              map_filter,
+              map_return
+            ])
+          end
+
+          # Visitor for count aggregate
+          class Count < self
+            FUNCTION = 'LENGTH'.freeze
+            handle(Axiom::Aggregate::Count)
+          end
+
+          # Visitor for sum aggregate
+          class Sum < self
+            FUNCTION = 'SUM'.freeze
+            handle(Axiom::Aggregate::Sum)
+          end
+
+          # Visitor for maximum aggregate
+          class Maximum < self
+            FUNCTION = 'MAX'.freeze
+            handle(Axiom::Aggregate::Maximum)
+          end
+
+          # Visitor for minimum aggregate
+          class Minimum < self
+            FUNCTION = 'MIN'.freeze
+            handle(Axiom::Aggregate::Minimum)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/axiom/adapter/arango/visitor/attribute.rb

@@ -0,0 +1,26 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        # Visitor for attribute accesses
+        class Attribute < self
+
+          handle(Axiom::Attribute::String)
+          handle(Axiom::Attribute::Integer)
+
+          # Return root AQL node
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def root
+            Node::Attribute.new(context.local_name, AQL.name_node(input.name))
+          end
+          memoize :root
+
+        end
+      end
+    end
+  end
+end

data/lib/axiom/adapter/arango/visitor/binary.rb

@@ -0,0 +1,77 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        # Visitor for binary AQL nodes
+        class Binary < self
+
+          MAPPING = {
+            Function::Numeric::Multiplication         => AQL::Node::Operator::Binary::Multiplication,
+            Function::Numeric::Addition               => AQL::Node::Operator::Binary::Addition,
+            Function::Numeric::Division               => AQL::Node::Operator::Binary::Division,
+            Function::Numeric::Modulo                 => AQL::Node::Operator::Binary::Modulo,
+            Function::Numeric::Subtraction            => AQL::Node::Operator::Binary::Subtraction,
+            Function::Predicate::GreaterThanOrEqualTo => AQL::Node::Operator::Binary::GreaterThanOrEqualTo,
+            Function::Predicate::GreaterThan          => AQL::Node::Operator::Binary::GreaterThan,
+            Function::Predicate::LessThan             => AQL::Node::Operator::Binary::LessThan,
+            Function::Predicate::LessThanOrEqualTo    => AQL::Node::Operator::Binary::LessThanOrEqualTo,
+            Function::Connective::Disjunction         => AQL::Node::Operator::Binary::Or,
+            Function::Connective::Conjunction         => AQL::Node::Operator::Binary::And,
+            Function::Predicate::Equality             => AQL::Node::Operator::Binary::Equality,
+            Function::Predicate::Inequality           => AQL::Node::Operator::Binary::Inequality
+          }.freeze
+
+          MAPPING.each_key do |klass|
+            handle(klass)
+          end
+
+          # Return local name
+          #
+          # @return [Node::Name]
+          #
+          # @api private
+          #
+          def local_name
+            context.local_name
+          end
+          memoize :local_name
+
+          # Return root AQL node
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def root
+            klass = MAPPING.fetch(input.class)
+            klass.new(left, right)
+          end
+          memoize :root
+
+        private
+
+          # Return left AQL node
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def left
+            visit(input.left)
+          end
+
+          # Return right AQL node
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def right
+            visit(input.right)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/axiom/adapter/arango/visitor/for.rb

@@ -0,0 +1,75 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        # Base class for visitors that emit for statements
+        class For < self
+
+          # Return root AQL AST
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def root
+            Node::Operation::For.new(local_name, source, body)
+          end
+          memoize :root
+
+          # Return local name
+          #
+          # @return [AQL::Node::Name]
+          #
+          # @api private
+          #
+          def local_name
+            self.class::LOCAL_NAME
+          end
+
+        private
+
+          # Return source
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def source
+            visit(input.operand)
+          end
+
+          # Return body
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def body
+            return_operation
+          end
+
+          # Return return operation
+          #
+          # @return [AQL::Node::Operation::Return]
+          #
+          # @api private
+          #
+          def return_operation
+            Node::Operation::Unary::Return.new(return_value)
+          end
+
+          # Return return value
+          #
+          # @return [AQL::Node::Literal::Composed::Document]
+          #
+          # @api private
+          #
+          def return_value
+            visit(input.header)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/axiom/adapter/arango/visitor/for/base.rb

@@ -0,0 +1,40 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        class For
+          # Visitor handling axiom base relations
+          class Base < self
+
+            handle(Axiom::Relation::Base)
+
+            LOCAL_NAME = AQL.name_node('base')
+
+          private
+
+            # Return source of iteration
+            #
+            # @return [AQL::Node::Name]
+            #
+            # @api private
+            #
+            def source
+              AQL.name_node(input.name)
+            end
+
+            # Return body of for statement
+            #
+            # @return [AQL::Node::Body]
+            #
+            # @api private
+            #
+            def body
+              Node::Block.new([return_operation])
+            end
+
+          end
+        end
+      end
+    end
+  end
+end