conceptql 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d18bbb657fb80b014eb554e98b1329f98ecb64f
-  data.tar.gz: 80564c67d29d44af5c91cae68a0096eac546116b
+  metadata.gz: cd428ab59c2a551527b6a2d3382679559aeb1bdb
+  data.tar.gz: 9250fb01a96c2b4f735bac39a12e9d37e0ffa534
 SHA512:
-  metadata.gz: 2bfa1b9efeae75d2d96c3565cc9ffe38398667e5d15afbf8c9c4d5d835c48da685eb74561262db103f86d8f880e4957ac3bd53ffc26816c5ceec73b065a09457
-  data.tar.gz: 11a3813fdd1450c70b4f6aa866dffba16f2e22376ec6a625a77ef6840aeb777dbc8099ab3f40b78feae2080706ebdf40b0609d2cea017f89af5e67faee1823e0
+  metadata.gz: cf43748c517516ed53ecedeef4a6e93d72576f0cc458460a67352fa8eb19c6e6cae3c22adde516be357b997d44751bee281e3538f86449acd25708fb0b3fac7d
+  data.tar.gz: 56cbc0f0697a0c3d98ed541cf286c36114a6dfa07c09c5fe13c2fc8bce3b55d645a5dc2aaebdc6d88dba3df5d24db33b0453b5709e920a9ee64141b33b616252

data/CHANGELOG.md

@@ -1,9 +1,27 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## 0.0.7 - 2014-08-28
+
+### Added
+- Support for Oracle.
+
+### Deprecated
+- Nothing.
+
+### Removed
+- Nothing.
+
+### Fixed
+- DateAdjuster/TimeWindow use Sequel's date_arithmetic extension to produce database agnostic date manipulation.
+- Breakage from Node#tree in GraphNodifier.
+- All tests are back to passing.
+
+
 ## 0.0.6 - 2014-08-23
 
 ### Added
+- Support for Oracle
 - Tree#defined to pass type information between Define and Recall.
 - Node#sql to produce SQL for each node.
 - Graph includes row count on each edge in the diagram.
@@ -18,6 +36,8 @@ All notable changes to this project will be documented in this file.
 - Bug in CastingNode that generate SQL returning multiple columns in a subquery.
 - Made ruby-graphviz a dependency so calling programs don't bomb out.
 - Define now passes rows on through like any other node!
+- DateAdjuster/TimeWindow use Sequel's date_arithmetic extension to produce database agnostic date manipulation.
+- All tests are back to passing.
 
 
 ## 0.0.5 - 2014-08-19

data/lib/conceptql/date_adjuster.rb

@@ -16,16 +16,16 @@ module ConceptQL
     private
     def lookup
       {
-        'y' => 'year',
-        'm' => 'month',
-        'd' => 'day'
+        'y' => :years,
+        'm' => :months,
+        'd' => :days
       }
     end
 
     def parse(str)
       ConceptQL.logger.debug(str)
-      return [] if str.nil?
-      return ["#{str} days"] if str.match(/^[-+]?\d+$/)
+      return [] if str.nil? || str.empty?
+      return [[lookup['d'], str.to_i]] if str.match(/^[-+]?\d+$/)
       str.downcase.scan(/([-+]?\d*[dmy])/).map do |adjustment|
         adjustment = adjustment.first
         quantity = 1
@@ -37,8 +37,7 @@ module ConceptQL
           end
         end
         unit = lookup[adjustment.chars.last]
-        unit += 's' if quantity.abs > 1
-        [quantity, unit].join(' ')
+        [unit, quantity]
       end
     end
   end

data/lib/conceptql/graph_nodifier.rb

@@ -126,30 +126,12 @@ module ConceptQL
     end
 
     class DefineNode < DotNode
-      def initialize(*args)
-        @gn = args.pop
-        super(*args)
-      end
-
-      def types
-        @gn.types[namify(arguments.first)] = super
-      end
-
       def shape
         :cds
       end
     end
 
     class RecallNode < DotNode
-      def initialize(*args)
-        @gn = args.pop
-        super(*args)
-      end
-
-      def types
-        @gn.types[namify(arguments.first)]
-      end
-
       def shape
         :cds
       end
@@ -176,9 +158,9 @@ module ConceptQL
       if BINARY_OPERATOR_TYPES.include?(type)
         return BinaryOperatorNode.new(type, values)
       elsif type == :define
-        return DefineNode.new(type, values, self)
+        return DefineNode.new(type, values).tap { |n| n.tree = self }
       elsif type == :recall
-        return RecallNode.new(type, values, self)
+        return RecallNode.new(type, values).tap { |n| n.tree = self }
       elsif type == :vsac
         types = values.pop
         return VsacNode.new(type, values, types)

data/lib/conceptql/nodes/date_range.rb

@@ -10,9 +10,9 @@ module ConceptQL
     class DateRange < Node
       def query(db)
         db.from(:person)
-          .select_append(Sequel.cast('person', :text).as(:criterion_type))
+          .select_append(Sequel.cast_string('person').as(:criterion_type))
           .select_append(Sequel.expr(:person_id).as(:criterion_id))
-          .select_append(Sequel.expr(start_date(db)).cast(:date).as(:start_date),Sequel.expr(end_date(db)).cast(:date).as(:end_date)).from_self
+          .select_append(Sequel.lit('date ?', start_date(db)).as(:start_date), Sequel.lit('date ?', end_date(db)).as(:end_date)).from_self
       end
 
       def types
@@ -31,8 +31,8 @@ module ConceptQL
       # TODO: Select the earliest and latest dates of observation from
       # the proper CDM table to represent the start and end of data
       def date_from(db, str)
-        return db.from(:visit_occurrence_with_dates).select { min(:start_date) } if str.upcase == 'START'
-        return db.from(:visit_occurrence_with_dates).select { max(:end_date) } if str.upcase == 'END'
+        return db.from(:visit_occurrence).select { min(:start_date) } if str.upcase == 'START'
+        return db.from(:visit_occurrence).select { max(:end_date) } if str.upcase == 'END'
         return str
       end
     end

data/lib/conceptql/nodes/define.rb

@@ -15,7 +15,6 @@ module ConceptQL
     class Define < Node
       def initialize(*args)
         super
-        tree.defined[table_name] = self
       end
       # Create a temporary table and store the stream of  results in that table.
       # This "caches" the results so we only have to execute stream's query
@@ -55,6 +54,11 @@ module ConceptQL
         db[db.send(:create_table_as_sql, table_name, stream.evaluate(db).sql, temp: true)].sql
       end
 
+      def tree=(tree)
+        super
+        tree.defined[table_name] = self
+      end
+
       private
 
       def table_name

data/lib/conceptql/nodes/intersect.rb

@@ -17,7 +17,7 @@ module ConceptQL
         end
         typed_queries = exprs.map do |type, queries|
           queries.inject do |q, query|
-            q.intersect(query, all: true)
+            q.intersect(query)
           end
         end
 

data/lib/conceptql/nodes/node.rb

@@ -3,8 +3,8 @@ module ConceptQL
   module Nodes
     class Node
       attr :values, :options
-      def initialize(tree, *args)
-        @tree = tree
+      attr_accessor :tree
+      def initialize(*args)
         args.flatten!
         if args.last.is_a?(Hash)
           @options = args.pop.symbolize_keys
@@ -23,7 +23,7 @@ module ConceptQL
 
       def select_it(query, specific_type = nil)
         specific_type = type if specific_type.nil? && respond_to?(:type)
-        query.select(*columns(specific_type))
+        query.select(*columns(query, specific_type))
       end
 
       def types
@@ -42,14 +42,14 @@ module ConceptQL
         @arguments ||= values.reject { |v| v.is_a?(Node) }
       end
 
-      def columns(local_type = nil)
+      def columns(query, local_type = nil)
         criterion_type = Sequel.expr(:criterion_type)
         if local_type
-          criterion_type = Sequel.expr(local_type.to_s).cast(:text)
+          criterion_type = Sequel.cast_string(local_type.to_s)
         end
         [:person_id___person_id,
          Sequel.expr(type_id(local_type)).as(:criterion_id),
-         criterion_type.as(:criterion_type)] + date_columns(local_type)
+         criterion_type.as(:criterion_type)] + date_columns(query, local_type)
       end
 
       private
@@ -83,23 +83,23 @@ module ConceptQL
         "#{table}___tab".to_sym
       end
 
-      def date_columns(type = nil)
+      def date_columns(query, type = nil)
         return [:start_date, :end_date] unless type
-        sd = start_date_column(type)
+        sd = start_date_column(query, type)
         sd = Sequel.expr(sd).cast(:date).as(:start_date) unless sd == :start_date
-        ed = end_date_column(type)
+        ed = end_date_column(query, type)
         ed = Sequel.expr(ed).cast(:date).as(:end_date) unless ed == :end_date
         [sd, ed]
       end
 
-      def start_date_column(type)
+      def start_date_column(query, type)
         {
           condition_occurrence: :condition_start_date,
           death: :death_date,
           drug_exposure: :drug_exposure_start_date,
           drug_cost: nil,
           payer_plan_period: :payer_plan_period_start_date,
-          person: person_date_of_birth,
+          person: person_date_of_birth(query),
           procedure_occurrence: :procedure_date,
           procedure_cost: nil,
           observation: :observation_date,
@@ -107,14 +107,14 @@ module ConceptQL
         }[type]
       end
 
-      def end_date_column(type)
+      def end_date_column(query, type)
         {
           condition_occurrence: :condition_end_date,
           death: :death_date,
           drug_exposure: :drug_exposure_end_date,
           drug_cost: nil,
           payer_plan_period: :payer_plan_period_end_date,
-          person: person_date_of_birth,
+          person: person_date_of_birth(query),
           procedure_occurrence: :procedure_date,
           procedure_cost: nil,
           observation: :observation_date,
@@ -122,16 +122,21 @@ module ConceptQL
         }[type]
       end
 
-      def person_date_of_birth
-        assemble_date(:year_of_birth, :month_of_birth, :day_of_birth)
+      def person_date_of_birth(query)
+        assemble_date(query, :year_of_birth, :month_of_birth, :day_of_birth)
       end
 
-      def assemble_date(*symbols)
+      def assemble_date(query, *symbols)
         strings = symbols.map do |symbol|
-          Sequel.function(:coalesce, Sequel.expr(symbol).cast(:text), Sequel.expr('01').cast(:text)).cast(:text)
+          Sequel.cast_string(Sequel.function(:coalesce, Sequel.cast_string(symbol), Sequel.cast_string('01')))
         end
         strings = strings.zip(['-'] * (symbols.length - 1)).flatten.compact
-        Sequel.function(:date, Sequel.join(strings))
+        concatted_strings = Sequel.join(strings)
+        unless query.db.database_type == :oracle
+          Sequel.cast(concatted_strings, Date)
+        else
+          Sequel.function(:to_date, concatted_strings, 'YYYY-MM-DD')
+        end
       end
 
       def determine_types

data/lib/conceptql/nodes/occurrence.rb

@@ -23,8 +23,10 @@ module ConceptQL
     # occurrence, this node returns nothing for that person
     class Occurrence < Node
       def query(db)
-        db.from(db.from(stream.evaluate(db))
-          .select_append { |o| o.row_number(:over, partition: :person_id, order: ordered_columns){}.as(:rn) })
+        stream.evaluate(db)
+          .from_self
+          .select_append { |o| o.row_number(:over, partition: :person_id, order: ordered_columns){}.as(:rn) }
+          .from_self
           .where(rn: occurrence.abs)
       end
 

data/lib/conceptql/nodes/temporal_node.rb

@@ -10,7 +10,7 @@ module ConceptQL
     class TemporalNode < BinaryOperatorNode
       def query(db)
         db.from(db.from(left_stream(db))
-                  .join(right_stream(db), [:person_id])
+                  .join(right_stream(db), l__person_id: :r__person_id)
                   .where(where_clause)
                   .select_all(:l))
       end

data/lib/conceptql/nodes/time_window.rb

@@ -21,11 +21,12 @@ module ConceptQL
     # start: 'd', end: '' # Only adjust start_date by positive 1 day and leave end_date uneffected
     class TimeWindow < Node
       def query(db)
+        db.extension :date_arithmetic
         db.from(stream.evaluate(db))
       end
 
       private
-      def date_columns(type = nil)
+      def date_columns(query, type = nil)
         [adjusted_start_date, adjusted_end_date]
       end
 
@@ -44,8 +45,12 @@ module ConceptQL
         arg ||= ''
         return ['end_date', column].join('___').to_sym if arg.downcase == 'end'
         return ['start_date', column].join('___').to_sym if arg.downcase == 'start'
-        DateAdjuster.new(arg).adjustments.inject(Sequel.function(:date, column)) do |sql, adjustment|
-          Sequel.function(:date, sql + Sequel.lit("interval '#{adjustment}'"))
+        DateAdjuster.new(arg).adjustments.inject(Sequel.expr(column)) do |sql, (units, quantity)|
+          if quantity > 0
+            Sequel.date_add(sql, units => quantity)
+          else
+            Sequel.date_sub(sql, units => quantity.abs)
+          end
         end.as(column)
       end
     end

data/lib/conceptql/nodifier.rb

@@ -3,7 +3,9 @@ module ConceptQL
   class Nodifier
     def create(type, values, tree)
       require_relative "nodes/#{type}"
-      "conceptQL/nodes/#{type}".camelize.constantize.new(tree, values)
+      node = "conceptQL/nodes/#{type}".camelize.constantize.new(values)
+      node.tree = tree
+      node
     end
   end
 end

data/lib/conceptql/version.rb

@@ -1,3 +1,3 @@
 module ConceptQL
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/spec/conceptql/behaviors/dottable_spec.rb

@@ -80,8 +80,8 @@ describe ConceptQL::Behaviors::Dottable do
           mock.types
         end
 
-        def link_to(mock_graph, mock_node)
-          mock.link_to(mock_graph, mock_node)
+        def link_to(mock_graph, mock_node, db)
+          mock.link_to(mock_graph, mock_node, db)
         end
       end
 
@@ -95,7 +95,7 @@ describe ConceptQL::Behaviors::Dottable do
       mock_child = MockChild.new
       mock_child.mock = Minitest::Mock.new
       mock_child.mock.expect :graph_it, :child_node, [mock_graph, :db]
-      mock_child.mock.expect :link_to, nil, [mock_graph, mock_node]
+      mock_child.mock.expect :link_to, nil, [mock_graph, mock_node, :db]
 
       mock_child.must_behave_like(:node)
 

data/spec/conceptql/date_adjuster_spec.rb

@@ -16,51 +16,51 @@ describe ConceptQL::DateAdjuster do
     end
 
     it 'returns single day for input of "1"' do
-      ConceptQL::DateAdjuster.new('1').adjustments.must_equal ['1 days']
+      ConceptQL::DateAdjuster.new('1').adjustments.must_equal [[:days, 1]]
     end
 
     it 'returns 20 days for input of "20"' do
-      ConceptQL::DateAdjuster.new('20').adjustments.must_equal ['20 days']
+      ConceptQL::DateAdjuster.new('20').adjustments.must_equal [[:days, 20]]
     end
 
     it 'returns single day for input of "d"' do
-      ConceptQL::DateAdjuster.new('d').adjustments.must_equal ['1 day']
+      ConceptQL::DateAdjuster.new('d').adjustments.must_equal [[:days, 1]]
     end
 
     it 'returns single month for input of "m"' do
-      ConceptQL::DateAdjuster.new('m').adjustments.must_equal ['1 month']
+      ConceptQL::DateAdjuster.new('m').adjustments.must_equal [[:months, 1]]
     end
 
     it 'returns single year for input of "y"' do
-      ConceptQL::DateAdjuster.new('y').adjustments.must_equal ['1 year']
+      ConceptQL::DateAdjuster.new('y').adjustments.must_equal [[:years, 1]]
     end
 
     it 'returns 2 days for input of "2d"' do
-      ConceptQL::DateAdjuster.new('2d').adjustments.must_equal ['2 days']
+      ConceptQL::DateAdjuster.new('2d').adjustments.must_equal [[:days, 2]]
     end
 
     it 'returns 2 months for input of "2m"' do
-      ConceptQL::DateAdjuster.new('2m').adjustments.must_equal ['2 months']
+      ConceptQL::DateAdjuster.new('2m').adjustments.must_equal [[:months, 2]]
     end
 
     it 'returns 2 years for input of "2y"' do
-      ConceptQL::DateAdjuster.new('2y').adjustments.must_equal ['2 years']
+      ConceptQL::DateAdjuster.new('2y').adjustments.must_equal [[:years, 2]]
     end
 
     it 'returns negative single day for input of "-d"' do
-      ConceptQL::DateAdjuster.new('-d').adjustments.must_equal ['-1 day']
+      ConceptQL::DateAdjuster.new('-d').adjustments.must_equal [[:days, -1]]
     end
 
     it 'returns negative single day, positive single month for "-dm"' do
-      ConceptQL::DateAdjuster.new('-dm').adjustments.must_equal ['-1 day', '1 month']
+      ConceptQL::DateAdjuster.new('-dm').adjustments.must_equal [[:days, -1], [:months, 1]]
     end
 
     it 'returns negative 2 days for "-2d"' do
-      ConceptQL::DateAdjuster.new('-2d').adjustments.must_equal ['-2 days']
+      ConceptQL::DateAdjuster.new('-2d').adjustments.must_equal [[:days, -2]]
     end
 
     it 'returns positive 2 days for "2d"' do
-      ConceptQL::DateAdjuster.new('2d').adjustments.must_equal ['2 days']
+      ConceptQL::DateAdjuster.new('2d').adjustments.must_equal [[:days, 2]]
     end
   end
 end

data/spec/conceptql/nodes/casting_node_spec.rb

@@ -49,8 +49,8 @@ describe ConceptQL::Nodes::CastingNode do
       stream = StreamForCastingDouble.new
       stream.types = [:i_point1]
       sql = CastingDouble.new(stream).query(Sequel.mock).sql
-      sql.must_match 'my_type_id IN'
-      sql.must_match 'GROUP BY i_point1_id'
+      sql.must_match 'i_point1_id IN'
+      sql.must_match "criterion_type = 'i_point1'"
     end
 
     it 'uses and unions multiple castable types if possible' do
@@ -58,14 +58,13 @@ describe ConceptQL::Nodes::CastingNode do
       stream.types = [:i_point1, :at_me2]
       sql = CastingDouble.new(stream).query(Sequel.mock).sql
       sql.must_match 'my_type_id IN'
-      sql.must_match 'GROUP BY i_point1_id'
-      sql.must_match 'GROUP BY at_me2_id'
-      sql.must_match 'UNION'
+      sql.must_match 'i_point1_id IN'
+      sql.must_match "criterion_type = 'i_point1'"
     end
 
     it 'returns all rows of a table if passed the argument "true"' do
       sql = CastingDouble.new(true).query(Sequel.mock).sql
-      sql.must_match "SELECT * FROM my_type_with_dates AS tab"
+      sql.must_match "SELECT * FROM my_type AS tab"
     end
   end
 end

data/spec/conceptql/nodes/complement_spec.rb

@@ -10,6 +10,6 @@ describe ConceptQL::Nodes::Complement do
   it 'generates complement for single criteria' do
     double1 = QueryDouble.new(1)
     double1.must_behave_like(:evaluator)
-    ConceptQL::Nodes::Complement.new(double1).query(Sequel.mock).sql.must_equal "SELECT person_id AS person_id, CAST(NULL AS bigint) AS condition_occurrence_id, CAST(NULL AS bigint) AS death_id, CAST(NULL AS bigint) AS drug_cost_id, CAST(NULL AS bigint) AS drug_exposure_id, CAST(NULL AS bigint) AS observation_id, CAST(NULL AS bigint) AS payer_plan_period_id, CAST(NULL AS bigint) AS procedure_cost_id, CAST(NULL AS bigint) AS procedure_occurrence_id, visit_occurrence_id AS visit_occurrence_id, start_date, end_date FROM visit_occurrence_with_dates AS tab WHERE (visit_occurrence_id NOT IN (SELECT * FROM (SELECT visit_occurrence_id FROM table1) AS t1 WHERE (visit_occurrence_id IS NOT NULL)))"
+    ConceptQL::Nodes::Complement.new(double1).query(Sequel.mock).sql.must_equal "SELECT * FROM (SELECT person_id AS person_id, visit_occurrence_id AS criterion_id, CAST('visit_occurrence' AS varchar(255)) AS criterion_type, CAST(visit_start_date AS date) AS start_date, CAST(visit_end_date AS date) AS end_date FROM visit_occurrence AS tab WHERE (visit_occurrence_id NOT IN (SELECT criterion_id FROM (SELECT * FROM table1) AS t1 WHERE ((criterion_id IS NOT NULL) AND (criterion_type = 'visit_occurrence'))))) AS t1"
   end
 end

data/spec/conceptql/nodes/condition_type_spec.rb

@@ -8,102 +8,102 @@ describe ConceptQL::Nodes::ConditionType do
 
   describe '#query' do
     it 'works for inpatient_detail_primary' do
-      correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000183))"
+      correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000183))"
       ConceptQL::Nodes::ConditionType.new(:inpatient_detail_primary).query(Sequel.mock).sql.must_equal correct_query
     end
 
     it 'works for inpatient_detail_1' do
-      correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000184))"
+      correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000184))"
       ConceptQL::Nodes::ConditionType.new(:inpatient_detail_1).query(Sequel.mock).sql.must_equal correct_query
     end
 
     it 'works for inpatient_detail_2' do
-      correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000185))"
+      correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000185))"
       ConceptQL::Nodes::ConditionType.new(:inpatient_detail_2).query(Sequel.mock).sql.must_equal correct_query
     end
 
     it 'works for inpatient_header_primary' do
-      correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000199))"
+      correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000199))"
       ConceptQL::Nodes::ConditionType.new(:inpatient_header_primary).query(Sequel.mock).sql.must_equal correct_query
     end
 
     it 'works for inpatient_header_1' do
-      correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000200))"
+      correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000200))"
       ConceptQL::Nodes::ConditionType.new(:inpatient_header_1).query(Sequel.mock).sql.must_equal correct_query
     end
 
     it 'works for outpatient_detail_1' do
-      correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000215))"
+      correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000215))"
       ConceptQL::Nodes::ConditionType.new(:outpatient_detail_1).query(Sequel.mock).sql.must_equal correct_query
     end
 
     it 'works for outpatient_header_1' do
-      correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000230))"
+      correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000230))"
       ConceptQL::Nodes::ConditionType.new(:outpatient_header_1).query(Sequel.mock).sql.must_equal correct_query
     end
 
     it 'works for ehr_problem_list' do
-      correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000245))"
+      correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000245))"
       ConceptQL::Nodes::ConditionType.new(:ehr_problem_list).query(Sequel.mock).sql.must_equal correct_query
     end
 
     it 'works for condition_era_0_day_window' do
-      correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000246))"
+      correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000246))"
       ConceptQL::Nodes::ConditionType.new(:condition_era_0_day_window).query(Sequel.mock).sql.must_equal correct_query
     end
 
     it 'works for condition_era_30_day_window' do
-      correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000247))"
+      correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000247))"
       ConceptQL::Nodes::ConditionType.new(:condition_era_30_day_window).query(Sequel.mock).sql.must_equal correct_query
     end
 
     describe 'with multiple arguments' do
       it 'works for inpatient_detail_1' do
-        correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000184, 38000185))"
+        correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000184, 38000185))"
         ConceptQL::Nodes::ConditionType.new(:inpatient_detail_1, :inpatient_detail_2).query(Sequel.mock).sql.must_equal correct_query
       end
     end
 
     describe 'with arguments as strings' do
       it 'works for inpatient_detail_1' do
-        correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000184, 38000185))"
+        correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000184, 38000185))"
         ConceptQL::Nodes::ConditionType.new('inpatient_detail_1', 'inpatient_detail_2').query(Sequel.mock).sql.must_equal correct_query
       end
     end
 
     describe 'as category' do
       it 'works for inpatient_detail' do
-        correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000183, 38000184, 38000185, 38000186, 38000187, 38000188, 38000189, 38000190, 38000191, 38000192, 38000193, 38000194, 38000195, 38000196, 38000197, 38000198))"
+        correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000183, 38000184, 38000185, 38000186, 38000187, 38000188, 38000189, 38000190, 38000191, 38000192, 38000193, 38000194, 38000195, 38000196, 38000197, 38000198))"
         ConceptQL::Nodes::ConditionType.new('inpatient_detail').query(Sequel.mock).sql.must_equal correct_query
       end
 
       it 'works for inpatient_header' do
-        correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000199, 38000200, 38000201, 38000202, 38000203, 38000204, 38000205, 38000206, 38000207, 38000208, 38000209, 38000210, 38000211, 38000212, 38000213, 38000214))"
+        correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000199, 38000200, 38000201, 38000202, 38000203, 38000204, 38000205, 38000206, 38000207, 38000208, 38000209, 38000210, 38000211, 38000212, 38000213, 38000214))"
         ConceptQL::Nodes::ConditionType.new('inpatient_header').query(Sequel.mock).sql.must_equal correct_query
       end
 
       it 'works for inpatient' do
-        correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000183, 38000184, 38000185, 38000186, 38000187, 38000188, 38000189, 38000190, 38000191, 38000192, 38000193, 38000194, 38000195, 38000196, 38000197, 38000198, 38000199, 38000200, 38000201, 38000202, 38000203, 38000204, 38000205, 38000206, 38000207, 38000208, 38000209, 38000210, 38000211, 38000212, 38000213, 38000214))"
+        correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000183, 38000184, 38000185, 38000186, 38000187, 38000188, 38000189, 38000190, 38000191, 38000192, 38000193, 38000194, 38000195, 38000196, 38000197, 38000198, 38000199, 38000200, 38000201, 38000202, 38000203, 38000204, 38000205, 38000206, 38000207, 38000208, 38000209, 38000210, 38000211, 38000212, 38000213, 38000214))"
         ConceptQL::Nodes::ConditionType.new('inpatient').query(Sequel.mock).sql.must_equal correct_query
       end
 
       it 'works for outpatient_detail' do
-        correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000215, 38000216, 38000217, 38000218, 38000219, 38000220, 38000221, 38000222, 38000223, 38000224, 38000225, 38000226, 38000227, 38000228, 38000229))"
+        correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000215, 38000216, 38000217, 38000218, 38000219, 38000220, 38000221, 38000222, 38000223, 38000224, 38000225, 38000226, 38000227, 38000228, 38000229))"
         ConceptQL::Nodes::ConditionType.new('outpatient_detail').query(Sequel.mock).sql.must_equal correct_query
       end
 
       it 'works for outpatient_header' do
-        correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000230, 38000231, 38000232, 38000233, 38000234, 38000235, 38000236, 38000237, 38000238, 38000239, 38000240, 38000241, 38000242, 38000243, 38000244))"
+        correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000230, 38000231, 38000232, 38000233, 38000234, 38000235, 38000236, 38000237, 38000238, 38000239, 38000240, 38000241, 38000242, 38000243, 38000244))"
         ConceptQL::Nodes::ConditionType.new('outpatient_header').query(Sequel.mock).sql.must_equal correct_query
       end
 
       it 'works for outpatient' do
-        correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000215, 38000216, 38000217, 38000218, 38000219, 38000220, 38000221, 38000222, 38000223, 38000224, 38000225, 38000226, 38000227, 38000228, 38000229, 38000230, 38000231, 38000232, 38000233, 38000234, 38000235, 38000236, 38000237, 38000238, 38000239, 38000240, 38000241, 38000242, 38000243, 38000244))"
+        correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000215, 38000216, 38000217, 38000218, 38000219, 38000220, 38000221, 38000222, 38000223, 38000224, 38000225, 38000226, 38000227, 38000228, 38000229, 38000230, 38000231, 38000232, 38000233, 38000234, 38000235, 38000236, 38000237, 38000238, 38000239, 38000240, 38000241, 38000242, 38000243, 38000244))"
         ConceptQL::Nodes::ConditionType.new('outpatient').query(Sequel.mock).sql.must_equal correct_query
       end
 
       it 'works for condition_era' do
-        correct_query = "SELECT * FROM condition_occurrence_with_dates WHERE (condition_type_concept_id IN (38000246, 38000247))"
+        correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000246, 38000247))"
         ConceptQL::Nodes::ConditionType.new('condition_era').query(Sequel.mock).sql.must_equal correct_query
       end
     end

data/spec/conceptql/nodes/date_range_spec.rb

@@ -14,19 +14,19 @@ describe ConceptQL::Nodes::DateRange do
 
   describe '#query' do
     it 'should be dates specified assigned to all persons' do
-      ConceptQL::Nodes::DateRange.new(start: '2004-12-13', end: '2010-03-20').query(Sequel.mock).sql.must_equal("SELECT * FROM (SELECT *, CAST('2004-12-13' AS date) AS start_date, CAST('2010-03-20' AS date) AS end_date FROM person) AS t1")
+      ConceptQL::Nodes::DateRange.new(start: '2004-12-13', end: '2010-03-20').query(Sequel.mock).sql.must_equal("SELECT * FROM (SELECT *, CAST('person' AS varchar(255)) AS criterion_type, person_id AS criterion_id, date '2004-12-13' AS start_date, date '2010-03-20' AS end_date FROM person) AS t1")
     end
 
     it 'should handle strings for option keys' do
-      ConceptQL::Nodes::DateRange.new('start' => '2004-12-13', 'end' => '2010-03-20').query(Sequel.mock).sql.must_equal("SELECT * FROM (SELECT *, CAST('2004-12-13' AS date) AS start_date, CAST('2010-03-20' AS date) AS end_date FROM person) AS t1")
+      ConceptQL::Nodes::DateRange.new('start' => '2004-12-13', 'end' => '2010-03-20').query(Sequel.mock).sql.must_equal("SELECT * FROM (SELECT *, CAST('person' AS varchar(255)) AS criterion_type, person_id AS criterion_id, date '2004-12-13' AS start_date, date '2010-03-20' AS end_date FROM person) AS t1")
     end
 
     it 'handles START as day before first recorded visit_occurrence' do
-      ConceptQL::Nodes::DateRange.new(start: 'START', end: '2010-03-20').query(Sequel.mock).sql.must_equal("SELECT * FROM (SELECT *, CAST((SELECT min(start_date) FROM visit_occurrence_with_dates) AS date) AS start_date, CAST('2010-03-20' AS date) AS end_date FROM person) AS t1")
+      ConceptQL::Nodes::DateRange.new(start: 'START', end: '2010-03-20').query(Sequel.mock).sql.must_equal("SELECT * FROM (SELECT *, CAST('person' AS varchar(255)) AS criterion_type, person_id AS criterion_id, date (SELECT min(start_date) FROM visit_occurrence) AS start_date, date '2010-03-20' AS end_date FROM person) AS t1")
     end
 
     it 'handles END as 2010-12-31' do
-      ConceptQL::Nodes::DateRange.new(start: '2004-12-13', end: 'END').query(Sequel.mock).sql.must_equal("SELECT * FROM (SELECT *, CAST('2004-12-13' AS date) AS start_date, CAST((SELECT max(end_date) FROM visit_occurrence_with_dates) AS date) AS end_date FROM person) AS t1")
+      ConceptQL::Nodes::DateRange.new(start: '2004-12-13', end: 'END').query(Sequel.mock).sql.must_equal("SELECT * FROM (SELECT *, CAST('person' AS varchar(255)) AS criterion_type, person_id AS criterion_id, date '2004-12-13' AS start_date, date (SELECT max(end_date) FROM visit_occurrence) AS end_date FROM person) AS t1")
     end
   end
 

data/spec/conceptql/nodes/gender_spec.rb

@@ -8,7 +8,7 @@ describe ConceptQL::Nodes::Gender do
 
   describe '#query' do
     it 'works for male/MALE/Male/M/m' do
-      correct_query = "SELECT * FROM person_with_dates WHERE (gender_concept_id IN (8507))"
+      correct_query = "SELECT * FROM person WHERE (gender_concept_id IN (8507))"
       ConceptQL::Nodes::Gender.new('male').query(Sequel.mock).sql.must_equal correct_query
       ConceptQL::Nodes::Gender.new('Male').query(Sequel.mock).sql.must_equal correct_query
       ConceptQL::Nodes::Gender.new('MALE').query(Sequel.mock).sql.must_equal correct_query
@@ -17,7 +17,7 @@ describe ConceptQL::Nodes::Gender do
     end
 
     it 'works for Female/FEMALE/female/F/f' do
-      correct_query = "SELECT * FROM person_with_dates WHERE (gender_concept_id IN (8532))"
+      correct_query = "SELECT * FROM person WHERE (gender_concept_id IN (8532))"
       ConceptQL::Nodes::Gender.new('female').query(Sequel.mock).sql.must_equal correct_query
       ConceptQL::Nodes::Gender.new('Female').query(Sequel.mock).sql.must_equal correct_query
       ConceptQL::Nodes::Gender.new('FEMALE').query(Sequel.mock).sql.must_equal correct_query

data/spec/conceptql/nodes/intersect_spec.rb

@@ -13,7 +13,7 @@ describe ConceptQL::Nodes::Intersect do
       double2 = QueryDouble.new(2)
       double3 = QueryDouble.new(3)
       double1.must_behave_like(:evaluator)
-      ConceptQL::Nodes::Intersect.new(double1, double2, double3).query(Sequel.mock).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table1 INTERSECT ALL SELECT * FROM table2) AS t1 INTERSECT ALL SELECT * FROM table3) AS t1"
+      ConceptQL::Nodes::Intersect.new(double1, double2, double3).query(Sequel.mock).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table1 INTERSECT SELECT * FROM table2) AS t1 INTERSECT SELECT * FROM table3) AS t1"
     end
 
     it 'works for multiple criteria of different type' do
@@ -21,7 +21,7 @@ describe ConceptQL::Nodes::Intersect do
       double2 = QueryDouble.new(2, :person)
       double3 = QueryDouble.new(3)
       double1.must_behave_like(:evaluator)
-      ConceptQL::Nodes::Intersect.new(double1, double2, double3).query(Sequel.mock).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table1 INTERSECT ALL SELECT * FROM table3) AS t1 UNION ALL SELECT * FROM table2) AS t1"
+      ConceptQL::Nodes::Intersect.new(double1, double2, double3).query(Sequel.mock).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table1 INTERSECT SELECT * FROM table3) AS t1 UNION ALL SELECT * FROM table2) AS t1"
     end
 
     it 'works for single criteria' do

data/spec/conceptql/nodes/occurrence_spec.rb

@@ -81,7 +81,7 @@ describe ConceptQL::Nodes::Occurrence do
     end
 
     it 'should order by ascending start_date' do
-      subject.must_match ', condition_occurrence_id ASC'
+      subject.must_match ', criterion_type, criterion_id'
     end
   end
 end

data/spec/conceptql/nodes/place_of_service_code_spec.rb

@@ -8,17 +8,17 @@ describe ConceptQL::Nodes::PlaceOfServiceCode do
 
   describe '#query' do
     it 'works for 23' do
-      correct_query = "SELECT * FROM visit_occurrence_with_dates AS v INNER JOIN vocabulary.concept AS vc ON (vc.concept_id = v.place_of_service_concept_id) WHERE (vc.concept_code IN ('23'))"
+      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
     end
 
     it 'works for 23 as number' do
-      correct_query = "SELECT * FROM visit_occurrence_with_dates AS v INNER JOIN vocabulary.concept AS vc ON (vc.concept_id = v.place_of_service_concept_id) WHERE (vc.concept_code IN ('23'))"
+      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
     end
 
     it 'works for multiple values' do
-      correct_query = "SELECT * FROM visit_occurrence_with_dates 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'))"
+      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
     end
   end

data/spec/conceptql/nodes/race_spec.rb

@@ -8,13 +8,13 @@ describe ConceptQL::Nodes::Race do
 
   describe '#query' do
     it 'works for white' do
-      correct_query = "SELECT * FROM person_with_dates AS p INNER JOIN vocabulary.concept AS vc ON (vc.concept_id = p.race_concept_id) WHERE (lower(vc.concept_name) IN ('white'))"
+      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'))"
       ConceptQL::Nodes::Race.new('White').query(Sequel.mock).sql.must_equal correct_query
       ConceptQL::Nodes::Race.new('white').query(Sequel.mock).sql.must_equal correct_query
     end
 
     it 'works for multiple values' do
-      correct_query = "SELECT * FROM person_with_dates AS p INNER JOIN vocabulary.concept AS vc ON (vc.concept_id = p.race_concept_id) WHERE (lower(vc.concept_name) IN ('white', 'other'))"
+      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'))"
       ConceptQL::Nodes::Race.new('White', 'Other').query(Sequel.mock).sql.must_equal correct_query
       ConceptQL::Nodes::Race.new('white', 'other').query(Sequel.mock).sql.must_equal correct_query
     end

data/spec/conceptql/nodes/source_vocabulary_node_spec.rb

@@ -26,11 +26,11 @@ describe ConceptQL::Nodes::SourceVocabularyNode do
 
   describe '#query' do
     it 'works for single values' do
-      SourceVocabularyDouble.new('value').query(Sequel.mock).sql.must_equal "SELECT * FROM table_with_dates 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))"
+      SourceVocabularyDouble.new('value').query(Sequel.mock).sql.must_equal "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
-      SourceVocabularyDouble.new('value1', 'value2').query(Sequel.mock).sql.must_equal "SELECT * FROM table_with_dates 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))"
+      SourceVocabularyDouble.new('value1', 'value2').query(Sequel.mock).sql.must_equal "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/nodes/standard_vocabulary_node_spec.rb

@@ -28,11 +28,11 @@ describe ConceptQL::Nodes::StandardVocabularyNode do
 
   describe '#query' do
     it 'works for single values' do
-      StandardVocabularyDouble.new('value').query(Sequel.mock).sql.must_equal "SELECT * FROM table_with_dates 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))"
+      StandardVocabularyDouble.new('value').query(Sequel.mock).sql.must_equal "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
-      StandardVocabularyDouble.new('value1', 'value2').query(Sequel.mock).sql.must_equal "SELECT * FROM table_with_dates 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))"
+      StandardVocabularyDouble.new('value1', 'value2').query(Sequel.mock).sql.must_equal "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/nodes/time_window_spec.rb

@@ -13,52 +13,71 @@ describe ConceptQL::Nodes::TimeWindow do
     end
   end
 
+  before do
+    @db_mock = Sequel.mock
+    @sequel_mock = Minitest::Mock.new
+    @sequel_mock.expect :expr, @sequel_mock, [:start_date]
+    @sequel_mock.expect :expr, @sequel_mock, [:end_date]
+    @sequel_mock.expect :as, @sequel_mock, [:start_date]
+    @sequel_mock.expect :as, @sequel_mock, [:end_date]
+  end
+
   describe '#evaluate' do
     it 'adjusts start by 1 day' do
-      sql = ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: 'd', end: '' }).evaluate(Sequel.mock).sql
-      sql.must_match(%q{date((date(start_date) + interval '1 day')) AS start_date})
-      sql.must_match(%q{date(end_date) AS end_date})
+      @sequel_mock.expect :date_add, @sequel_mock, [@sequel_mock, days: 1]
+
+      stub_const(ConceptQL::Nodes::TimeWindow, :Sequel, @sequel_mock) do
+        ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: 'd', end: '' }).evaluate(@db_mock)
+      end
+      @sequel_mock.verify
     end
 
     it 'adjusts start by 1 day' do
-      sql = ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: '', end: 'd' }).evaluate(Sequel.mock).sql
-      sql.must_match(%q{date(start_date) AS start_date})
-      sql.must_match(%q{date((date(end_date) + interval '1 day')) AS end_date})
+      @sequel_mock.expect :date_add, @sequel_mock, [@sequel_mock, days: 1]
+      stub_const(ConceptQL::Nodes::TimeWindow, :Sequel, @sequel_mock) do
+        ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: '', end: 'd' }).evaluate(@db_mock)
+      end
+      @sequel_mock.verify
     end
 
     it 'adjusts both values by 1 day' do
-      sql = ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: 'd', end: 'd' }).evaluate(Sequel.mock).sql
-      sql.must_match(%q{date((date(start_date) + interval '1 day')) AS start_date, date((date(end_date) + interval '1 day')) AS end_date})
+      @sequel_mock.expect :date_add, @sequel_mock, [@sequel_mock, days: 1]
+      @sequel_mock.expect :date_add, @sequel_mock, [@sequel_mock, days: 1]
+      stub_const(ConceptQL::Nodes::TimeWindow, :Sequel, @sequel_mock) do
+        ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: 'd', end: 'd' }).evaluate(@db_mock)
+      end
+      @sequel_mock.verify
     end
 
     it 'makes multiple adjustments to both values' do
-      sql = ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: 'dmy', end: '-d-m-y' }).evaluate(Sequel.mock).sql
-      sql.must_match(%q{date((date((date((date(start_date) + interval '1 day')) + interval '1 month')) + interval '1 year'))})
-      sql.must_match(%q{date((date((date((date(end_date) + interval '-1 day')) + interval '-1 month')) + interval '-1 year'))})
+      @sequel_mock.expect :date_add, @sequel_mock, [@sequel_mock, days: 1]
+      @sequel_mock.expect :date_add, @sequel_mock, [@sequel_mock, months: 1]
+      @sequel_mock.expect :date_add, @sequel_mock, [@sequel_mock, years: 1]
+
+      @sequel_mock.expect :date_sub, @sequel_mock, [@sequel_mock, days: 1]
+      @sequel_mock.expect :date_sub, @sequel_mock, [@sequel_mock, months: 1]
+      @sequel_mock.expect :date_sub, @sequel_mock, [@sequel_mock, years: 1]
+
+      stub_const(ConceptQL::Nodes::TimeWindow, :Sequel, @sequel_mock) do
+        ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: 'dmy', end: '-d-m-y' }).evaluate(@db_mock)
+      end
+      @sequel_mock.verify
     end
 
     it 'can set start_date to be end_date' do
-      sql = ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: 'end', end: '' }).evaluate(Sequel.mock).sql
-      sql.must_match(%q{end_date AS start_date})
-      sql.must_match(%q{date(end_date) AS end_date})
+      ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: 'end', end: '' }).evaluate(@db_mock)
     end
 
     it 'can set end_date to be start_date' do
-      sql = ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: '', end: 'start' }).evaluate(Sequel.mock).sql
-      sql.must_match(%q{start_date AS end_date})
-      sql.must_match(%q{date(start_date) AS start_date})
+      ConceptQL::Nodes::TimeWindow.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
-      sql = ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: 'end', end: 'start' }).evaluate(Sequel.mock).sql
-      sql.must_match(%q{start_date AS end_date})
-      sql.must_match(%q{end_date AS start_date})
+      ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: 'end', end: 'start' }).evaluate(@db_mock)
     end
 
     it 'handles nil arguments to both start and end' do
-      sql = ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: nil, end: nil }).evaluate(Sequel.mock).sql
-      sql.must_match(%q{date(start_date) AS start_date})
-      sql.must_match(%q{date(end_date) AS end_date})
+      ConceptQL::Nodes::TimeWindow.new(Stream4TimeWindowDouble.new, { start: nil, end: nil }).evaluate(@db_mock)
     end
   end
 end

data/spec/conceptql/query_spec.rb

@@ -7,10 +7,11 @@ describe ConceptQL::Query do
       yaml = Psych.dump({ icd9: '799.22' })
       mock_tree = Minitest::Mock.new
       mock_node = Minitest::Mock.new
+      mock_query = Minitest::Mock.new
 
       query = ConceptQL::Query.new(:mock_db, yaml, mock_tree)
       mock_tree.expect :root, mock_node, [query]
-      mock_node.expect :evaluate, nil, [:mock_db]
+      mock_node.expect :map, [mock_query]
       query.query
 
       mock_node.verify

data/spec/conceptql/tree_spec.rb

@@ -15,39 +15,39 @@ describe ConceptQL::Tree do
     end
 
     it 'should walk single node criteria tree and convert to node' do
-      @mock_nodifier.expect :create, :success_indicator, [:icd9, '799.22']
+      @mock_nodifier.expect :create, :success_indicator, [:icd9, '799.22', @tree]
       @mock_query_obj.expect :statement, { icd9: '799.22' }
 
-      @tree.root(@mock_query_obj).must_equal :success_indicator
+      @tree.root(@mock_query_obj).must_equal [: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]
 
-      @mock_nodifier.expect :create, mock_icd9_obj, [:icd9, '799.22']
+      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)
       tree.root(@mock_query_obj)
     end
 
     it 'should walk multi-criteria node' do
-      @mock_nodifier.expect :create, :mock_icd9, [:icd9, '799.22']
-      @mock_nodifier.expect :create, :success_indicator, [:nth, { occurrence: 1, expression: :mock_icd9 }]
+      @mock_nodifier.expect :create, :mock_icd9, [:icd9, '799.22', @tree]
+      @mock_nodifier.expect :create, :success_indicator, [:nth, { occurrence: 1, expression: :mock_icd9 }, @tree]
 
       @mock_query_obj.expect :statement, { nth: { occurrence: 1, expression: { icd9: '799.22' } } }
 
-      @tree.root(@mock_query_obj).must_equal :success_indicator
+      @tree.root(@mock_query_obj).must_equal [:success_indicator]
     end
 
     it 'should walk multi-node criteria tree and convert to nodes' do
-      @mock_nodifier.expect :create, :mock_icd9, [:icd9, '799.22']
-      @mock_nodifier.expect :create, :success_indicator, [:any, [:mock_icd9]]
+      @mock_nodifier.expect :create, :mock_icd9, [:icd9, '799.22', @tree]
+      @mock_nodifier.expect :create, :success_indicator, [:any, [:mock_icd9], @tree]
 
       @mock_query_obj.expect :statement, { any: [{ icd9: '799.22' }] }
 
-      @tree.root(@mock_query_obj).must_equal :success_indicator
+      @tree.root(@mock_query_obj).must_equal [:success_indicator]
     end
   end
 end

data/spec/doubles/stream_for_occurrence_double.rb

@@ -6,6 +6,10 @@ class StreamForOccurrenceDouble < ConceptQL::Nodes::Node
     ds
   end
 
+  def evaluate(db)
+    query(db)
+  end
+
   # Stole this from:
   # https://github.com/jeremyevans/sequel/blob/63397b787335d06de97dc89ddf49b7a3a93ffdc9/spec/core/expression_filters_spec.rb#L400
   #

data/spec/spec_helper.rb

@@ -72,3 +72,15 @@ def require_double(double_name)
   p = p + 'spec' + 'doubles' + (double_name + '_double')
   require(p.expand_path)
 end
+
+def stub_const(klass, const, replace, &block)
+  klass.send(:const_set, const, replace)
+  if block_given?
+    yield
+    remove_stubbed_const(klass, const)
+  end
+end
+
+def remove_stubbed_const(klass, const)
+  klass.send(:remove_const, const)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: conceptql
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Ryan Duryea
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-23 00:00:00.000000000 Z
+date: 2014-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport