conceptql 0.1.1 → 0.2.0

data/spec/conceptql/{nodes → operators}/place_of_service_code_spec.rb

@@ -1,25 +1,23 @@
 require 'spec_helper'
-require 'conceptql/nodes/place_of_service_code'
+require 'conceptql/operators/place_of_service_code'
 
-describe ConceptQL::Nodes::PlaceOfServiceCode do
-  it 'behaves itself' do
-    ConceptQL::Nodes::PlaceOfServiceCode.new.must_behave_like(:evaluator)
-  end
+describe ConceptQL::Operators::PlaceOfServiceCode do
+  it_behaves_like(:evaluator)
 
   describe '#query' do
     it 'works for 23' do
       correct_query = "SELECT * FROM visit_occurrence AS v INNER JOIN vocabulary.concept AS vc ON (vc.concept_id = v.place_of_service_concept_id) WHERE ((vc.concept_code IN ('23')) AND (vc.vocabulary_id = 14))"
-      ConceptQL::Nodes::PlaceOfServiceCode.new('23').query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::PlaceOfServiceCode.new('23').query(Sequel.mock).sql).to eq(correct_query)
     end
 
     it 'works for 23 as number' do
       correct_query = "SELECT * FROM visit_occurrence AS v INNER JOIN vocabulary.concept AS vc ON (vc.concept_id = v.place_of_service_concept_id) WHERE ((vc.concept_code IN ('23')) AND (vc.vocabulary_id = 14))"
-      ConceptQL::Nodes::PlaceOfServiceCode.new(23).query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::PlaceOfServiceCode.new(23).query(Sequel.mock).sql).to eq(correct_query)
     end
 
     it 'works for multiple values' do
       correct_query = "SELECT * FROM visit_occurrence AS v INNER JOIN vocabulary.concept AS vc ON (vc.concept_id = v.place_of_service_concept_id) WHERE ((vc.concept_code IN ('23', '22')) AND (vc.vocabulary_id = 14))"
-      ConceptQL::Nodes::PlaceOfServiceCode.new('23', '22').query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::PlaceOfServiceCode.new('23', '22').query(Sequel.mock).sql).to eq(correct_query)
     end
   end
 end

data/spec/conceptql/operators/procedure_occurrence_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'conceptql/operators/procedure_occurrence'
+require_double('stream_for_casting')
+
+describe ConceptQL::Operators::ProcedureOccurrence do
+  it_behaves_like(:casting_operator)
+end
+
+
+

data/spec/conceptql/operators/prodcode_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'conceptql/operators/prodcode'
+
+describe ConceptQL::Operators::Prodcode do
+  it_behaves_like(:source_vocabulary_operator)
+
+  subject do
+    described_class.new
+  end
+
+  describe '#table' do
+    it 'should be drug_exposure' do
+      expect(subject.table).to eq(:drug_exposure)
+    end
+  end
+
+  describe '#concept_column' do
+    it 'should be drug_concept_id' do
+      expect(subject.concept_column).to eq(:drug_concept_id)
+    end
+  end
+
+  describe '#source_column' do
+    it 'should be drug_source_valuej' do
+      expect(subject.source_column).to eq(:drug_source_value)
+    end
+  end
+
+  describe '#vocabulary_id' do
+    it 'should be 200 (a J&J provided mapping as part of CPRD)' do
+      expect(subject.vocabulary_id).to eq(200)
+    end
+  end
+end
+

data/spec/conceptql/operators/query_double.rb

@@ -0,0 +1,20 @@
+require 'conceptql/operators/operator'
+class QueryDouble < ConceptQL::Operators::Operator
+  def initialize(*args)
+    super
+    @num = arguments.first
+    @type = arguments[1] || :visit_occurrence
+  end
+
+  def types
+    [@type]
+  end
+
+  def evaluate(db)
+    query(db)
+  end
+
+  def query(db)
+    db["table#{@num}".to_sym]
+  end
+end

data/spec/conceptql/operators/query_double_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require_relative 'query_double'
+
+describe QueryDouble do
+  it_behaves_like(:evaluator)
+end
+

data/spec/conceptql/operators/race_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'conceptql/operators/race'
+
+describe ConceptQL::Operators::Race do
+  it_behaves_like(:evaluator)
+
+  describe '#query' do
+    it 'works for white' do
+      correct_query = "SELECT * FROM person AS p INNER JOIN vocabulary.concept AS vc ON (vc.concept_id = p.race_concept_id) WHERE (lower(vc.concept_name) IN ('white'))"
+      expect(ConceptQL::Operators::Race.new('White').query(Sequel.mock).sql).to eq(correct_query)
+      expect(ConceptQL::Operators::Race.new('white').query(Sequel.mock).sql).to eq(correct_query)
+    end
+
+    it 'works for multiple values' do
+      correct_query = "SELECT * FROM person AS p INNER JOIN vocabulary.concept AS vc ON (vc.concept_id = p.race_concept_id) WHERE (lower(vc.concept_name) IN ('white', 'other'))"
+      expect(ConceptQL::Operators::Race.new('White', 'Other').query(Sequel.mock).sql).to eq(correct_query)
+      expect(ConceptQL::Operators::Race.new('white', 'other').query(Sequel.mock).sql).to eq(correct_query)
+    end
+  end
+end
+

data/spec/conceptql/operators/rxnorm_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'conceptql/operators/rxnorm'
+
+describe ConceptQL::Operators::Rxnorm do
+    it_behaves_like(:standard_vocabulary_operator)
+
+  subject do
+    described_class.new
+  end
+
+  describe '#table' do
+    it 'should be drug_exposure' do
+      expect(subject.table).to eq(:drug_exposure)
+    end
+  end
+
+  describe '#concept_column' do
+    it 'should be drug_concept_id' do
+      expect(subject.concept_column).to eq(:drug_concept_id)
+    end
+  end
+
+  describe '#vocabulary_id' do
+    it 'should be 8' do
+      expect(subject.vocabulary_id).to eq(8)
+    end
+  end
+end
+

data/spec/conceptql/operators/snomed_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'conceptql/operators/snomed'
+
+describe ConceptQL::Operators::Snomed do
+  it_behaves_like(:standard_vocabulary_operator)
+
+  subject do
+    described_class.new
+  end
+
+  describe '#table' do
+    it 'should be condition_occurrence' do
+      expect(subject.table).to eq(:condition_occurrence)
+    end
+  end
+
+  describe '#concept_column' do
+    it 'should be condition_concept_id' do
+      expect(subject.concept_column).to eq(:condition_concept_id)
+    end
+  end
+
+  describe '#vocabulary_id' do
+    it 'should be 1' do
+      expect(subject.vocabulary_id).to eq(1)
+    end
+  end
+end
+

data/spec/conceptql/operators/source_vocabulary_operator_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'conceptql/operators/source_vocabulary_operator'
+
+describe ConceptQL::Operators::SourceVocabularyOperator do
+  it_behaves_like(:evaluator)
+
+  class SourceVocabularyDouble < ConceptQL::Operators::SourceVocabularyOperator
+    def table
+      :table
+    end
+
+    def source_column
+      :source_column
+    end
+
+    def concept_column
+      :concept_column
+    end
+
+    def vocabulary_id
+      1
+    end
+  end
+
+  describe '#query' do
+    it 'works for single values' do
+      expect(SourceVocabularyDouble.new('value').query(Sequel.mock).sql).to eq("SELECT * FROM table AS tab INNER JOIN vocabulary.source_to_concept_map AS scm ON (scm.target_concept_id = tab.concept_column) WHERE ((scm.source_code IN ('value')) AND (scm.source_vocabulary_id = 1) AND (scm.source_code = tab.source_column))")
+    end
+
+    it 'works for multiple values' do
+      expect(SourceVocabularyDouble.new('value1', 'value2').query(Sequel.mock).sql).to eq("SELECT * FROM table AS tab INNER JOIN vocabulary.source_to_concept_map AS scm ON (scm.target_concept_id = tab.concept_column) WHERE ((scm.source_code IN ('value1', 'value2')) AND (scm.source_vocabulary_id = 1) AND (scm.source_code = tab.source_column))")
+    end
+  end
+end
+

data/spec/conceptql/operators/standard_vocabulary_operator_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'conceptql/operators/standard_vocabulary_operator'
+
+describe ConceptQL::Operators::StandardVocabularyOperator do
+  it_behaves_like(:evaluator)
+
+  class StandardVocabularyDouble < ConceptQL::Operators::StandardVocabularyOperator
+    def table
+      :table
+    end
+
+    def concept_column
+      :concept_column
+    end
+
+    def vocabulary_id
+      1
+    end
+  end
+
+  describe StandardVocabularyDouble do
+    it_behaves_like(:standard_vocabulary_operator)
+  end
+
+  describe '#query' do
+    it 'works for single values' do
+      expect(StandardVocabularyDouble.new('value').query(Sequel.mock).sql).to eq("SELECT * FROM table AS tab INNER JOIN vocabulary.concept AS c ON (c.concept_id = tab.concept_column) WHERE ((c.concept_code IN ('value')) AND (c.vocabulary_id = 1))")
+    end
+
+    it 'works for multiple diagnoses' do
+      expect(StandardVocabularyDouble.new('value1', 'value2').query(Sequel.mock).sql).to eq("SELECT * FROM table AS tab INNER JOIN vocabulary.concept AS c ON (c.concept_id = tab.concept_column) WHERE ((c.concept_code IN ('value1', 'value2')) AND (c.vocabulary_id = 1))")
+    end
+  end
+end
+

data/spec/conceptql/operators/started_by_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'conceptql/operators/started_by'
+require_double('stream_for_temporal')
+
+describe ConceptQL::Operators::StartedBy do
+  it_behaves_like(:temporal_operator)
+  subject do
+    described_class.new(left: StreamForTemporalDouble.new, right: StreamForTemporalDouble.new)
+  end
+
+  it 'should use proper where clause' do
+    expect(subject.query(Sequel.mock).sql).to match('l.start_date = r.start_date')
+    expect(subject.query(Sequel.mock).sql).to match('l.end_date > r.end_date')
+  end
+
+  it 'should use proper where clause when inclusive' do
+    sub = ConceptQL::Operators::StartedBy.new(left: StreamForTemporalDouble.new, right: StreamForTemporalDouble.new, inclusive: true)
+    expect(sub.query(Sequel.mock).sql).to match('l.start_date = r.start_date')
+    expect(sub.query(Sequel.mock).sql).to match('l.end_date >= r.end_date')
+  end
+end
+

data/spec/conceptql/{nodes/temporal_node_spec.rb → operators/temporal_operator_spec.rb}

@@ -1,13 +1,11 @@
 require 'spec_helper'
-require 'conceptql/nodes/temporal_node'
+require 'conceptql/operators/temporal_operator'
 require_double('stream_for_temporal')
 
-describe ConceptQL::Nodes::TemporalNode do
-  it 'behaves itself' do
-    ConceptQL::Nodes::TemporalNode.new.must_behave_like(:evaluator)
-  end
+describe ConceptQL::Operators::TemporalOperator do
+  it_behaves_like(:evaluator)
 
-  class TemporalDouble < ConceptQL::Nodes::TemporalNode
+  class TemporalDouble < ConceptQL::Operators::TemporalOperator
     def where_clause
       Proc.new do
         l__end_date < r__start_date
@@ -16,41 +14,37 @@ describe ConceptQL::Nodes::TemporalNode do
   end
 
   describe TemporalDouble do
-    it 'behaves itself' do
-      TemporalDouble.new.must_behave_like(:temporal_node)
-    end
+    it_behaves_like(:temporal_operator)
   end
 
   describe StreamForTemporalDouble do
-    it 'behaves itself' do
-      StreamForTemporalDouble.new.must_behave_like(:evaluator)
-    end
+    it_behaves_like(:evaluator)
   end
 
   describe '#inclusive?' do
     it 'defaults to false' do
-      refute(TemporalDouble.new.inclusive?)
+      expect(TemporalDouble.new.inclusive?).to be_falsy
     end
 
     it 'can be set to true' do
-      assert(TemporalDouble.new(inclusive: true).inclusive?)
+      expect(TemporalDouble.new(inclusive: true).inclusive?).to be_truthy
     end
   end
 
   describe '#query' do
     it 'uses logic from where_clause' do
       sql = TemporalDouble.new(left: StreamForTemporalDouble.new, right: StreamForTemporalDouble.new).query(Sequel.mock).sql
-      sql.must_match('l.end_date < r.start_date')
+      expect(sql).to match('l.end_date < r.start_date')
     end
 
     it 'pulls from the right tables' do
       sql = TemporalDouble.new(left: StreamForTemporalDouble.new, right: StreamForTemporalDouble.new).query(Sequel.mock).sql
-      sql.must_match('FROM table')
+      expect(sql).to match('FROM table')
     end
 
     it 'is ok with symbols' do
       sql = TemporalDouble.new(left: StreamForTemporalDouble.new, right: StreamForTemporalDouble.new).query(Sequel.mock).sql
-      sql.must_match('FROM table')
+      expect(sql).to match('FROM table')
     end
   end
 end

data/spec/conceptql/operators/time_window_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'conceptql/operators/time_window'
+require 'conceptql/operators/operator'
+
+describe ConceptQL::Operators::TimeWindow do
+  class Stream4TimeWindowDouble < ConceptQL::Operators::Operator
+    def types
+      [:visit_occurrence]
+    end
+
+    def query(db)
+      db.from(:table)
+    end
+  end
+
+  let (:sequel_mock) do
+    sequel_mock = double("sequel")
+  end
+
+  before do
+    @db_mock = Sequel.mock
+  end
+
+  describe '#evaluate' do
+    it 'adjusts start by 1 day' do
+      expect(sequel_mock).to receive(:date_add).with(Sequel.identifier("start_date"), days: 1).and_return(sequel_mock)
+      expect(@db_mock).to receive(:extension).with(:date_arithmetic)
+
+      described_class.new(Stream4TimeWindowDouble.new, { start: 'd', end: '', date_manipulator: sequel_mock }).evaluate(@db_mock)
+    end
+
+    it 'adjusts end by 1 day' do
+      expect(sequel_mock).to receive(:date_add).with(Sequel.identifier("end_date"), days: 1).and_return(sequel_mock)
+      described_class.new(Stream4TimeWindowDouble.new, { start: '', end: 'd', date_manipulator: sequel_mock }).evaluate(@db_mock)
+    end
+
+    it 'adjusts both values by 1 day' do
+      expect(sequel_mock).to receive(:date_add).with(Sequel.identifier("start_date"), days: 1).and_return(sequel_mock)
+      expect(sequel_mock).to receive(:date_add).with(Sequel.identifier("end_date"), days: 1).and_return(sequel_mock)
+      described_class.new(Stream4TimeWindowDouble.new, { start: 'd', end: 'd', date_manipulator: sequel_mock }).evaluate(@db_mock)
+    end
+
+    it 'makes multiple adjustments to both values' do
+      expect(sequel_mock).to receive(:date_add).with(Sequel.identifier("start_date"), days: 1).and_return(sequel_mock)
+      expect(sequel_mock).to receive(:date_add).with(sequel_mock, months: 1).and_return(sequel_mock)
+      expect(sequel_mock).to receive(:date_add).with(sequel_mock, years: 1).and_return(sequel_mock)
+
+      expect(sequel_mock).to receive(:date_sub).with(Sequel.identifier("end_date"), days: 1).and_return(sequel_mock)
+      expect(sequel_mock).to receive(:date_sub).with(sequel_mock, months: 1).and_return(sequel_mock)
+      expect(sequel_mock).to receive(:date_sub).with(sequel_mock, years: 1).and_return(sequel_mock)
+
+      described_class.new(Stream4TimeWindowDouble.new, { start: 'dmy', end: '-d-m-y', date_manipulator: sequel_mock }).evaluate(@db_mock)
+    end
+
+    it 'can set start_date and end_date to specific dates' do
+      described_class.new(Stream4TimeWindowDouble.new, { start: '2000-01-01', end: '2000-02-02' }).evaluate(@db_mock)
+    end
+
+    it 'can set start_date to be end_date' do
+      described_class.new(Stream4TimeWindowDouble.new, { start: 'end', end: '' }).evaluate(@db_mock)
+    end
+
+    it 'can set end_date to be start_date' do
+      described_class.new(Stream4TimeWindowDouble.new, { start: '', end: 'start' }).evaluate(@db_mock)
+    end
+
+    it 'will swap start and end dates, though this is a bad idea but you should probably know about this' do
+      described_class.new(Stream4TimeWindowDouble.new, { start: 'end', end: 'start' }).evaluate(@db_mock)
+    end
+
+    it 'handles nil arguments to both start and end' do
+      described_class.new(Stream4TimeWindowDouble.new, { start: nil, end: nil }).evaluate(@db_mock)
+    end
+  end
+end
+
+

data/spec/conceptql/operators/union_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'conceptql/operators/union'
+require_relative 'query_double'
+
+describe ConceptQL::Operators::Union do
+  it_behaves_like(:evaluator)
+
+  describe '#query' do
+    it 'works for multiple criteria' do
+      double1 = QueryDouble.new(1)
+      double2 = QueryDouble.new(2)
+      double3 = QueryDouble.new(3)
+      expect(described_class.new(double1, double2, double3).query(Sequel.mock).sql).to eq("SELECT * FROM (SELECT * FROM (SELECT * FROM (SELECT * FROM table1) AS t1 UNION ALL SELECT * FROM (SELECT * FROM table2) AS t1) AS t1 UNION ALL SELECT * FROM (SELECT * FROM table3) AS t1) AS t1")
+    end
+
+    it 'works for single criteria' do
+      double1 = QueryDouble.new(1)
+      expect(described_class.new(double1).query(Sequel.mock).sql).to eq("SELECT * FROM (SELECT * FROM table1) AS t1")
+    end
+  end
+end

data/spec/conceptql/operators/visit_occurrence_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'conceptql/operators/visit_occurrence'
+require_double('stream_for_casting')
+
+describe ConceptQL::Operators::VisitOccurrence do
+  it_behaves_like(:casting_operator)
+end
+
+
+

data/spec/conceptql/query_spec.rb

@@ -5,17 +5,18 @@ describe ConceptQL::Query do
   describe '#query' do
     it 'passes request on to tree' do
       yaml = Psych.dump({ icd9: '799.22' })
-      mock_tree = Minitest::Mock.new
-      mock_node = Minitest::Mock.new
-      mock_query = Minitest::Mock.new
+      mock_tree = double("tree")
+      mock_operator = double("operator")
+      mock_query = double("query")
+      mock_db = double("db")
 
-      query = ConceptQL::Query.new(:mock_db, yaml, mock_tree)
-      mock_tree.expect :root, mock_node, [query]
-      mock_node.expect :map, [mock_query]
-      query.query
+      expect(mock_db).to receive(:extend_datasets).with(Module).and_return(mock_db)
 
-      mock_node.verify
-      mock_tree.verify
+      query = ConceptQL::Query.new(mock_db, yaml, mock_tree)
+      expect(mock_tree).to receive(:root).with(query).and_return(mock_operator)
+      expect(mock_operator).to receive(:evaluate).with(mock_db).and_return(mock_query)
+      expect(mock_query).to receive(:tap).and_return(mock_query)
+      query.query
     end
   end
 end

data/spec/conceptql/tree_spec.rb

@@ -4,50 +4,46 @@ require 'conceptql/tree'
 describe ConceptQL::Tree do
   describe '#root' do
     before do
-      @mock_query_obj = Minitest::Mock.new
-      @mock_nodifier = Minitest::Mock.new
-      @tree = ConceptQL::Tree.new(nodifier: @mock_nodifier)
+      @mock_query_obj = double("mock  query")
+      @mock_nodifier = double("mock nodifier")
+      @mock_scope = double("mock scope")
+      @tree = ConceptQL::Tree.new(nodifier: @mock_nodifier, scope: @mock_scope)
     end
 
-    after do
-      @mock_query_obj.verify
-      @mock_nodifier.verify
-    end
-
-    it 'should walk single node criteria tree and convert to node' do
-      @mock_nodifier.expect :create, :success_indicator, [:icd9, '799.22', @tree]
-      @mock_query_obj.expect :statement, { icd9: '799.22' }
+    it 'should walk single operator criteria tree and convert to operator' do
+      expect(@mock_nodifier).to receive(:create).with(@mock_scope, :icd9, '799.22').and_return(:success_indicator)
+      expect(@mock_query_obj).to receive(:statement).and_return({ icd9: '799.22' })
 
-      @tree.root(@mock_query_obj).must_equal [:success_indicator]
+      expect(@tree.root(@mock_query_obj)).to eq(:success_indicator)
     end
 
-    it 'should extend all nodes created with behavior passed in' do
-      mock_icd9_obj = Minitest::Mock.new
-      mock_icd9_obj.expect :extend, nil, [:mock_behavior]
+    it 'should extend all operators created with behavior passed in' do
+      mock_icd9_obj = double("mock icd9")
+      expect(mock_icd9_obj).to receive(:extend).with(:mock_behavior)
 
-      tree = ConceptQL::Tree.new(nodifier: @mock_nodifier, behavior: :mock_behavior)
-      @mock_nodifier.expect :create, mock_icd9_obj, [:icd9, '799.22', tree]
-      @mock_query_obj.expect :statement, { icd9: '799.22' }
+      tree = ConceptQL::Tree.new(nodifier: @mock_nodifier, behavior: :mock_behavior, scope: @mock_scope)
+      expect(@mock_nodifier).to receive(:create).with(@mock_scope, :icd9, '799.22').and_return(mock_icd9_obj)
+      expect(@mock_query_obj).to receive(:statement).and_return({ icd9: '799.22' })
 
       tree.root(@mock_query_obj)
     end
 
-    it 'should walk multi-criteria node' do
-      @mock_nodifier.expect :create, :mock_icd9, [:icd9, '799.22', @tree]
-      @mock_nodifier.expect :create, :success_indicator, [:nth, { occurrence: 1, expression: :mock_icd9 }, @tree]
+    it 'should walk multi-criteria operator' do
+      expect(@mock_nodifier).to receive(:create).with(@mock_scope, :icd9, '799.22').and_return(:mock_icd9)
+      expect(@mock_nodifier).to receive(:create).with(@mock_scope, :nth, { occurrence: 1, expression: :mock_icd9 }).and_return(:success_indicator)
 
-      @mock_query_obj.expect :statement, { nth: { occurrence: 1, expression: { icd9: '799.22' } } }
+      expect(@mock_query_obj).to receive(:statement).and_return({ nth: { occurrence: 1, expression: { icd9: '799.22' } } })
 
-      @tree.root(@mock_query_obj).must_equal [:success_indicator]
+      expect(@tree.root(@mock_query_obj)).to eq(:success_indicator)
     end
 
-    it 'should walk multi-node criteria tree and convert to nodes' do
-      @mock_nodifier.expect :create, :mock_icd9, [:icd9, '799.22', @tree]
-      @mock_nodifier.expect :create, :success_indicator, [:any, [:mock_icd9], @tree]
+    it 'should walk multi-operator criteria tree and convert to operators' do
+      expect(@mock_nodifier).to receive(:create).with(@mock_scope, :icd9, '799.22').and_return(:mock_icd9)
+      expect(@mock_nodifier).to receive(:create).with(@mock_scope, :any, :mock_icd9).and_return(:success_indicator)
 
-      @mock_query_obj.expect :statement, { any: [{ icd9: '799.22' }] }
+      expect(@mock_query_obj).to receive(:statement).and_return({ any: [{ icd9: '799.22' }] })
 
-      @tree.root(@mock_query_obj).must_equal [:success_indicator]
+      expect(@tree.root(@mock_query_obj)).to eq(:success_indicator)
     end
   end
 end

data/spec/doubles/stream_for_casting_double.rb

@@ -1,4 +1,4 @@
-class StreamForCastingDouble < ConceptQL::Nodes::Node
+class StreamForCastingDouble < ConceptQL::Operators::Operator
   def query(db)
     db.from(:table)
   end

data/spec/doubles/stream_for_occurrence_double.rb

@@ -1,4 +1,4 @@
-class StreamForOccurrenceDouble < ConceptQL::Nodes::Node
+class StreamForOccurrenceDouble < ConceptQL::Operators::Operator
   def query(db)
     ds = db.from(:table)
     # Occurrence needs window functions to work

data/spec/doubles/stream_for_temporal_double.rb

@@ -1,4 +1,4 @@
-class StreamForTemporalDouble < ConceptQL::Nodes::Node
+class StreamForTemporalDouble < ConceptQL::Operators::Operator
   def query(db)
     db.from(:table)
   end