Calculate pattern cost based on position of variables.

Author: gkellogg

lib/rdf/query/pattern.rb

@@ -47,6 +47,13 @@ def initialize!
       @subject    = Variable.new(@subject)    if @subject.is_a?(Symbol)
       @predicate  = Variable.new(@predicate)  if @predicate.is_a?(Symbol)
       @object     = Variable.new(@object)     if @object.is_a?(Symbol)
+
+      # Estmate cost positionally, with variables being least expensive as objects, then predicates, then subjects, then graph_names.
+      # XXX does not consider bound variables, which would need to be dynamically calculated.
+      @cost = (@object.nil?     || @object.variable?      ? 1 : 0) +
+              (@predicate.nil?  || @predicate.variable?   ? 2 : 0) +
+              (@subject.nil?    || @subject.variable?     ? 4 : 0) +
+              (@graph_name      && @graph_name.variable?  ? 8 : 0)
       super
     end
 

spec/query_pattern_spec.rb

@@ -22,6 +22,8 @@
       end
     end
 
+    its(:cost) {is_expected.to be (4+2+1)}
+
     it "should not have variables" do
       expect(subject.variables?).to be_falsey
       expect(subject.variable_count).to eq 0
@@ -52,9 +54,11 @@
     let(:s) {RDF::Query::Variable.new(:s, true)}
     subject {described_class.new(s)}
 
-    specify {expect(subject).not_to be_constant}
-    specify {expect(subject).to be_variable}
-    specify {expect(subject).to be_bound}
+    specify {is_expected.not_to be_constant}
+    specify {is_expected.to be_variable}
+    specify {is_expected.to be_bound}
+
+    its(:cost) {is_expected.to be (4+2+1)}
 
     it "should have one variable" do
       expect(subject).to be_variables
@@ -73,8 +77,8 @@
     end
 
     it "should be fully bound" do
-      expect(subject).not_to be_unbound
-      expect(subject).to be_bound
+      is_expected.not_to be_unbound
+      is_expected.to be_bound
     end
 
     it "should have one binding" do
@@ -90,9 +94,11 @@
     let(:o) {RDF::Query::Variable.new(:o, true)}
     subject {described_class.new(s, p, o)}
 
-    specify {expect(subject).not_to be_constant}
-    specify {expect(subject).to be_variable}
-    specify {expect(subject).to be_bound}
+    specify {is_expected.not_to be_constant}
+    specify {is_expected.to be_variable}
+    specify {is_expected.to be_bound}
+
+    its(:cost) {is_expected.to be (4+2+1)}
 
     it "should have three variables" do
       expect(subject).to be_variables
@@ -111,8 +117,8 @@
     end
 
     it "should be fully bound" do
-      expect(subject).not_to be_unbound
-      expect(subject).to be_bound
+      is_expected.not_to be_unbound
+      is_expected.to be_bound
     end
 
     it "should have three bindings" do
@@ -122,18 +128,45 @@
     end
   end
 
+  context "with variable in different locations" do
+    {
+      "spog": [[RDF::URI("s"), RDF::URI("p"), RDF::URI("o"), graph_name: RDF::URI("g")], 0],
+      "spo?": [[RDF::URI("s"), RDF::URI("p"), RDF::URI("o"), graph_name: :g], 8],
+      "sp?g": [[RDF::URI("s"), RDF::URI("p"), :o, graph_name: RDF::URI("g")], 1],
+      "s?og": [[RDF::URI("s"), :p, RDF::URI("o"), graph_name: RDF::URI("g")], 2],
+      "?pog": [[:s, RDF::URI("p"), RDF::URI("o"), graph_name: RDF::URI("g")], 4],
+    }.each do |name, (args, cost)|
+      it "cost for #{name} should be #{cost}" do
+        pattern = described_class.new(*args)
+        expect(pattern.cost).to be cost
+      end
+    end
+  end
+
+  context "#cost" do
+    it "can be set separately" do
+      expect(subject.cost).to be (4+2+1)
+      subject.cost = 0
+      expect(subject.cost).to be 0
+    end
+  end
+
   context "with a graph_name" do
     let(:s) {RDF::Query::Variable.new(:s, true)}
     let(:p) {RDF::Query::Variable.new(:p, true)}
     let(:o) {RDF::Query::Variable.new(:o, true)}
+    subject {described_class.new(s, p, o, graph_name: :c)}
+
     it "uses a variable for a symbol" do
-      pattern = described_class.new(s, p, o, graph_name: :c)
-      expect(pattern.graph_name).to eq RDF::Query::Variable.new(:c)
+      expect(subject.graph_name).to eq RDF::Query::Variable.new(:c)
     end
 
+    its(:cost) {is_expected.to be (8+4+2+1)}
+
     it "uses a constant for :default" do
       pattern = described_class.new(s, p, o, graph_name: false)
       expect(pattern.graph_name).to eq false
+      expect(pattern.cost).to eq (4+2+1)
     end
   end
 
@@ -143,9 +176,11 @@
     let(:o) {RDF::Query::Variable.new(:o)}
     subject {described_class.new(s, p, o)}
 
-    specify {expect(subject).not_to be_constant}
-    specify {expect(subject).to be_variable}
-    specify {expect(subject).not_to be_bound}
+    specify {is_expected.not_to be_constant}
+    specify {is_expected.to be_variable}
+    specify {is_expected.not_to be_bound}
+
+    its(:cost) {is_expected.to be (4+2+1)}
 
     describe "#bind" do
       context "complete solution" do
@@ -196,9 +231,11 @@
     let(:p) {RDF::Query::Variable.new(:p)}
     subject {described_class.new(s, p)}
 
-    specify {expect(subject).not_to be_constant}
-    specify {expect(subject).to be_variable}
-    specify {expect(subject).not_to be_bound}
+    specify {is_expected.not_to be_constant}
+    specify {is_expected.to be_variable}
+    specify {is_expected.not_to be_bound}
+
+    its(:cost) {is_expected.to be (4+2+1)}
 
     it "should have two variable" do
       expect(subject).to be_variables
@@ -218,8 +255,8 @@
     end
 
     it "should not be fully bound" do
-      expect(subject).not_to be_unbound
-      expect(subject).not_to be_bound
+      is_expected.not_to be_unbound
+      is_expected.not_to be_bound
     end
 
     it "should have one binding" do
@@ -249,7 +286,7 @@
 
     describe "#variable_terms" do
       it "has term" do
-        expect(described_class.new(RDF::Node.new, :p, 123).variable_terms).to eq([:predicate])
+        expect(described_class.new(RDF::Node.new, :p, RDF::Literal(123)).variable_terms).to eq([:predicate])
       end
     end