conceptql 0.0.1

data/lib/conceptql/nodes/standard_vocabulary_node.rb

@@ -0,0 +1,43 @@
+require_relative 'node'
+
+module ConceptQL
+  module Nodes
+    # A StandardVocabularyNode is a superclass for a node that represents a criterion whose column stores information associated with a standard vocabulary.
+    #
+    # If that seems confusing, then think of CPT or SNOMED criteria.  That type of criterion takes a set of values that live in the OMOP concept table.
+    #
+    # My coworker came up with a nice, gneralized query that checks for matching concept_ids and matching source_code values.  This class encapsulates that query.
+    #
+    # Subclasses must provide the following methods:
+    # * table
+    #   * The CDM table name where the criterion will fetch its rows
+    #   * e.g. for CPT, this would be procedure_occurrence
+    # * concept_column
+    #   * Name of the column in the table that stores a concept_id related to the criterion
+    #   * e.g. for CPT, this would be procedure_concept_id
+    # * vocabulary_id
+    #   * The vocabulary ID of the source vocabulary for the criterion
+    #   * e.g. for CPT, a value of 4 (for CPT-4)
+    class StandardVocabularyNode < Node
+      def query(db)
+        db.from(table_name)
+          .join(:vocabulary__concept___c, c__concept_id: table_concept_column)
+          .where(c__concept_code: values, c__vocabulary_id: vocabulary_id)
+      end
+
+      def types
+        [table]
+      end
+
+      private
+      def table_name
+        @table_name ||= make_table_name(table)
+      end
+
+      def table_concept_column
+        "tab__#{concept_column}".to_sym
+      end
+    end
+  end
+end
+

data/lib/conceptql/nodes/started_by.rb

@@ -0,0 +1,16 @@
+require_relative 'temporal_node'
+
+module ConceptQL
+  module Nodes
+    class StartedBy < TemporalNode
+      def where_clause
+        [ { l__start_date: :r__start_date } ] + \
+        if inclusive?
+          [ Proc.new { l__end_date >= r__end_date } ]
+        else
+          [ Proc.new { l__end_date > r__end_date } ]
+        end
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/temporal_node.rb

@@ -0,0 +1,25 @@
+require_relative 'binary_operator_node'
+
+module ConceptQL
+  module Nodes
+    # Base class for all temporal nodes
+    #
+    # Subclasses must implement the where_clause method which should probably return
+    # a proc that can be executed as a Sequel "virtual row" e.g.
+    # Proc.new { l.end_date < r.start_date }
+    class TemporalNode < BinaryOperatorNode
+      def query(db)
+        db.from(db.from(Sequel.expr(left.evaluate(db)).as(:l))
+                  .join(Sequel.expr(right.evaluate(db)).as(:r), [:person_id])
+                  .where(where_clause)
+                  .select_all(:l))
+      end
+
+      def inclusive?
+        options[:inclusive]
+      end
+    end
+  end
+end
+
+

data/lib/conceptql/nodes/time_window.rb

@@ -0,0 +1,54 @@
+require_relative 'node'
+require_relative '../date_adjuster'
+
+module ConceptQL
+  module Nodes
+    # A TimeWindow adjusts the start_date and end_date the incoming stream by the values specified in
+    # the start and end arguments.
+    #
+    # Start and end take the format of ([+-]\d*[mdy])+.  For example:
+    # 'd' => adjust date by one day.  2012-10-07 => 2012-10-08
+    # 'm' => adjust date by one month. 2012-10-07 => 2012-11-07
+    # 'y' => adjust date by one year. 2012-10-07 => 2013-10-07
+    # '1y' => adjust date by one year. 2012-10-07 => 2013-10-07
+    # '1d1y' => adjust date by one day and one year. 2012-10-07 => 2013-10-08
+    # '-1d' => adjust date by negative one day. 2012-10-07 => 2012-10-06
+    # '-1d1y' => adjust date by negative one day and positive one year. 2012-10-07 => 2013-10-06
+    # '', '0', nil => don't adjust date at all
+    #
+    # Both start and end arguments must be provided, but if you do not wish to adjust a date just
+    # pass '', '0', or nil as that argument.  E.g.:
+    # start: 'd', end: '' # Only adjust start_date by positive 1 day and leave end_date uneffected
+    class TimeWindow < Node
+      def query(db)
+        db.from(stream.evaluate(db))
+      end
+
+      private
+      def date_columns
+        [adjusted_start_date, adjusted_end_date]
+      end
+
+      def adjusted_start_date
+        adjusted_date(:start, :start_date)
+      end
+
+      def adjusted_end_date
+        adjusted_date(:end, :end_date)
+      end
+
+      # NOTE: This produces PostgreSQL-specific date adjustment.  I'm not yet certain how to generalize this
+      # or make different versions based on RDBMS
+      def adjusted_date(option_arg, column)
+        arg = options[option_arg]
+        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}'"))
+        end.as(column)
+      end
+    end
+  end
+end
+

data/lib/conceptql/nodes/union.rb

@@ -0,0 +1,15 @@
+require_relative 'pass_thru'
+
+module ConceptQL
+  module Nodes
+    class Union < PassThru
+      def query(db)
+        values.map do |expression|
+          expression.evaluate(db)
+        end.inject do |q, query|
+          q.union(query, all: true)
+        end
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/visit.rb

@@ -0,0 +1,11 @@
+require_relative 'node'
+
+module ConceptQL
+  module Nodes
+    class Visit < Node
+      def types
+        [:visit_occurrence]
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/visit_occurrence.rb

@@ -0,0 +1,26 @@
+require_relative 'casting_node'
+
+module ConceptQL
+  module Nodes
+    class VisitOccurrence < CastingNode
+      def my_type
+        :visit_occurrence
+      end
+
+      def i_point_at
+        [ :person ]
+      end
+
+      def these_point_at_me
+        %i[
+          condition_occurrence
+          drug_cost
+          drug_exposure
+          observation
+          procedure_cost
+          procedure_occurrence
+        ]
+      end
+    end
+  end
+end

data/lib/conceptql/nodifier.rb

@@ -0,0 +1,9 @@
+require 'active_support/inflector'
+module ConceptQL
+  class Nodifier
+    def create(type, values)
+      require_relative "nodes/#{type}"
+      "conceptQL/nodes/#{type}".camelize.constantize.new(values)
+    end
+  end
+end

data/lib/conceptql/query.rb

@@ -0,0 +1,39 @@
+require 'psych'
+require_relative 'tree'
+require_relative 'view_maker'
+
+module ConceptQL
+  class Query
+    attr :statement
+    def initialize(db, statement, tree = Tree.new)
+      @db = db
+      @statement = statement
+      @tree = tree
+    end
+
+    def query
+      build_query(db)
+    end
+
+    def execute
+      ensure_views
+      build_query(db).all
+    end
+
+    def types
+      tree.root(self).types
+    end
+
+    private
+    attr :yaml, :tree, :db
+
+    def build_query(db)
+      tree.root(self).evaluate(db)
+    end
+
+    def ensure_views
+      return if db.views.include?(:person_with_dates)
+      ViewMaker.make_views(db)
+    end
+  end
+end

data/lib/conceptql/tree.rb

@@ -0,0 +1,36 @@
+require_relative 'nodifier'
+require 'active_support/core_ext/hash'
+
+module ConceptQL
+  class Tree
+    attr :nodifier, :behavior
+    def initialize(opts = {})
+      @nodifier = opts.fetch(:nodifier, Nodifier.new)
+      @behavior = opts.fetch(:behavior, nil)
+    end
+
+    def root(query)
+      @root ||= traverse(query.statement.symbolize_keys)
+    end
+
+    private
+    def traverse(obj)
+      case obj
+      when Hash
+        if obj.keys.length > 1
+          obj = Hash[obj.map { |key, value| [ key, traverse(value) ]}]
+          return obj
+        end
+        type = obj.keys.first
+        values = traverse(obj[type])
+        obj = nodifier.create(type, values)
+        obj.extend(behavior) if behavior
+        obj
+      when Array
+        obj.map { |value| traverse(value) }
+      else
+        obj
+      end
+    end
+  end
+end

data/lib/conceptql/version.rb

@@ -0,0 +1,3 @@
+module ConceptQL
+  VERSION = "0.0.1"
+end

data/lib/conceptql/view_maker.rb

@@ -0,0 +1,56 @@
+require 'sequel'
+
+module ConceptQL
+  module ViewMaker
+    def self.make_views(db, schema = nil)
+      views.each do |view, columns|
+        make_view(db, schema, view, columns)
+      end
+    end
+
+    def self.make_view(db, schema, view, columns)
+      view_name = (view.to_s + '_with_dates')
+      view_name = schema + '__' + view_name if schema
+      view_name = view_name.to_sym
+
+      table_name = view.to_s
+      table_name = schema + '__' + table_name if schema
+      table_name = table_name.to_sym
+
+      additional_columns = [Sequel.expr(columns.shift).cast(:date).as(:start_date), Sequel.expr(columns.shift).cast(:date).as(:end_date)]
+      unless columns.empty?
+        additional_columns += columns.last.map do |column_name, column_value|
+          Sequel.expr(column_value).as(column_name)
+        end
+      end
+      query = db.from(table_name).select_all.select_append(*additional_columns)
+      puts query.sql
+      db.drop_view(view_name, if_exists: true)
+      db.create_view(view_name, query)
+    end
+
+    def self.views
+      person_date_of_birth = assemble_date(:year_of_birth, :month_of_birth, :day_of_birth)
+      {
+        condition_occurrence: [:condition_start_date, :condition_end_date],
+        death: [:death_date, :death_date, { death_id: :person_id }],
+        drug_exposure: [:drug_exposure_start_date, :drug_exposure_end_date],
+        drug_cost: [nil, nil],
+        payer_plan_period: [:payer_plan_period_start_date, :payer_plan_period_end_date],
+        person: [person_date_of_birth, person_date_of_birth],
+        procedure_occurrence: [:procedure_date, :procedure_date],
+        procedure_cost: [nil, nil],
+        observation: [:observation_date, :observation_date],
+        visit_occurrence: [:visit_start_date, :visit_end_date]
+      }
+    end
+
+    def self.assemble_date(*symbols)
+      strings = symbols.map do |symbol|
+        Sequel.function(:coalesce, symbol, '01').cast(:text)
+      end
+      strings = strings.zip(['-'] * (symbols.length - 1)).flatten.compact
+      Sequel.function(:date, Sequel.join(strings))
+    end
+  end
+end

data/lib/conceptql.rb

@@ -0,0 +1,7 @@
+require "conceptql/version"
+require "conceptql/logger"
+require "conceptql/query"
+
+module ConceptQL
+  # Your code goes here...
+end

data/spec/conceptql/behaviors/dottable_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'conceptql/nodes/node'
+require 'conceptql/behaviors/dottable'
+
+class NodeDouble < ConceptQL::Nodes::Node
+  include ConceptQL::Behaviors::Dottable
+
+  attr_accessor :values, :options
+  def initialize(*values)
+    @values = values
+    @options = {}
+    @types = []
+  end
+end
+
+describe ConceptQL::Behaviors::Dottable do
+  before do
+    @obj = NodeDouble.new
+    @obj.must_behave_like(:node)
+  end
+
+  describe '#display_name' do
+    it 'should show just the name if no children or arguments' do
+      @obj.values = []
+      @obj.display_name.must_equal 'Node Double'
+    end
+
+    it 'should show name and args' do
+      @obj.values = [5, 10]
+      @obj.display_name.must_equal 'Node Double: 5, 10'
+    end
+
+    it 'should not include children' do
+      @obj.values = [::ConceptQL::Nodes::Node.new]
+      @obj.display_name.must_equal 'Node Double'
+    end
+  end
+
+  describe '#node_name' do
+    it 'should show just the name and digit if no children' do
+      @obj.values = [::ConceptQL::Nodes::Node.new]
+      @obj.node_name.must_match(/^node_double_\d+$/)
+    end
+
+    it 'should not show args' do
+      @obj.values = [5, 10]
+      @obj.node_name.must_match(/^node_double_\d+$/)
+    end
+
+    it 'should not include children' do
+      @obj.values = [::ConceptQL::Nodes::Node.new]
+      @obj.node_name.must_match(/^node_double_\d+$/)
+    end
+  end
+
+  describe '#graph_it' do
+    it 'should add itself as a node if no children' do
+      @obj.values = []
+      mock_graph = Minitest::Mock.new
+      mock_node = Minitest::Mock.new
+      mock_graph.expect :add_nodes, mock_node, [@obj.node_name]
+      mock_node.expect :[]=, nil, [:label, @obj.display_name]
+      mock_node.expect :[]=, nil, [:color, 'black']
+      @obj.graph_it(mock_graph, Sequel.mock)
+
+      mock_node.verify
+      mock_graph.verify
+    end
+
+    it 'should add its children, then link itself as a node if children' do
+      class MockChild < ConceptQL::Nodes::Node
+        include ConceptQL::Behaviors::Dottable
+
+        attr_accessor :mock
+        def graph_it(graph, db)
+          mock.graph_it(graph, db)
+        end
+
+        def types
+          mock.types
+        end
+
+        def link_to(mock_graph, mock_node)
+          mock.link_to(mock_graph, mock_node)
+        end
+      end
+
+      mock_node = Minitest::Mock.new
+      mock_node.expect :[]=, nil, [:label, @obj.display_name]
+      mock_node.expect :[]=, nil, [:color, 'black']
+
+      mock_graph = Minitest::Mock.new
+      mock_graph.expect :add_nodes, mock_node, [@obj.node_name]
+
+      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.must_behave_like(:node)
+
+      @obj.values = [mock_child]
+
+      @obj.graph_it(mock_graph, :db)
+
+      mock_node.verify
+      mock_graph.verify
+      mock_child.mock.verify
+    end
+  end
+end

data/spec/conceptql/date_adjuster_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'conceptql/date_adjuster'
+
+describe ConceptQL::DateAdjuster do
+  describe '#adjustments' do
+    it 'returns nothing for input of ""' do
+      ConceptQL::DateAdjuster.new('').adjustments.must_equal []
+    end
+
+    it 'returns nothing for input of "0"' do
+      ConceptQL::DateAdjuster.new('').adjustments.must_equal []
+    end
+
+    it 'returns nothing for input of nil' do
+      ConceptQL::DateAdjuster.new(nil).adjustments.must_equal []
+    end
+
+    it 'returns single day for input of "1"' do
+      ConceptQL::DateAdjuster.new('1').adjustments.must_equal ['1 days']
+    end
+
+    it 'returns 20 days for input of "20"' do
+      ConceptQL::DateAdjuster.new('20').adjustments.must_equal ['20 days']
+    end
+
+    it 'returns single day for input of "d"' do
+      ConceptQL::DateAdjuster.new('d').adjustments.must_equal ['1 day']
+    end
+
+    it 'returns single month for input of "m"' do
+      ConceptQL::DateAdjuster.new('m').adjustments.must_equal ['1 month']
+    end
+
+    it 'returns single year for input of "y"' do
+      ConceptQL::DateAdjuster.new('y').adjustments.must_equal ['1 year']
+    end
+
+    it 'returns 2 days for input of "2d"' do
+      ConceptQL::DateAdjuster.new('2d').adjustments.must_equal ['2 days']
+    end
+
+    it 'returns 2 months for input of "2m"' do
+      ConceptQL::DateAdjuster.new('2m').adjustments.must_equal ['2 months']
+    end
+
+    it 'returns 2 years for input of "2y"' do
+      ConceptQL::DateAdjuster.new('2y').adjustments.must_equal ['2 years']
+    end
+
+    it 'returns negative single day for input of "-d"' do
+      ConceptQL::DateAdjuster.new('-d').adjustments.must_equal ['-1 day']
+    end
+
+    it 'returns negative single day, positive single month for "-dm"' do
+      ConceptQL::DateAdjuster.new('-dm').adjustments.must_equal ['-1 day', '1 month']
+    end
+
+    it 'returns negative 2 days for "-2d"' do
+      ConceptQL::DateAdjuster.new('-2d').adjustments.must_equal ['-2 days']
+    end
+
+    it 'returns positive 2 days for "2d"' do
+      ConceptQL::DateAdjuster.new('2d').adjustments.must_equal ['2 days']
+    end
+  end
+end
+
+

data/spec/conceptql/nodes/after_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'conceptql/nodes/after'
+require_double('stream_for_temporal')
+
+describe ConceptQL::Nodes::After do
+  it 'behaves itself' do
+    ConceptQL::Nodes::After.new.must_behave_like(:temporal_node)
+  end
+
+  subject do
+    ConceptQL::Nodes::After.new(left: StreamForTemporalDouble.new, right: StreamForTemporalDouble.new)
+  end
+
+  it 'should use proper where clause' do
+    subject.query(Sequel.mock).sql.must_match 'l.start_date > r.end_date'
+  end
+end
+

data/spec/conceptql/nodes/before_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'conceptql/nodes/before'
+require_double('stream_for_temporal')
+
+describe ConceptQL::Nodes::Before do
+  it 'behaves itself' do
+    ConceptQL::Nodes::Before.new.must_behave_like(:temporal_node)
+  end
+
+  subject do
+    ConceptQL::Nodes::Before.new(left: StreamForTemporalDouble.new, right: StreamForTemporalDouble.new)
+  end
+
+  it 'should use proper where clause' do
+    subject.query(Sequel.mock).sql.must_match 'l.end_date < r.start_date'
+  end
+end
+

data/spec/conceptql/nodes/casting_node_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'conceptql/nodes/casting_node'
+require_double('stream_for_casting')
+
+describe ConceptQL::Nodes::CastingNode do
+  it 'behaves itself' do
+    ConceptQL::Nodes::CastingNode.new.must_behave_like(:evaluator)
+  end
+
+  class CastingDouble < ConceptQL::Nodes::CastingNode
+    def my_type
+      :my_type
+    end
+
+    def i_point_at
+      [ :i_point1, :i_point2 ]
+    end
+
+    def these_point_at_me
+      [ :at_me1, :at_me2 ]
+    end
+  end
+
+  describe CastingDouble do
+    it 'must behave' do
+      CastingDouble.new.must_behave_like(:casting_node)
+    end
+  end
+
+  describe '#query' do
+    it 'uses person_ids when an uncastable type is encountered' do
+      stream = StreamForCastingDouble.new
+      stream.types = [:uncastable]
+      sql = CastingDouble.new(stream).query(Sequel.mock).sql
+      sql.must_match 'person_id IN'
+      sql.must_match 'GROUP BY person_id'
+      sql.must_match 'FROM table'
+    end
+
+    it 'uses person_ids when an uncastable type is included among castable types' do
+      stream = StreamForCastingDouble.new
+      stream.types = [:i_point1, :uncastable]
+      sql = CastingDouble.new(stream).query(Sequel.mock).sql
+      sql.must_match 'person_id IN'
+      sql.must_match 'GROUP BY person_id'
+    end
+
+    it 'uses castable types if possible' 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'
+    end
+
+    it 'uses and unions multiple castable types if possible' do
+      stream = StreamForCastingDouble.new
+      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'
+    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"
+    end
+  end
+end
+
+

data/spec/conceptql/nodes/complement_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'conceptql/nodes/complement'
+require_relative 'query_double'
+
+describe ConceptQL::Nodes::Complement do
+  it 'behaves itself' do
+    ConceptQL::Nodes::Complement.new.must_behave_like(:evaluator)
+  end
+
+  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)))"
+  end
+end