conceptql 0.1.1 → 0.2.0

data/lib/conceptql/operators/death.rb

@@ -0,0 +1,23 @@
+require_relative 'casting_operator'
+
+module ConceptQL
+  module Operators
+    class Death < CastingOperator
+      desc 'Generates all death records, or, if fed a stream, fetches all death records for the people represented in the incoming result set.'
+      types :death
+      allows_one_upstream
+
+      def my_type
+        :death
+      end
+
+      def i_point_at
+        [ :person ]
+      end
+
+      def these_point_at_me
+        []
+      end
+    end
+  end
+end

data/lib/conceptql/operators/drug_type_concept.rb

@@ -0,0 +1,21 @@
+require_relative 'operator'
+
+module ConceptQL
+  module Operators
+    class DrugTypeConcept < Operator
+      desc 'Given a set of concept IDs in RxNorm, returns that set of drug exposures'
+      argument :concept_ids, type: :codelist, vocab: 'RxNorm'
+
+      def type
+        :drug_exposure
+      end
+
+      def query(db)
+        db.from(:drug_exposure)
+          .where(drug_type_concept_id: arguments)
+      end
+    end
+  end
+end
+
+

data/lib/conceptql/{nodes → operators}/during.rb

@@ -1,8 +1,14 @@
-require_relative 'temporal_node'
+require_relative 'temporal_operator'
 
 module ConceptQL
-  module Nodes
-    class During < TemporalNode
+  module Operators
+    class During < TemporalOperator
+      desc <<-EOF
+Compares all results on a person-by-person basis between the left hand results (LHR) and the right hand resuls (RHR).
+For any result in the LHR whose start_date and end_date occur within the start_date and end_date of a RHR row, that result is passed through.
+All other results are discarded, including all results in the RHR.
+      EOF
+
       def where_clause
         if inclusive?
           Sequel.expr(Sequel.expr(Proc.new { r__start_date <= l__start_date}).&(Sequel.expr( Proc.new { l__start_date <= r__end_date })))

data/lib/conceptql/operators/equal.rb

@@ -0,0 +1,13 @@
+require_relative 'temporal_operator'
+
+module ConceptQL
+  module Operators
+    class Equal < TemporalOperator
+      desc 'If a LHR result has the same value_as_number as a RHR result, it is passed through'
+
+      def where_clause
+        { r__value_as_number: :l__value_as_number }
+      end
+    end
+  end
+end

data/lib/conceptql/operators/except.rb

@@ -0,0 +1,28 @@
+require_relative 'binary_operator_operator'
+
+module ConceptQL
+  module Operators
+    class Except < BinaryOperatorOperator
+      desc 'If a LHR result appears in the RHR result, it is removed from the output result set.'
+      category 'Set Logic'
+
+      def query(db)
+        if ignore_dates?
+          query = db.from(Sequel.as(left.evaluate(db), :l))
+            .left_join(Sequel.as(right.evaluate(db), :r), l__criterion_id: :r__criterion_id, l__criterion_type: :r__criterion_type)
+            .where(r__criterion_id: nil)
+            .select_all(:l)
+          db.from(query)
+        else
+          left.evaluate(db).except(right.evaluate(db))
+        end
+      end
+
+      private
+
+      def ignore_dates?
+        options[:ignore_dates]
+      end
+    end
+  end
+end

data/lib/conceptql/operators/filter.rb

@@ -0,0 +1,21 @@
+require_relative 'binary_operator_operator'
+
+module ConceptQL
+  module Operators
+    class Filter < BinaryOperatorOperator
+      desc 'Only pass through results from the LHR that have a corresponding RHR with the same person, criterion_id, and criterion_type'
+
+      def query(db)
+        rhs = right.evaluate(db)
+        rhs = rhs.select_group(:person_id, :criterion_id, :criterion_type)
+        query = db.from(Sequel.as(left.evaluate(db), :l))
+        query = query
+          .left_join(Sequel.as(rhs, :r), l__person_id: :r__person_id, l__criterion_id: :r__criterion_id, l__criterion_type: :r__criterion_type)
+          .exclude(r__criterion_id: nil)
+          .select_all(:l)
+        db.from(query)
+      end
+    end
+  end
+end
+

data/lib/conceptql/{nodes → operators}/first.rb

@@ -1,20 +1,22 @@
 require_relative 'occurrence'
 
 module ConceptQL
-  module Nodes
-    # Represents a node that will grab the first occurrence of something
+  module Operators
+    # Represents a operator that will grab the first occurrence of something
     #
-    # The node treats all streams as a single, large stream.  It partitions
+    # The operator treats all streams as a single, large stream.  It partitions
     # that larget stream by person_id, then sorts within those groupings
     # by start_date and then select at most one row per person, regardless
-    # of how many different types of streams enter the node
+    # of how many different types of streams enter the operator
     #
     # If two rows have the same start_date, the order of their ranking
     # is arbitrary
     #
     # If we ask for the first occurrence of something and a person has no
-    # occurrences, this node returns nothing for that person
+    # occurrences, this operator returns nothing for that person
     class First < Occurrence
+      desc 'Only passes through the row with the earliest start_date per person.  If more than one row qualifies, result is arbitrarily chosen.'
+
       def occurrence
         1
       end

data/lib/conceptql/{nodes → operators}/from.rb

@@ -1,8 +1,8 @@
 require_relative 'pass_thru'
 
 module ConceptQL
-  module Nodes
-    class From < Node
+  module Operators
+    class From < Operator
       def query(db)
         db.from(values.first)
       end

data/lib/conceptql/operators/from_seer_visits.rb

@@ -0,0 +1,23 @@
+require_relative 'operator'
+
+module ConceptQL
+  module Operators
+    class FromSeerVisits < Operator
+      def type
+        :observation
+      end
+      def query(db)
+        visit_ids = stream.evaluate(db)
+          .from_self
+          .where(criterion_type: 'visit_occurrence')
+        query = db[:observation].where(visit_occurrence_id: visit_ids.select(:criterion_id))
+        arguments.inject(query) do |q, key|
+          q.where(observation_source_value: key.to_s.upcase)
+        end
+      end
+    end
+  end
+end
+
+
+

data/lib/conceptql/{nodes → operators}/gender.rb

@@ -1,11 +1,11 @@
-require_relative 'node'
+require_relative 'operator'
 
 module ConceptQL
-  module Nodes
-    class Gender < Node
-      def type
-        :person
-      end
+  module Operators
+    class Gender < Operator
+      desc 'Returns all person records that match the selected gender.'
+      argument :gender, type: :string, options: ['Male', 'Female']
+      types :person
 
       def query(db)
         gender_concept_ids = values.map do |value|

data/lib/conceptql/operators/hcpcs.rb

@@ -0,0 +1,25 @@
+require_relative 'standard_vocabulary_operator'
+
+module ConceptQL
+  module Operators
+    class Hcpcs < StandardVocabularyOperator
+      preferred_name 'HCPCS'
+      desc 'Searches the procedure_occurrence table for all procedures with matching HCPCS codes'
+      argument :hcpcs, type: :codelist, vocab: 'HCPCS'
+      predominant_types :procedure_occurrence
+
+      def table
+        :procedure_occurrence
+      end
+
+      def vocabulary_id
+        5
+      end
+
+      def concept_column
+        :procedure_concept_id
+      end
+    end
+  end
+end
+

data/lib/conceptql/operators/icd10.rb

@@ -0,0 +1,28 @@
+require_relative 'source_vocabulary_operator'
+
+module ConceptQL
+  module Operators
+    class Icd10 < SourceVocabularyOperator
+      preferred_name 'ICD-10 CM'
+      desc 'Searches the condition_occurrence table for the given set of ICD-10 codes.'
+      argument :icd10s, type: :codelist, vocab: 'ICD10CM'
+      predominant_types :condition_occurrence
+
+      def table
+        :condition_occurrence
+      end
+
+      def vocabulary_id
+        34
+      end
+
+      def source_column
+        :condition_source_value
+      end
+
+      def concept_column
+        :condition_concept_id
+      end
+    end
+  end
+end

data/lib/conceptql/operators/icd9.rb

@@ -0,0 +1,28 @@
+require_relative 'source_vocabulary_operator'
+
+module ConceptQL
+  module Operators
+    class Icd9 < SourceVocabularyOperator
+      preferred_name 'ICD-9 CM'
+      desc 'Searches the condition_occurrence table for the given set of ICD-9 codes.'
+      argument :icd9s, type: :codelist, vocab: 'ICD9CM'
+      predominant_types :condition_occurrence
+
+      def table
+        :condition_occurrence
+      end
+
+      def vocabulary_id
+        2
+      end
+
+      def source_column
+        :condition_source_value
+      end
+
+      def concept_column
+        :condition_concept_id
+      end
+    end
+  end
+end

data/lib/conceptql/operators/icd9_procedure.rb

@@ -0,0 +1,25 @@
+require_relative 'standard_vocabulary_operator'
+
+module ConceptQL
+  module Operators
+    class Icd9Procedure < StandardVocabularyOperator
+      preferred_name 'ICD-9 Proc'
+      desc 'Searches the procedure_occurrence table for the given set of ICD-9 codes.'
+      argument :icd9s, type: :codelist, vocab: 'ICD9Proc'
+      predominant_types :procedure_occurrence
+
+      def table
+        :procedure_occurrence
+      end
+
+      def vocabulary_id
+        3
+      end
+
+      def concept_column
+        :procedure_concept_id
+      end
+    end
+  end
+end
+

data/lib/conceptql/{nodes → operators}/intersect.rb

@@ -1,15 +1,19 @@
 require_relative 'pass_thru'
 
 module ConceptQL
-  module Nodes
+  module Operators
     class Intersect < PassThru
+      desc 'Passes thru any result row that appears in all incoming result sets.'
+      allows_many_upstreams
+      category 'Set Logic'
+
       def types
-        values.map(&:types).flatten.uniq
+        upstreams.map(&:types).flatten.uniq
       end
 
       def query(db)
         exprs = {}
-        values.each do |expression|
+        upstreams.each do |expression|
           evaled = expression.evaluate(db)
           expression.types.each do |type|
             (exprs[type] ||= []) << evaled

data/lib/conceptql/{nodes → operators}/last.rb

@@ -1,20 +1,22 @@
 require_relative 'occurrence'
 
 module ConceptQL
-  module Nodes
-    # Represents a node that will grab the last occurrence of something
+  module Operators
+    # Represents a operator that will grab the last occurrence of something
     #
-    # The node treats all streams as a single, large stream.  It partitions
+    # The operator treats all streams as a single, large stream.  It partitions
     # that larget stream by person_id, then sorts within those groupings
     # by start_date and then select at most one row per person, regardless
-    # of how many different types of streams enter the node
+    # of how many different types of streams enter the operator
     #
     # If two rows have the same start_date, the order of their ranking
     # is arbitrary
     #
     # If we ask for the last occurrence of something and a person has no
-    # occurrences, this node returns nothing for that person
+    # occurrences, this operator returns nothing for that person
     class Last < Occurrence
+      desc 'Only passes through the row with the most recent start_date per person.  If more than one row qualifies, result is arbitrarily chosen.'
+
       def occurrence
         -1
       end

data/lib/conceptql/operators/loinc.rb

@@ -0,0 +1,25 @@
+require_relative 'standard_vocabulary_operator'
+
+module ConceptQL
+  module Operators
+    class Loinc < StandardVocabularyOperator
+      preferred_name 'LOINC'
+      desc 'Searches the observation table for all observations with matching LOINC codes'
+      argument :loincs, type: :codelist, vocab: 'LOINC'
+      predominant_types :observation
+
+      def table
+        :observation
+      end
+
+      def vocabulary_id
+        6
+      end
+
+      def concept_column
+        :observation_concept_id
+      end
+    end
+  end
+end
+

data/lib/conceptql/operators/medcode.rb

@@ -0,0 +1,28 @@
+require_relative 'source_vocabulary_operator'
+
+module ConceptQL
+  module Operators
+    class Medcode < SourceVocabularyOperator
+      desc 'Searches the condition_occurrence table for all conditions with matching Medcodes'
+      argument :medcodes, type: :codelist, vocab_id: '203'
+      predominant_types :condition_occurrence
+
+      def table
+        :condition_occurrence
+      end
+
+      def vocabulary_id
+        203
+      end
+
+      def source_column
+        :condition_source_value
+      end
+
+      def concept_column
+        :condition_concept_id
+      end
+    end
+  end
+end
+

data/lib/conceptql/operators/medcode_procedure.rb

@@ -0,0 +1,27 @@
+require_relative 'source_vocabulary_operator'
+
+module ConceptQL
+  module Operators
+    class MedcodeProcedure < SourceVocabularyOperator
+      desc 'Searches the procedure_occurrence table for all procedures with matching Medcodes'
+      argument :medcodes, type: :codelist, vocab: '204'
+      predominant_types :procedure_occurrence
+
+      def table
+        :procedure_occurrence
+      end
+
+      def vocabulary_id
+        204
+      end
+
+      def source_column
+        :procedure_source_value
+      end
+
+      def concept_column
+        :procedure_concept_id
+      end
+    end
+  end
+end

data/lib/conceptql/operators/ndc.rb

@@ -0,0 +1,29 @@
+require_relative 'source_vocabulary_operator'
+
+module ConceptQL
+  module Operators
+    class Ndc < SourceVocabularyOperator
+      preferred_name 'NDC'
+      desc 'Searches the drug_exposure table for all procedures with matching NDC codes'
+      argument :ndcs, type: :codelist, vocab: 'NDC'
+      predominant_types :drug_exposure
+
+      def table
+        :drug_exposure
+      end
+
+      def vocabulary_id
+        9
+      end
+
+      def source_column
+        :drug_source_value
+      end
+
+      def concept_column
+        :drug_concept_id
+      end
+    end
+  end
+end
+

data/lib/conceptql/operators/numeric.rb

@@ -0,0 +1,54 @@
+require_relative 'pass_thru'
+
+module ConceptQL
+  module Operators
+    # Represents a operator that will either:
+    # - create a value_as_number value for every person in the database
+    # - change the value_as_number value for every every result passed in
+    #   - either to a number
+    #   - or a value from a column in the origin row
+    #
+    # Accepts two params:
+    # - Either a number value or a symbol representing a column name
+    # - An optional stream
+    class Numeric < PassThru
+      desc <<-EOF
+Represents a operator that will either:
+- create a value_as_number value for every person in the database
+- change the value_as_number value for every every result passed in
+  - either to a number
+  - or a value from a column in the origin row
+
+Accepts two params:
+- Either a number value or a symbol representing a column name
+- An optional stream
+      EOF
+      argument :value, type: :float
+      allows_one_upstream
+
+      def query(db)
+        stream.nil? ? as_criterion(db) : with_kids(db)
+      end
+
+      def types
+        stream.nil? ? [:person] : super
+      end
+
+      private
+      def with_kids(db)
+        db.from(stream.evaluate(db))
+          .select(*(COLUMNS - [:value_as_number]))
+          .select_append(Sequel.lit('?', arguments.first).cast(Float).as(:value_as_number))
+          .from_self
+      end
+
+      def as_criterion(db)
+        db.from(select_it(db.from(:person), :person))
+          .select(*(COLUMNS - [:value_as_number]))
+          .select_append(Sequel.lit('?', arguments.first).cast(Float).as(:value_as_number))
+          .from_self
+      end
+    end
+  end
+end
+

data/lib/conceptql/operators/observation_by_enttype.rb

@@ -0,0 +1,29 @@
+require_relative 'source_vocabulary_operator'
+
+module ConceptQL
+  module Operators
+    class ObservationByEnttype < SourceVocabularyOperator
+      desc 'Searches the observation table for all observations with matching Enttype'
+      argument :enttypes, type: :codelist, vocab_id: [206, 207]
+      predominant_types :observation
+
+      def table
+        :observation
+      end
+
+      def vocabulary_id
+        [206, 207]
+      end
+
+      def source_column
+        :observation_source_value
+      end
+
+      def concept_column
+        :observation_concept_id
+      end
+    end
+  end
+end
+
+

data/lib/conceptql/operators/observation_period.rb

@@ -0,0 +1,30 @@
+require_relative 'casting_operator'
+
+module ConceptQL
+  module Operators
+    class ObservationPeriod < CastingOperator
+      desc 'Generates all observation_period records, or, if fed a stream, fetches all observation_period records for the people represented in the incoming result set.'
+      types :observation_period
+      allows_one_upstream
+
+      def my_type
+        :observation_period
+      end
+
+      def i_point_at
+        []
+      end
+
+      def these_point_at_me
+        # I could list ALL the types we use, but the default behavior of casting,
+        # when there is no explicit casting defined, is to convert everything to
+        # person IDs
+        #
+        # So by defining no known castable relationships in this operator, all
+        # types will be converted to person
+        []
+      end
+    end
+  end
+end
+

data/lib/conceptql/operators/occurrence.rb

@@ -0,0 +1,70 @@
+require_relative 'operator'
+
+module ConceptQL
+  module Operators
+    # Represents a operator that will grab the Nth occurrence of something
+    #
+    # Specify occurrences as integers, excluding O
+    # 1 => first
+    # 2 => second
+    # ...
+    # -1 => last
+    # -2 => second-to-last
+    #
+    # The operator treats all streams as a single, large stream.  It partitions
+    # that larget stream by person_id, then sorts within those groupings
+    # by start_date and then select at most one row per person, regardless
+    # of how many different types of streams enter the operator
+    #
+    # If two rows have the same start_date, the order of their ranking
+    # is arbitrary
+    #
+    # If we ask for the second occurrence of something and a person has only one
+    # occurrence, this operator returns nothing for that person
+    class Occurrence < Operator
+      preferred_name 'Nth Occurrence'
+      desc <<-EOF
+Groups all results by person, then orders by start_date, then finds the nth occurrence.
+nth occurrence can be positive or negative.
+1 => first
+2 => second
+...
+-1 => last
+-2 => second-to-last
+
+If two rows have the same start_date, the order of their ranking
+is arbitrary
+
+If we ask for the second occurrence of something and a person has only one
+occurrence, this operator returns nothing for that person
+      EOF
+      argument :occurrence, type: :integer
+      allows_one_upstream
+      category %w(Temporal Occurrence)
+
+      def query(db)
+        db[:occurrences]
+          .with(:occurrences,
+            stream.evaluate(db)
+              .from_self
+              .select_append { |o| o.row_number(:over, partition: :person_id, order: ordered_columns){}.as(:rn) })
+          .where(rn: occurrence.abs)
+      end
+
+      def occurrence
+        @occurrence ||= arguments.first
+      end
+
+      private
+      def asc_or_desc
+        occurrence < 0 ? :desc : :asc
+      end
+
+      def ordered_columns
+        ordered_columns = [Sequel.send(asc_or_desc, :start_date)]
+        ordered_columns += [:criterion_type, :criterion_id]
+      end
+    end
+  end
+end
+