sparql 0.0.1 → 0.0.2

data/lib/sparql/algebra/operator/less_than.rb

@@ -0,0 +1,32 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL relational `<` (less than) comparison operator.
+    #
+    # @example
+    #   (< ?x ?y)
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#OperatorMapping
+    # @see http://www.w3.org/TR/xpath-functions/#func-compare
+    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-less-than
+    # @see http://www.w3.org/TR/xpath-functions/#func-boolean-less-than
+    # @see http://www.w3.org/TR/xpath-functions/#func-dateTime-less-than
+    class LessThan < Compare
+      NAME = :<
+
+      ##
+      # Returns `true` if the first operand is less than the second
+      # operand; returns `false` otherwise.
+      #
+      # @param  [RDF::Literal] left
+      #   a literal
+      # @param  [RDF::Literal] right
+      #   a literal
+      # @return [RDF::Literal::Boolean] `true` or `false`
+      # @raise  [TypeError] if either operand is not a literal
+      def apply(left, right)
+        super
+      end
+    end # LessThan
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/less_than_or_equal.rb

@@ -0,0 +1,32 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL relational `<=` (less than or equal) comparison operator.
+    #
+    # @example
+    #   (<= ?x ?y)
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#OperatorMapping
+    # @see http://www.w3.org/TR/xpath-functions/#func-compare
+    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-less-than
+    # @see http://www.w3.org/TR/xpath-functions/#func-boolean-less-than
+    # @see http://www.w3.org/TR/xpath-functions/#func-dateTime-less-than
+    class LessThanOrEqual < Compare
+      NAME = :<=
+
+      ##
+      # Returns `true` if the first operand is less than or equal to the
+      # second operand; returns `false` otherwise.
+      #
+      # @param  [RDF::Literal] left
+      #   a literal
+      # @param  [RDF::Literal] right
+      #   a literal
+      # @return [RDF::Literal::Boolean] `true` or `false`
+      # @raise  [TypeError] if either operand is not a literal
+      def apply(left, right)
+        super
+      end
+    end # LessThanOrEqual
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/minus.rb

@@ -0,0 +1,31 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL numeric unary `-` (negation) operator.
+    #
+    # @example
+    #   (- ?x)
+    #   (minus ?x)
+    #
+    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
+    class Minus < Operator::Unary
+      include Evaluatable
+
+      NAME = [:-, :minus]
+
+      ##
+      # Returns the operand with its sign reversed.
+      #
+      # @param  [RDF::Literal::Numeric] numeric
+      #   a numeric literal
+      # @return [RDF::Literal::Numeric]
+      # @raise  [TypeError] if the operand is not a numeric literal
+      def apply(term)
+        case term
+          when RDF::Literal::Numeric then -term
+          else raise TypeError, "expected an RDF::Literal::Numeric, but got #{term.inspect}"
+        end
+      end
+    end # Minus
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/multiply.rb

@@ -0,0 +1,34 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL numeric `multiply` operator.
+    #
+    # @example
+    #   (* ?x ?y)
+    #   (multiply ?x ?y)
+    #
+    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-multiply
+    class Multiply < Operator::Binary
+      include Evaluatable
+
+      NAME = [:*, :multiply]
+
+      ##
+      # Returns the arithmetic product of the operands.
+      #
+      # @param  [RDF::Literal::Numeric] left
+      #   a numeric literal
+      # @param  [RDF::Literal::Numeric] right
+      #   a numeric literal
+      # @return [RDF::Literal::Numeric]
+      # @raise  [TypeError] if either operand is not a numeric literal
+      def apply(left, right)
+        case
+          when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
+            left * right
+          else raise TypeError, "expected two RDF::Literal::Numeric operands, but got #{left.inspect} and #{right.inspect}"
+        end
+      end
+    end # Multiply
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/not.rb

@@ -0,0 +1,35 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `not` operator.
+    #
+    # @example
+    #   (! ?x ?y)
+    #   (not ?x ?y)
+    #
+    # @see http://www.w3.org/TR/xpath-functions/#func-not
+    class Not < Operator::Unary
+      include Evaluatable
+
+      NAME = [:not, :'!']
+
+      ##
+      # Returns the logical `NOT` (inverse) of the operand.
+      #
+      # Note that this operator operates on the effective boolean value
+      # (EBV) of its operand.
+      #
+      # @param  [RDF::Literal::Boolean] operand
+      #   the operand
+      # @return [RDF::Literal::Boolean] `true` or `false`
+      # @raise  [TypeError] if the operand could not be coerced to a boolean literal
+      def apply(operand)
+        case bool = boolean(operand)
+          when RDF::Literal::Boolean
+            RDF::Literal(bool.false?)
+          else super
+        end
+      end
+    end # Not
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/not_equal.rb

@@ -0,0 +1,26 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL relational `!=` (not equal) comparison operator.
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#OperatorMapping
+    # @see http://www.w3.org/TR/rdf-sparql-query/#func-RDFterm-equal
+    class NotEqual < Equal
+      NAME = :'!='
+
+      ##
+      # Returns `true` if the operands are not equal; returns `false`
+      # otherwise.
+      #
+      # @param  [RDF::Term] term1
+      #   an RDF term
+      # @param  [RDF::Term] term2
+      #   an RDF term
+      # @return [RDF::Literal::Boolean] `true` or `false`
+      # @raise  [TypeError] if either operand is not an RDF term
+      def apply(term1, term2)
+        RDF::Literal(super.false?)
+      end
+    end # NotEqual
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/or.rb

@@ -0,0 +1,65 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `or` operator.
+    #
+    # @example
+    #   (|| ?x ?y)
+    #   (or ?x ?y)
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#func-logical-or
+    # @see http://www.w3.org/TR/rdf-sparql-query/#evaluation
+    class Or < Operator::Binary
+      include Evaluatable
+
+      NAME = [:or, :'||']
+
+      ##
+      # Initializes a new operator instance.
+      #
+      # @param  [RDF::Literal::Boolean] left
+      #   the left operand
+      # @param  [RDF::Literal::Boolean] right
+      #   the right operand
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional options (see {Operator#initialize})
+      # @raise  [TypeError] if any operand is invalid
+      def initialize(left, right, options = {})
+        super
+      end
+
+      ##
+      # Returns the logical `OR` of the left operand and the right operand.
+      #
+      # Note that this operator operates on the effective boolean value
+      # (EBV) of its operands.
+      #
+      # @param  [RDF::Query::Solution, #[]] bindings
+      # @return [RDF::Literal::Boolean] `true` or `false`
+      # @raise  [TypeError] if the operands could not be coerced to a boolean literal
+      def evaluate(bindings = {})
+        begin
+          left = boolean(operand(0).evaluate(bindings)).true?
+        rescue TypeError
+          left = nil
+        end
+        
+        begin
+          right = boolean(operand(1).evaluate(bindings)).true?
+        rescue TypeError
+          right = nil
+        end
+
+        # From http://www.w3.org/TR/rdf-sparql-query/#evaluation
+        # A logical-or that encounters an error on only one branch will return TRUE if the other branch is TRUE
+        # and an error if the other branch is FALSE.
+        case
+        when left.nil? && right.nil? then raise(TypeError)
+        when left.nil?               then right ? RDF::Literal::TRUE : raise(TypeError)
+        when right.nil?              then left ? RDF::Literal::TRUE : raise(TypeError)
+        else                              RDF::Literal(left || right)
+        end
+      end
+    end # Or
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/order.rb

@@ -0,0 +1,69 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL GraphPattern `order` operator.
+    #
+    # @example
+    #   (prefix ((foaf: <http://xmlns.com/foaf/0.1/>))
+    #     (project (?name)
+    #       (order ((asc ?name))
+    #         (bgp (triple ?x foaf:name ?name)))))
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#modOrderBy
+    class Order < Operator::Binary
+      include Query
+      
+      NAME = [:order]
+
+      ##
+      # Executes this query on the given `queryable` graph or repository.
+      # Orders a solution set returned by executing operand(1) using
+      # an array of expressions and/or variables specified in operand(0)
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @return [RDF::Query::Solutions]
+      #   the resulting solution sequence
+      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      def execute(queryable, options = {})
+        debug(options) {"Order"}
+        @solutions = operands.last.execute(queryable, options.merge(:depth => options[:depth].to_i + 1)).order do |a, b|
+          operand(0).inject(false) do |memo, op|
+            debug(options) {"=> #{op.inspect}"}
+            memo ||= begin
+              comp = case op
+              when RDF::Query::Variable
+                a[op.to_sym] <=> b[op.to_sym]
+              when Operator, Array
+                a_eval, b_eval = op.evaluate(a), op.evaluate(b)
+                if a_eval.nil?
+                  RDF::Literal(-1)
+                elsif b_eval.nil?
+                  RDF::Literal(1)
+                else
+                  Operator::Compare.evaluate(a_eval, b_eval)
+                end
+              else
+                raise TypeError, "Unexpected order expression #{op.inspect}"
+              end
+              comp = -comp if op.is_a?(Operator::Desc)
+              comp == 0 ? false : comp
+            end
+          end || 0  # They compare equivalently if there are no matches
+        end
+      end
+      
+      ##
+      # Returns an optimized version of this query.
+      #
+      # Return optimized query
+      #
+      # @return [Union, RDF::Query] `self`
+      def optimize
+        operands = operands.map(&:optimize)
+      end
+    end # Order
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/plus.rb

@@ -0,0 +1,31 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL numeric unary `+` operator.
+    #
+    # @example
+    #   (+ ?x ?y)
+    #   (plus ?x ?y)
+    #
+    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-unary-plus
+    class Plus < Operator::Unary
+      include Evaluatable
+
+      NAME = [:+, :plus]
+
+      ##
+      # Returns the operand with its sign unchanged.
+      #
+      # @param  [RDF::Literal::Numeric] numeric
+      #   a numeric literal
+      # @return [RDF::Literal::Numeric]
+      # @raise  [TypeError] if the operand is not a numeric literal
+      def apply(term)
+        case term
+          when RDF::Literal::Numeric then term
+          else raise TypeError, "expected an RDF::Literal::Numeric, but got #{term.inspect}"
+        end
+      end
+    end # Plus
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/prefix.rb

@@ -0,0 +1,45 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL GraphPattern `prefix` operator.
+    #
+    # @example
+    #   (prefix ((: <http://example/>))
+    #     (graph ?g
+    #       (bgp (triple ?s ?p ?o))))
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#QSynIRI
+    class Prefix < Binary
+      include Query
+      
+      NAME = [:prefix]
+
+      ##
+      # Executes this query on the given `queryable` graph or repository.
+      # Really a pass-through, as this is a syntactic object used for providing
+      # context for URIs.
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @return [RDF::Query::Solutions]
+      #   the resulting solution sequence
+      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      def execute(queryable, options = {})
+        @solutions = operands.last.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
+      end
+      
+      ##
+      # Returns an optimized version of this query.
+      #
+      # If optimize operands, and if the first two operands are both Queries, replace
+      # with the unique sum of the query elements
+      #
+      # @return [Union, RDF::Query] `self`
+      def optimize
+        operands.last.optimize
+      end
+    end # Prefix
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/project.rb

@@ -0,0 +1,46 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL GraphPattern `order` operator.
+    #
+    # @example
+    #   (select (?v)
+    #     (project (?v)
+    #       (filter (= ?v 2)
+    #         (bgp (triple ?s <http://example/p> ?v)))))
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#modProjection
+    class Project < Operator::Binary
+      include Query
+      
+      NAME = [:project]
+
+      ##
+      # Executes this query on the given `queryable` graph or repository.
+      # Reduces the result set to the variables listed in the first operand
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @return [RDF::Query::Solutions]
+      #   the resulting solution sequence
+      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      def execute(queryable, options = {})
+        @solutions = operands.last.
+          execute(queryable, options.merge(:depth => options[:depth].to_i + 1)).
+          project(*(operands.first))
+      end
+      
+      ##
+      # Returns an optimized version of this query.
+      #
+      # Return optimized query
+      #
+      # @return [Union, RDF::Query] `self`
+      def optimize
+        operands = operands.map(&:optimize)
+      end
+    end # Project
+  end # Operator
+end; end # SPARQL::Algebra