conceptql 0.2.0 → 0.4.0

data/lib/conceptql/operators/source_vocabulary_operator.rb

@@ -1,58 +0,0 @@
-require_relative 'operator'
-
-module ConceptQL
-  module Operators
-    # A SourceVocabularyOperator is a superclass for a operator that represents a criterion whose column stores information associated with a source vocabulary.
-    #
-    # If that seems confusing, then think of ICD-9 or NDC criteria.  That type of criterion takes a set of values that are mapped via the source_to_concept_map table into a standard vocabulary.
-    #
-    # This kind of criterion can have some interesting issues when we are searching for rows that match.  Let's take ICD-9 286.53 for example. That code maps to concept_id 0, so if we try to pull all conditions that match just the concept_id of 0 we'll pull all condtions that have no match in the SNOMED standard vocabulary.  That's not what we want!  So we need to search the condition_source_value field for matches on this code instead.
-    #
-    # But there's another, more complicated problem.  Say we're looking for ICD-9 289.81.  OMOP maps this to concept_id 432585.  OMOP also maps 20 other conditions, 6 of which are other ICD-9 codes, to this same concept_id.  So if we look for ICD-9s that have a non-zero condition_condept_id, we might pull up conditions that match on concept_id, but aren't the same exact code as the one we're looking for.
-    #
-    # 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 ICD-9, this would be condition_occurrence
-    # * concept_column
-    #   * Name of the column in the table that stores a concept_id related to the criterion
-    #   * e.g. for ICD-9, this would be condition_concept_id
-    # * source_column
-    #   * Name of the column in the table that stores the "raw" value related to the criterion
-    #   * e.g. for ICD-9, this would be condition_source_value
-    # * vocabulary_id
-    #   * The vocabulary ID of the source vocabulary for the criterion
-    #   * e.g. for ICD-9, a value of 2 (for ICD-9-CM)
-    class SourceVocabularyOperator < Operator
-      category 'Source Vocabulary'
-      category 'Code Lists'
-
-      def query(db)
-        db.from(table_name)
-          .join(:vocabulary__source_to_concept_map___scm, scm__target_concept_id: table_concept_column)
-          .where(Sequel.expr(scm__source_code: values, scm__source_vocabulary_id: vocabulary_id).&(Sequel.expr(scm__source_code: table_source_column)))
-      end
-
-      def type
-        table
-      end
-
-      private
-
-      def table_name
-        @table_name ||= make_table_name(table)
-      end
-
-      def table_concept_column
-        "tab__#{concept_column}".to_sym
-      end
-
-      def table_source_column
-        "tab__#{source_column}".to_sym
-      end
-    end
-  end
-end
-

data/lib/conceptql/operators/standard_vocabulary_operator.rb

@@ -1,45 +0,0 @@
-require_relative 'operator'
-
-module ConceptQL
-  module Operators
-    # A StandardVocabularyOperator is a superclass for a operator 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 StandardVocabularyOperator < Operator
-      category 'Standard Vocabulary'
-      category 'Code Lists'
-      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 type
-        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/operators/started_by.rb

@@ -1,22 +0,0 @@
-require_relative 'temporal_operator'
-
-module ConceptQL
-  module Operators
-    class StartedBy < TemporalOperator
-      desc <<-EOF
-If LHR has the same start date as RHR, but LHR's end_date falls on or after end_date of RHR, LHR is passed through.
-L----Y----L
-R-------R
-L--N--L
-      EOF
-      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/operators/to_seer_visits.rb

@@ -1,24 +0,0 @@
-require_relative 'operator'
-
-module ConceptQL
-  module Operators
-    class ToSeerVisits < Operator
-      def type
-        :visit_occurrence
-      end
-
-      def query(db)
-        query = options.map do |k, v|
-          next if v.nil?
-          db[:observation]
-            .where(observation_source_value: k.to_s.upcase, value_as_string: v)
-            .select(:visit_occurrence_id)
-            .from_self
-        end.compact.inject { |q, i| i.intersect(q) }
-        db[:visit_occurrence].where(visit_occurrence_id: query)
-      end
-    end
-  end
-end
-
-

data/lib/conceptql/operators/visit.rb

@@ -1,15 +0,0 @@
-require_relative 'operator'
-
-module ConceptQL
-  module Operators
-    class Visit < Operator
-      desc 'Generates all visit_occurrence records, or, if fed a stream, fetches all visit_occurrence records for the people represented in the incoming result set.'
-      types :visit_occurrence
-      allows_one_upstream
-
-      def types
-        [:visit_occurrence]
-      end
-    end
-  end
-end

data/lib/conceptql/operators/visit_occurrence.rb

@@ -1,30 +0,0 @@
-require_relative 'casting_operator'
-
-module ConceptQL
-  module Operators
-    class VisitOccurrence < CastingOperator
-      desc 'Returns all visits in the database, or if given a upstream, converts all results to the set of visit_occurrences related to those results.'
-      allows_one_upstream
-      types :visit_occurrence
-
-      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/tree.rb

@@ -1,53 +0,0 @@
-require_relative 'nodifier'
-require_relative 'converter'
-require_relative 'scope'
-require 'facets/hash/deep_rekey'
-require 'facets/array/recurse'
-
-module ConceptQL
-  # Tree is used to walk through a ConceptQL statement, instantiate
-  # all operators, and then provide access to the root operator
-  class Tree
-    attr :nodifier, :behavior, :defined, :opts, :temp_tables, :scope
-    def initialize(opts = {})
-      @nodifier = opts.fetch(:nodifier, Nodifier.new)
-      @behavior = opts.fetch(:behavior, nil)
-      @defined = {}
-      @temp_tables = {}
-      @opts = {}
-      @scope = opts.fetch(:scope, Scope.new)
-    end
-
-    def root(query)
-      @root ||= start_traverse(query.statement)
-    end
-
-    private
-
-    def start_traverse(stmt)
-      case stmt
-      when Hash
-        traverse(converter.convert(stmt))
-      when Array
-        traverse(stmt)
-      end
-    end
-
-    def traverse(stmt)
-      stmt.recurse(Array, Hash) do |arr_or_hash|
-        if arr_or_hash.is_a?(Array)
-          type = arr_or_hash.shift
-          obj = nodifier.create(scope, type, *arr_or_hash)
-          obj.extend(behavior) if behavior
-          obj
-        else
-          arr_or_hash
-        end
-      end
-    end
-
-    def converter
-      @converter ||= Converter.new
-    end
-  end
-end

data/lib/conceptql/utils/temp_table.rb

@@ -1,72 +0,0 @@
-require 'zlib'
-
-module ConceptQL
-  # TempTable coordinates the creation of any temporary tables a statement
-  # might need.
-  #
-  # Currently, temp tables are used to share a set of results when a Recall
-  # operator is present in a statement.
-  #
-  # It also provides an API to generate the SQL that Sequel would use to create
-  # and populate the temp table
-  class TempTable
-    attr :operator
-    def initialize(operator, db)
-      @operator = operator
-      fake_it!(db)
-    end
-
-    def build(db)
-      @built ||= build_it(db)
-    end
-
-    def sql(db)
-      # Sequel doesn't (currently) provide an API for getting the SQL for the
-      # creation of tables, so we're calling one of the private methods
-      sql = db[db.send(:create_table_as_sql, table_name, operator.evaluate(db), temp: true)].sql
-      ["-- #{operator.label}", sql].join("\n")
-    end
-
-    def from(db)
-      db[table_name]
-    end
-
-    private
-
-    def table_name
-      namify(operator.label)
-    end
-
-    def build_it(db)
-      db.create_table!(table_name, as: operator.evaluate(db), temp: true)
-      true
-    end
-
-    def namify(name)
-      digest = Zlib.crc32 name
-      ('_' + digest.to_s).to_sym
-    end
-
-    # Creates the temp table, but populates it with a single fake row of null
-    # values.  Some operations, such as generating the SQL for a statement
-    # Want the temp tables to exist, but we don't _really_ need the actual
-    # results in the temp table since they might take a long time to calculate.
-    def fake_it!(db)
-      db.create_table!(table_name, temp: true, as: fake_row(db))
-    end
-
-    def fake_row(db)
-      db
-        .select(Sequel.cast(nil, Bignum).as(:person_id))
-        .select_append(Sequel.cast(nil, Bignum).as(:criterion_id))
-        .select_append(Sequel.cast(nil, String).as(:criterion_type))
-        .select_append(Sequel.cast(nil, Date).as(:start_date))
-        .select_append(Sequel.cast(nil, Date).as(:end_date))
-        .select_append(Sequel.cast(nil, Bignum).as(:value_as_number))
-        .select_append(Sequel.cast(nil, String).as(:value_as_string))
-        .select_append(Sequel.cast(nil, Bignum).as(:value_as_concept_id))
-        .select_append(Sequel.cast(nil, String).as(:units_source_value))
-        .select_append(Sequel.cast(nil, String).as(:source_value))
-    end
-  end
-end

data/spec/conceptql/behaviors/dottable_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-require 'conceptql/operators/operator'
-require 'conceptql/behaviors/dottable'
-
-class OperatorDouble < ConceptQL::Operators::Operator
-  include ConceptQL::Behaviors::Dottable
-
-  def initialize(*args)
-    super
-    @types = []
-  end
-end
-
-describe ConceptQL::Behaviors::Dottable do
-  before do
-    @obj = OperatorDouble.new
-  end
-
-  describe '#display_name' do
-    it 'should show just the name if no upstreams or arguments' do
-      @obj.values = []
-      expect(@obj.display_name).to match(/Operator Double( \d+)?/)
-    end
-
-    it 'should show name and args' do
-      @obj.values = [5, 10]
-      expect(@obj.display_name).to match(/Operator Double( \d+)?: 5, 10/)
-    end
-
-    it 'should not include upstreams' do
-      @obj.values = [::ConceptQL::Operators::Operator.new]
-      expect(@obj.display_name).to match(/Operator Double( \d+)?/)
-    end
-  end
-
-  describe '#operator_name' do
-    it 'should show just the name and digit if no upstreams' do
-      @obj.values = [::ConceptQL::Operators::Operator.new]
-      expect(@obj.operator_name).to match(/^operator_double_\d+$/)
-    end
-
-    it 'should not show args' do
-      @obj.values = [5, 10]
-      expect(@obj.operator_name).to match(/^operator_double_\d+$/)
-    end
-
-    it 'should not include upstreams' do
-      @obj.values = [::ConceptQL::Operators::Operator.new]
-      expect(@obj.operator_name).to match(/^operator_double_\d+$/)
-    end
-  end
-
-  describe '#graph_it' do
-    it 'should add itself as a operator if no upstreams' do
-      @obj.values = []
-      mock_graph = double("graph")
-      mock_operator = double("operator")
-      expect(mock_graph).to receive(:add_nodes).with(@obj.operator_name).and_return(mock_operator)
-      expect(mock_operator).to receive(:[]=).with(:label, @obj.display_name).and_return(nil)
-      expect(mock_operator).to receive(:[]=).with(:color, 'black').and_return(nil)
-      @obj.graph_it(mock_graph, Sequel.mock)
-    end
-
-    it 'should add its upstreams, then link itself as a operator if upstreams' do
-      class MockUpstream < ConceptQL::Operators::Operator
-        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_operator, db)
-          mock.link_to(mock_graph, mock_operator, db)
-        end
-      end
-
-      mock_operator = double("operator")
-      expect(mock_operator).to receive(:[]=).with(:label, @obj.display_name).and_return(nil)
-      expect(mock_operator).to receive(:[]=).with(:color, 'black').and_return(nil)
-
-      mock_graph = double("graph")
-      expect(mock_graph).to receive(:add_nodes).with(@obj.operator_name).and_return(mock_operator)
-
-      mock_upstream = MockUpstream.new
-      mock_upstream.mock = double("upstream")
-      expect(mock_upstream.mock).to receive(:graph_it).with(mock_graph, :db).and_return(:upstream_operator)
-      expect(mock_upstream.mock).to receive(:link_to).with(mock_graph, mock_operator, :db).and_return(nil)
-
-      @obj.values = mock_upstream
-
-      @obj.graph_it(mock_graph, :db)
-    end
-  end
-end

data/spec/conceptql/converter_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'conceptql/converter'
-
-describe ConceptQL::Converter do
-  describe '#convert' do
-    it 'convert {icd9: 412} to [:icd9, "412"]' do
-      statement = { icd9: '412' }
-      expect(ConceptQL::Converter.new.convert(statement)).to eq([:icd9, '412'])
-    end
-
-    it 'convert {icd9: ["412", "200"]} to [:icd9, "412"]' do
-      statement = { icd9: %w(412 200) }
-      expect(ConceptQL::Converter.new.convert(statement)).to eq([:icd9, '412', '200'])
-    end
-
-    it 'convert { first: {icd9: ["412", "200"]}} to [:first, [:icd9, "412"] ]' do
-      statement = {
-        first: {
-          icd9: %w(412 200)
-        }
-      }
-      expect(ConceptQL::Converter.new.convert(statement)).to eq([:first, [:icd9, '412', '200'] ])
-    end
-
-    it 'convert operators in options to list-syntax' do
-      statement = {
-        after: {
-          left: {
-            icd9: '412'
-          },
-          right: {
-            icd9: '200'
-
-          }
-        }
-      }
-      expect(ConceptQL::Converter.new.convert(statement)).to eq([:after, { left: [:icd9, '412'], right: [:icd9, '200'] }])
-    end
-
-    it 'converts operators with an array of upstreams' do
-      statement = {
-        intersect: [
-          { icd9: '412' },
-          { condition_type: :inpatient_header }
-        ]
-      }
-      expect(ConceptQL::Converter.new.convert(statement)).to eq([:intersect, [ :icd9, '412' ], [ :condition_type, :inpatient_header ] ])
-    end
-  end
-end
-

data/spec/conceptql/date_adjuster_spec.rb

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

data/spec/conceptql/operators/after_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require 'conceptql/operators/after'
-require_double('stream_for_temporal')
-
-describe ConceptQL::Operators::After 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.end_date')
-  end
-end
-

data/spec/conceptql/operators/before_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require 'conceptql/operators/before'
-require_double('stream_for_temporal')
-
-describe ConceptQL::Operators::Before 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.end_date < r.start_date')
-  end
-end
-

data/spec/conceptql/operators/casting_operator_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require 'conceptql/operators/casting_operator'
-require_double('stream_for_casting')
-
-describe ConceptQL::Operators::CastingOperator do
-  it_behaves_like(:evaluator)
-
-  class CastingDouble < ConceptQL::Operators::CastingOperator
-    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_behaves_like(:casting_operator)
-  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
-      expect(sql).to match('person_id IN')
-      expect(sql).to match('GROUP BY person_id')
-      expect(sql).to 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
-      expect(sql).to match('person_id IN')
-      expect(sql).to 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
-      expect(sql).to match('i_point1_id IN')
-      expect(sql).to match("criterion_type = 'i_point1'")
-    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
-      expect(sql).to match('my_type_id IN')
-      expect(sql).to match('i_point1_id IN')
-      expect(sql).to 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
-      expect(sql).to match("SELECT * FROM my_type AS tab")
-    end
-  end
-end
-
-

data/spec/conceptql/operators/complement_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-require 'conceptql/operators/complement'
-require_relative 'query_double'
-
-describe ConceptQL::Operators::Complement do
-  it_behaves_like(:evaluator)
-
-  it 'generates complement for single criteria' do
-    double1 = QueryDouble.new(1)
-    sql = ConceptQL::Operators::Complement.new(double1).query(Sequel.mock).sql
-    expect(sql).to match("criterion_id IS NOT NULL")
-    expect(sql).to match("visit_occurrence_id NOT IN")
-    expect(sql).to match("criterion_type = 'visit_occurrence'")
-  end
-end