axiom-arango-adapter 0.0.1

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

@@ -0,0 +1,31 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        class For
+          class Unary
+            # Visitor for emitting AQL LIMIT statements from axiom limit operations
+            class Limit < self
+
+              handle(Axiom::Relation::Operation::Limit)
+              LOCAL_NAME = AQL.name_node('limit')
+
+            private
+
+              # Return limit operation
+              #
+              # @return [AQL::Node]
+              #
+              # @api private
+              #
+              def operation
+                Node::Operation::Nary::Limit.new(Node::Literal::Primitive::Number.new(input.limit), Node::Literal::Primitive::Number.new(0))
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        class For
+          class Unary
+            # Visitor for emitting currently defunct LIMIT statements from axiom offset operations
+            class Offset < self
+
+              handle(Axiom::Relation::Operation::Offset)
+
+              SIGNED_INT_32_MAX = 2 ** 31 - 1
+              LOCAL_NAME = AQL.name_node('offset')
+              MAXIMUM = Node::Literal::Primitive::Number.new(SIGNED_INT_32_MAX)
+
+            private
+
+              # Return offset operation
+              #
+              # @return [AQL::Node]
+              #
+              # @api private
+              #
+              def operation
+                Node::Operation::Nary::Limit.new(MAXIMUM, Node::Literal::Primitive::Number.new(input.offset))
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        class For
+          class Unary
+            # Visitor for emitting AQL SORT statements from axiom order operations
+            class Order < self
+
+              handle(Axiom::Relation::Operation::Order)
+
+              LOCAL_NAME = AQL.name_node('order')
+
+            private
+
+              # Return operation
+              #
+              # @return [AQL::Node]
+              #
+              # @api private
+              #
+              def operation
+                Node::Operation::Nary::Sort.new(directions)
+              end
+              memoize :operation
+
+              # Return restriction expression
+              #
+              # @return [Enumerable<AQL::Node>]
+              #
+              # @api private
+              #
+              def directions
+                input.directions.map do |direction|
+                  direction(direction)
+                end
+              end
+
+              TABLE = {
+                Axiom::Relation::Operation::Order::Ascending  => Node::Operation::Unary::Direction::Ascending,
+                Axiom::Relation::Operation::Order::Descending => Node::Operation::Unary::Direction::Descending
+              }.freeze
+
+              # Return direction AQL for axiom direction
+              #
+              # @param [Relation::Operation::Order::Direction] direction
+              #
+              # @return [AQL::Node]
+              #
+              # @api private
+              #
+              def direction(direction)
+                klass = TABLE.fetch(direction.class)
+                klass.new(visit(direction.attribute))
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        class For
+          class Unary
+            # Visitor for emitting projections
+            class Projection < self
+
+              handle(Algebra::Projection)
+
+              LOCAL_NAME = AQL.name_node('projection')
+
+            private
+
+              # Return for body
+              #
+              # @return [AQL::Node]
+              #
+              # @api private
+              #
+              def body
+                return_operation
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        class For
+          class Unary
+            # Visitor for emitting renames
+            class Rename < self
+
+              handle(Algebra::Rename)
+
+              LOCAL_NAME = AQL.name_node('rename')
+
+            private
+
+              # Return return value
+              #
+              # @return [AQL::Node::Literal::Composed::Document]
+              #
+              # @api private
+              #
+              def return_value
+                Node::Literal::Composed::Document.new(renamed_attributes)
+              end
+
+              # Return for body
+              #
+              # @return [AQL::Node]
+              #
+              # @api private
+              #
+              def body
+                return_operation
+              end
+
+              # Return renamed attributes
+              #
+              # @return [Enumerable<AQL::Node::Literal::Composed::Document::Attribute>]
+              #
+              # @api private
+              #
+              def renamed_attributes
+                input.header.map do |attribute|
+                  document_attribute(attribute)
+                end
+              end
+
+              # Return document attribute
+              #
+              # @param [Attribute] attribute
+              #
+              # @return [Node::Literal::Composed::Document::Attribute]
+              #
+              # @api private
+              #
+              def document_attribute(attribute)
+                key = Node::Literal::Primitive::String.new(attribute.name.to_s)
+                Node::Literal::Composed::Document::Attribute.new(key, document_attribute_value(attribute))
+              end
+
+              # Return inverse of aliases
+              #
+              # @return [Algebra::Rename::Aliases]
+              #
+              # @api private
+              #
+              def inverse
+                input.aliases.inverse
+              end
+              memoize :inverse
+
+              # Return document attribute value
+              #
+              # @return [AQL::Node]
+              #
+              # @api private
+              #
+              def document_attribute_value(attribute)
+                visit(inverse[attribute])
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        class For
+          class Unary
+            # Visitor for emitting AQL FILTER statements from axiom restrictions
+            class Restriction < self
+
+              handle(Axiom::Algebra::Restriction)
+
+              LOCAL_NAME = AQL.name_node('restriction')
+
+            private
+
+              # Return filter operation
+              #
+              # @return [AQL::Node]
+              #
+              # @api private
+              #
+              def operation
+                Node::Operation::Unary::Filter.new(expression)
+              end
+
+              # Return restriction expression
+              #
+              # @return [AQL::Node]
+              #
+              # @api private
+              #
+              def expression
+                visit(input.predicate)
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        # Base class for visitors with static root
+        class Static < self
+
+          # Return root node
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def root
+            self.class::ROOT
+          end
+
+          # Visitor for Axiom::Function::Proposition::Tautology
+          class Tautology < self
+            ROOT = AQL::Node::Literal::Singleton::TRUE
+            handle(Axiom::Function::Proposition::Tautology)
+          end
+
+          # Visitor for Axiom::Function::Proposition::Contradiction
+          class Contradiction < self
+            ROOT = AQL::Node::Literal::Singleton::FALSE
+            handle(Axiom::Function::Proposition::Contradiction)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        # Visitor for creating projected documents from axiom header
+        class Header < self
+
+          handle(Relation::Header)
+
+          # Return document node
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def root
+            Node::Literal::Composed::Document.new(document_attributes)
+          end
+          memoize :root
+
+          # Return document attributes
+          #
+          # @return [Enumerable<AQL::Node>]
+          #
+          # @api private
+          #
+          def document_attributes
+            input.map do |attribute|
+              document_attribute(attribute)
+            end
+          end
+          memoize :document_attributes
+
+        private
+
+          # Return document attribute node
+          #
+          # @return [Axiom::Attribute] attribute
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def document_attribute(attribute)
+            Node::Literal::Composed::Document::Attribute.new(
+              Node::Literal::Primitive::String.new(attribute.name.to_s),
+              visit(attribute, context)
+            )
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        # Visitor for literal nodes
+        class Literal < self
+
+          handle(::String)
+          handle(::Fixnum)
+
+          # Return root AQL node
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def root
+            Node::Literal.build(input)
+          end
+          memoize :root
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Axiom
+  module Adapter
+    module Arango
+      class Visitor
+        # Visitor for reverse operation
+        class Reverse < self
+
+          handle(Axiom::Relation::Operation::Reverse)
+
+          FUNCTION_NAME = 'REVERSE'.freeze
+
+          # Return root AQL AST
+          #
+          # @return [AQL::Node]
+          #
+          # @api private
+          #
+          def root
+            Node::Call::new(FUNCTION_NAME, [visit(input.operand)])
+          end
+          memoize :root
+
+        end
+      end
+    end
+  end
+end

data/spec/fuzzer.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'axiom-arango-adapter'
+require 'axiom-fuzzer'
+require 'logger'
+require 'yaml'
+
+# This will go away with the shared gateway
+Axiom::Sexp::Generator::REGISTRY[Veritas::Adapter::Arango::Gateway] = [ :unary, :gateway, :relation ]
+ 
+database = Ashikawa::Core::Database.new do |config|
+  config.url = 'http://localhost:8529'
+end
+
+collection = database['people']
+collection.delete
+collection = database['people']
+ 
+YAML.load(DATA).each do |document|
+  collection.create_document(document)
+end
+
+header   = [ [ :id, Integer ], [ :name, String, { :length => 1..50 } ] ]
+
+base     = Axiom::Relation::Base.new('people', header)
+adapter  = Axiom::Adapter::Arango::Adapter.new(database, Logger.new($stderr, :debug))
+gateway  = adapter.gateway(base)
+relation = gateway.materialize
+
+Axiom::Fuzzer.run(gateway, relation)
+
+__END__
+---
+- id: 1
+  name: Macie Deckow
+- id: 2
+  name: Desmond Gleichner
+- id: 3
+  name: Phil Krajcik
+- id: 4
+  name: Adolph McClure
+- id: 5
+  name: Trudy Torphy
+- id: 6
+  name: Vance Hegmann
+- id: 7
+  name: Lincoln Morissette
+- id: 8
+  name: Dexter Doyle
+- id: 9
+  name: Edgar Sanford
+- id: 10
+  name: Jasper Batz