rdf-n3 3.0.1 → 3.2.0

data/lib/rdf/n3/algebra/list/length.rb

@@ -0,0 +1,24 @@
+module RDF::N3::Algebra::List
+  ##
+  # Iff the subject is a list and the object is the last thing that list, then this is true. The object can be calculated as a function of the list.
+  #
+  # @example
+  #     { ( 1 2 3 4 5 6 ) list:length 6 } => { :test1 a :SUCCESS }.
+  #
+  # The object can be calculated as a function of the list.
+  class Length < RDF::N3::Algebra::ListOperator
+    NAME = :listLength
+    URI = RDF::N3::List.length
+
+    ##
+    # Resolves this operator using the given variable `bindings`.
+    # If the last operand is a variable, it creates a solution for each element in the list.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      RDF::Literal(list.length)
+    end
+  end
+end

data/lib/rdf/n3/algebra/list/member.rb

@@ -0,0 +1,44 @@
+module RDF::N3::Algebra::List
+  ##
+  # Iff the subject is a list and the object is in that list, then this is true.
+  class Member < RDF::N3::Algebra::ListOperator
+    NAME = :listMember
+    URI = RDF::N3::List.member
+
+    ##
+    # Evaluates this operator using the given variable `bindings`.
+    # If the last operand is a variable, it creates a solution for each element in the list.
+    #
+    # @param  [RDF::Queryable] queryable
+    #   the graph or repository to query
+    # @param [RDF::Query::Solutions] solutions
+    #   solutions for chained queries
+    # @return [RDF::Query::Solutions]
+    def execute(queryable, solutions:, **options)
+      RDF::Query::Solutions(solutions.map do |solution|
+        list = operand(0).evaluate(solution.bindings, formulae: formulae)
+        next unless list
+        list = RDF::N3::List.try_list(list, queryable).evaluate(solution.bindings, formulae: formulae)
+        object = operand(1).evaluate(solution.bindings, formulae: formulae) || operand(1)
+        object = formulae[object].deep_dup if object.node? && formulae.has_key?(object)
+
+        log_debug(NAME) {"list: #{list.to_sxp}, object: #{object.to_sxp}"}
+        unless list.list? && list.valid?
+          log_error(NAME) {"operand is not a list: #{list.to_sxp}"}
+          next
+        end
+
+        if object.variable?
+          # Bind all list entries to this solution, creates an array of solutions
+          list.to_a.map do |term|
+            solution.merge(object.to_sym => term)
+          end
+        elsif list.to_a.include?(object)
+          solution
+        else
+          nil
+        end
+      end.flatten.compact.uniq)
+    end
+  end
+end

data/lib/rdf/n3/algebra/list_operator.rb

@@ -0,0 +1,96 @@
+module RDF::N3::Algebra
+  ##
+  # This is a generic operator where the subject is a list or binds to a list and the object is either a constant that equals the evaluation of the subject, or a variable to which the result is bound in a solution
+  class ListOperator < SPARQL::Algebra::Operator::Binary
+    include SPARQL::Algebra::Query
+    include SPARQL::Algebra::Update
+    include RDF::N3::Algebra::Builtin
+
+    NAME = :listOperator
+
+    ##
+    # The operator takes a list and provides a mechanism for subclasses to operate over (and validate) that list argument.
+    #
+    # @param  [RDF::Queryable] queryable
+    #   the graph or repository to query
+    # @param [RDF::Query::Solutions] solutions
+    #   solutions for chained queries
+    # @return [RDF::Query::Solutions]
+    def execute(queryable, solutions:, **options)
+      RDF::Query::Solutions(solutions.map do |solution|
+        # Might be a variable or node evaluating to a list in queryable, or might be a list with variables
+        subject = operand(0).evaluate(solution.bindings, formulae: formulae)
+        next unless subject
+        # If it evaluated to a BNode, re-expand as a list
+        subject = RDF::N3::List.try_list(subject, queryable).evaluate(solution.bindings, formulae: formulae)
+        object = operand(1).evaluate(solution.bindings, formulae: formulae) || operand(1)
+        object = formulae.fetch(object, object) if object.node?
+
+        log_info(self.class.const_get(:NAME), "subject") {SXP::Generator.string(subject.to_sxp_bin).strip}
+        log_info(self.class.const_get(:NAME), "object") {SXP::Generator.string(object.to_sxp_bin).strip}
+        next unless validate(subject)
+
+        lhs = resolve(subject)
+        if lhs.nil?
+          log_error(self.class.const_get(:NAME), "subject evaluates to null") {subject.inspect}
+          next
+        end
+
+        if object.variable?
+          log_debug(self.class.const_get(:NAME), "result") {SXP::Generator.string(lhs.to_sxp_bin).strip}
+          solution.merge(object.to_sym => lhs)
+        elsif object != lhs
+          log_debug(self.class.const_get(:NAME), "result: false")
+          nil
+        else
+          log_debug(self.class.const_get(:NAME), "result: true")
+          solution
+        end
+      end.compact.uniq)
+    end
+
+    ##
+    # Input is generically the subject
+    #
+    # @return [RDF::Term]
+    def input_operand
+      operand(0)
+    end
+
+    ##
+    # Subclasses implement `resolve`.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    def resolve(list)
+      raise NotImplemented
+    end
+
+    ##
+    # Subclasses may override or supplement validate to perform validation on the list subject
+    #
+    # @param [RDF::N3::List] list
+    # @return [Boolean]
+    def validate(list)
+      if list.list? && list.valid?
+        true
+      else
+        log_error(NAME) {"operand is not a list: #{list.to_sxp}"}
+        false
+      end
+    end
+
+    ##
+    # Returns a literal for the numeric argument.
+    def as_literal(object)
+      case object
+      when Float
+        literal = RDF::Literal(object, canonicalize: true)
+        literal.instance_variable_set(:@string, literal.to_s.downcase)
+        literal
+      else
+        RDF::Literal(object, canonicalize: true)
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/conclusion.rb

@@ -0,0 +1,65 @@
+module RDF::N3::Algebra::Log
+  ##
+  # All possible conclusions which can be drawn from a formula.
+  #
+  # The object of this function, a formula, is the set of conclusions which can be drawn from the subject formula, by successively applying any rules it contains to the data it contains. This is equivalent to cwm's "--think" command line function.  It does use built-ins, so it may for example indirectly invoke other documents, validate signatures, etc.
+  class Conclusion < RDF::N3::Algebra::ResourceOperator
+    NAME = :logConclusion
+    URI = RDF::N3::Log.conclusion
+
+    ##
+    # Evaluates this operator by creating a new formula containing the triples generated by reasoning over the input formula using think.
+    #
+    # The subject is evaluated into an isolated repository so that conclusions evaluated when evaluating the subject are not necessarily conclusions resulting from evaluating this operator.
+    #
+    # @param [RDF::N3::Algebra:Formula] resource
+    # @return [RDF::N3::Algebra::Formula]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(resource, position:)
+      return resource unless position == :subject
+
+      log_depth do
+        reasoner = RDF::N3::Reasoner.new(resource, **@options)
+        conclusions = RDF::N3::Repository.new
+        reasoner.execute(think: true) {|stmt| conclusions << stmt}
+
+        # The result is a formula containing the conclusions
+        form = RDF::N3::Algebra::Formula.from_enumerable(conclusions, **@options).deep_dup
+
+        log_info("#{NAME} resolved") {SXP::Generator.string form.to_sxp_bin} 
+        form
+      end
+    end
+
+    ##
+    # To be valid, subject must be a formula, and object a formula or variable.
+    #
+    # @param [RDF::Term] subject
+    # @param [RDF::Term] object
+    # @return [Boolean]
+    def valid?(subject, object)
+      subject.formula? && (object.formula? || object.is_a?(RDF::Query::Variable))
+    end
+
+    ##
+    # Return subject operand.
+    #
+    # @return [RDF::Term]
+    def input_operand
+      operands.first
+    end
+
+    ##
+    # Yields statements, and de-asserts `inferred` from the subject.
+    #
+    # @yield  [statement]
+    #   each matching statement
+    # @yieldparam  [RDF::Statement] solution
+    # @yieldreturn [void] ignored
+    def each(solutions:, &block)
+      super do |stmt|
+        block.call(RDF::Statement.from(stmt.to_quad))
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/conjunction.rb

@@ -0,0 +1,36 @@
+module RDF::N3::Algebra::Log
+  ##
+  # A function to merge formulae: logical AND.
+  #
+  # The subject is a list of formulae. The object, which can be generated, is a formula containing a copy of each of the formulae in the list on the left. A cwm built-in function.
+  class Conjunction < RDF::N3::Algebra::ListOperator
+    NAME = :logConjunction
+    URI = RDF::N3::Log.conjunction
+
+    ##
+    # Evaluates this operator by creating a new formula containing the triples from each of the formulae in the list.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::N3::Algebra::Formula]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      form = RDF::N3::Algebra::Formula.new(graph_name: RDF::Node.intern(list.hash)) 
+      log_debug(NAME, "list hash") {form.graph_name}
+
+      list.each do |f|
+        form.operands.push(*f.operands)
+      end
+      form = form.dup
+      log_info(NAME, "result") {SXP::Generator.string form.to_sxp_bin}
+      form
+    end
+
+    ##
+    # Return subject operand.
+    #
+    # @return [RDF::Term]
+    def input_operand
+      operands.first
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/content.rb

@@ -0,0 +1,34 @@
+module RDF::N3::Algebra::Log
+  ##
+  # This connects a document and a string that represents it.
+  #
+  # (Cwm knows how to go get a document in order to evaluate this.)
+  #
+  # Note that the content-type of the information is not given and so must be known or guessed.
+  class Content < RDF::N3::Algebra::ResourceOperator
+    NAME = :logContent
+    URI = RDF::N3::Log.content
+
+    ##
+    # Reads the subject into the object.
+    #
+    # Returns nil if resource does not validate, given its position
+    #
+    # @param [RDF::N3::List] resource
+    # @return [RDF::Term]
+    def resolve(resource, position: :subject)
+      case position
+      when :subject
+        return nil unless resource.literal? || resource.uri?
+        content = begin
+          as_literal(RDF::Util::File.open_file(resource) {|f| f.read})
+        rescue IOError
+          nil
+        end
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/dtlit.rb

@@ -0,0 +1,41 @@
+module RDF::N3::Algebra::Log
+  ##
+  # Takes a list of a string and an IRI and creates a datatyped literal.
+  class DtLit < RDF::N3::Algebra::ListOperator
+    NAME = :dtlit
+    URI = RDF::N3::Log.dtlit
+
+    ##
+    # Reads the subject into the object.
+    #
+    # Returns nil if resource does not validate, given its position
+    #
+    # @param [RDF::N3::List] resource
+    # @return [RDF::Term]
+    def resolve(resource, position: :subject)
+      case position
+      when :subject
+        RDF::Literal(as_literal(resource.first).to_s, datatype: resource.last)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+
+    def validate(list)
+      if super(list)
+        if list.length != 2
+          log_error(NAME) {"operand is not a list with two elements: #{list.to_sxp}"}
+          false
+        elsif !list.last.uri?
+          log_error(NAME) {"second component of subject must be an IRI: #{list.last.to_sxp}"}
+          false
+        else
+          true
+        end
+      else
+        false
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/equal_to.rb

@@ -0,0 +1,34 @@
+module RDF::N3::Algebra::Log
+  ##
+  # True if the subject and object are the same RDF node (symbol or literal).  Do not confuse with owl:sameAs. A cwm built-in logical operator, RDF graph level.
+  class EqualTo < RDF::N3::Algebra::ResourceOperator
+    NAME = :logEqualTo
+    URI = RDF::N3::Log.equalTo
+
+    ##
+    # Resolves inputs as terms.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Literal]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource if resource.term?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(left.sameTerm?(right))
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/implies.rb

@@ -0,0 +1,102 @@
+module RDF::N3::Algebra::Log
+  ##
+  # Logical implication.
+  #
+  # This is the relation between the antecedent (subject) and conclusion (object) of a rule. The application of a rule to a knowledge-base is as follows. For every substitution which, applied to the antecedent, gives a formula which is a subset of the knowledge-base, then the result of applying that same substitution to the conclusion may be added to the knowledge-base.
+  #
+  # related: See log:conclusion.
+  class Implies < SPARQL::Algebra::Operator::Binary
+    include SPARQL::Algebra::Query
+    include SPARQL::Algebra::Update
+    include RDF::N3::Algebra::Builtin
+
+    NAME = :logImplies
+    URI = RDF::N3::Log.implies
+
+    ##
+    # Returns solutions from subject. Solutions are created by evaluating subject against `queryable`.
+    #
+    # Solutions are kept within this instance, and used for conclusions. Note that the evaluated solutions do not affect that of the invoking formula, as the solution spaces are disjoint.
+    #
+    # @param  [RDF::Queryable] queryable
+    #   the graph or repository to query
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional keyword options
+    # @option options [RDF::Query::Solutions] solutions
+    #   optional initial solutions for chained queries
+    # @return [RDF::Solutions] distinct solutions
+    def execute(queryable, solutions:, **options)
+      @queryable = queryable
+      @solutions = RDF::Query::Solutions(solutions.map do |solution|
+        log_debug(NAME, "solution") {SXP::Generator.string(solution.to_sxp_bin)}
+        subject = operand(0).evaluate(solution.bindings, formulae: formulae)
+        object = operand(1).evaluate(solution.bindings, formulae: formulae)
+        log_info(NAME,  "subject") {SXP::Generator.string(subject.to_sxp_bin)}
+        log_info(NAME, "object") {SXP::Generator.string(object.to_sxp_bin)}
+
+        # Nothing to do if variables aren't resolved.
+        next unless subject && object
+
+        solns = log_depth {subject.execute(queryable, solutions: RDF::Query::Solutions(solution), **options)}
+
+        # Execute object as well (typically used for log:outputString)
+        solns.each do |soln|
+          log_depth {object.execute(queryable, solutions: RDF::Query::Solutions(soln), **options)}
+        end
+
+        # filter solutions where not all variables in antecedant are bound.
+        vars = subject.universal_vars
+        solns = RDF::Query::Solutions(solns.to_a.select do |soln|
+          vars.all? {|v| soln.bound?(v)}
+        end)
+        solns
+      end.flatten.compact.uniq)
+      log_info(NAME) {SXP::Generator.string(@solutions.to_sxp_bin)}
+
+      # Return original solutions, without bindings
+      solutions
+    end
+
+    ##
+    # Clear out any cached solutions.
+    # This principaly is for log:conclusions
+    def clear_solutions
+      super
+      @solutions = nil
+    end
+
+    ##
+    # Yields statements from the object based on solutions determined from the subject. Each solution formed by querying `queryable` from the subject is  used to create a graph, which must be a subgraph of `queryable`. If so, that solution is used to generate triples from the object formula which are yielded.
+    #
+    # @yield  [statement]
+    #   each matching statement
+    # @yieldparam  [RDF::Statement] solution
+    # @yieldreturn [void] ignored
+    def each(solutions: RDF::Query::Solutions(), &block)
+      # Merge solutions in with those for the evaluation of this implication
+      # Clear out solutions so they don't get remembered erroneously.
+      solutions, @solutions = Array(@solutions), nil
+      log_depth do
+        super(solutions: RDF::Query::Solutions(RDF::Query::Solution.new), &block)
+
+        solutions.each do |solution|
+          log_info("(logImplies each) solution") {SXP::Generator.string solution.to_sxp_bin}
+          object = operand(1).evaluate(solution.bindings, formulae: formulae)
+          log_info("(logImplies each) object") {SXP::Generator.string object.to_sxp_bin}
+
+          # Yield inferred statements
+          log_depth do
+            object.each(solutions: RDF::Query::Solutions(solution)) do |statement|
+              log_debug(("(logImplies each) infer\s")) {statement.to_sxp}
+              block.call(RDF::Statement.from(statement.to_quad, inferred: true))
+            end
+          end
+        end
+      end
+    end
+
+    # Graph name associated with this operation, using the name of the parent
+    # @return [RDF::Resource]
+    def graph_name; parent.graph_name; end
+  end
+end

data/lib/rdf/n3/algebra/log/includes.rb

@@ -0,0 +1,70 @@
+module RDF::N3::Algebra::Log
+  ##
+  # The subject formula includes the object formula.
+  #
+  # Formula A includes formula B if there exists some substitution which when applied to B creates a formula B' such that for every statement in B' is also in A, every variable universally (or existentially) quantified in B' is quantified in the same way in A. 
+  #
+  # Variable substitution is applied recursively to nested compound terms such as formulae, lists and sets.
+  #
+  # (Understood natively by cwm when in in the antecedent of a rule. You can use this to peer inside nested formulae.)
+  class Includes < RDF::N3::Algebra::ResourceOperator
+    NAME = :logIncludes
+    URI = RDF::N3::Log.includes
+
+    ##
+    # Both subject and object must be formulae.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource if resource.formula?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # Creates a repository constructed by substituting variables and in that subject with known IRIs and queries object against that repository. Either retuns a single solution, or no solutions.
+    #
+    # @note this does allow object to have variables not in the subject, if they could have been substituted away.
+    #
+    # @param  [RDF::N3::Algebra::Formula] subject
+    #   a formula
+    # @param  [RDF::N3::Algebra::Formula] object
+    #   a formula
+    # @return [RDF::Literal::Boolean]
+    def apply(subject, object)
+      subject_var_map = subject.variables.values.inject({}) {|memo, v| memo.merge(v => RDF::URI(v.name))}
+      object_vars = object.variables.keys
+      log_debug(NAME,  "subject var map") {SXP::Generator.string(subject_var_map.to_sxp_bin)}
+      log_debug(NAME, "object vars") {SXP::Generator.string(object_vars.to_sxp_bin)}
+      # create a queryable from subject, replacing variables with IRIs for thsoe variables.
+      queryable = RDF::Repository.new do |r|
+        log_depth do
+          subject.each do |stmt|
+            parts = stmt.to_quad.map do |part|
+              part.is_a?(RDF::Query::Variable) ? subject_var_map.fetch(part) : part
+            end
+            r << RDF::Statement.from(parts)
+          end
+        end
+      end
+
+      # Query object against subject
+      solns = log_depth {queryable.query(object, **@options)}
+      log_info("(#{NAME} solutions)") {SXP::Generator.string solns.to_sxp_bin}
+
+      if !solns.empty? && (object_vars - solns.variable_names).empty?
+        # Return solution
+        solns.first
+      else
+        # Return false,
+        RDF::Literal::FALSE
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/langlit.rb

@@ -0,0 +1,41 @@
+module RDF::N3::Algebra::Log
+  ##
+  # Takes a list of two strings creates a language-tagged literal.
+  class LangLit < RDF::N3::Algebra::ListOperator
+    NAME = :langlit
+    URI = RDF::N3::Log.langlit
+
+    ##
+    # Reads the subject into the object.
+    #
+    # Returns nil if resource does not validate, given its position
+    #
+    # @param [RDF::N3::List] resource
+    # @return [RDF::Term]
+    def resolve(resource, position: :subject)
+      case position
+      when :subject
+        RDF::Literal(as_literal(resource.first).to_s, language: resource.last.to_s.to_sym)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+
+    def validate(list)
+      if super(list)
+        if list.length != 2
+          log_error(NAME) {"operand is not a list with two elements: #{list.to_sxp}"}
+          false
+        elsif !list.last.to_s.match?(/^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/)
+          log_warn(NAME) {"second component of subject should be BCP47 language tag: #{list.last.to_sxp}"}
+          false
+        else
+          true
+        end
+      else
+        false
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/n3_string.rb

@@ -0,0 +1,34 @@
+module RDF::N3::Algebra::Log
+  ##
+  # The subject formula, expressed as N3, gives this string.
+  class N3String < RDF::N3::Algebra::ResourceOperator
+    NAME = :logN3String
+    URI = RDF::N3::Log.n3String
+
+    ##
+    # Serializes the subject formula into an N3 string representation.
+    #
+    # @param [RDF::N3::List] resource
+    # @return [RDF::Term]
+    def resolve(resource, position: :subject)
+      case position
+      when :subject
+        return nil unless resource.formula?
+        as_literal(RDF::N3::Writer.buffer {|w| resource.each {|st| w << st}})
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+
+    ##
+    # Subject must evaluate to a formula and object to a literal.
+    #
+    # @param [RDF::Term] subject
+    # @param [RDF::Term] object
+    # @return [Boolean]
+    def valid?(subject, object)
+      subject.formula? && (object.variable? || object.literal?)
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/not_equal_to.rb

@@ -0,0 +1,23 @@
+module RDF::N3::Algebra::Log
+  ##
+  # Equality in this sense is actually the same URI. A cwm built-in logical operator.
+  class NotEqualTo < SPARQL::Algebra::Operator::SameTerm
+    include RDF::N3::Algebra::Builtin
+    NAME = :logNotEqualTo
+    URI = RDF::N3::Log.notEqualto
+
+    ##
+    # Returns `true` if the operands are not the same RDF term; 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 unbound
+    def apply(term1, term2)
+      RDF::Literal(!term1.eql?(term2))
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/not_includes.rb

@@ -0,0 +1,27 @@
+module RDF::N3::Algebra::Log
+  ##
+  # The object formula is NOT a subset of subject. True iff log:includes is false. The converse of log:includes.
+  # (Understood natively by cwm. The subject formula may contain variables.)
+  #
+  # (In cwm, variables must of course end up getting bound before the log:include test can be done, or an infinite result set would result)
+  #
+  # Related: See includes
+  class NotIncludes < Includes
+    NAME = :logNotIncludes
+    URI = RDF::N3::Log.notIncludes
+
+    ##
+    # Uses log:includes and returns a solution if log:includes fails
+    #
+    # @param  [RDF::Queryable] queryable
+    #   the graph or repository to query
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional keyword options
+    # @option options [RDF::Query::Solutions] solutions
+    #   optional initial solutions for chained queries
+    # @return [RDF::Solutions] distinct solutions
+    def execute(queryable, solutions:, **options)
+      super.empty? ? RDF::Query::Solutions(RDF::Query::Solution.new) : RDF::Query::Solutions.new
+    end
+  end
+end