conceptql 0.0.1

data/lib/conceptql/nodes/cpt.rb

@@ -0,0 +1,20 @@
+require_relative 'standard_vocabulary_node'
+
+module ConceptQL
+  module Nodes
+    class Cpt < StandardVocabularyNode
+      def table
+        :procedure_occurrence
+      end
+
+      def vocabulary_id
+        4
+      end
+
+      def concept_column
+        :procedure_concept_id
+      end
+    end
+  end
+end
+

data/lib/conceptql/nodes/date_range.rb

@@ -0,0 +1,39 @@
+require_relative 'node'
+
+module ConceptQL
+  module Nodes
+    # Represents a node that will create a date_range for every person in the database
+    #
+    # Accepts two params: start and end formateed as 'YYYY-MM-DD' or 'START' or 'END'
+    # 'START' represents the first date of data in the data source,
+    # 'END' represents the last date of data in the data source,
+    class DateRange < Node
+      def query(db)
+        db.from(:person)
+          .select_append(Sequel.expr(start_date(db)).cast(:date).as(:start_date),Sequel.expr(end_date(db)).cast(:date).as(:end_date)).from_self
+      end
+
+      def types
+        [:person]
+      end
+
+      private
+      def start_date(db)
+        date_from(db, options[:start])
+      end
+
+      def end_date(db)
+        date_from(db, options[:end])
+      end
+
+      # 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 str
+      end
+    end
+  end
+end
+

data/lib/conceptql/nodes/death.rb

@@ -0,0 +1,19 @@
+require_relative 'casting_node'
+
+module ConceptQL
+  module Nodes
+    class Death < CastingNode
+      def my_type
+        :death
+      end
+
+      def i_point_at
+        [ :person ]
+      end
+
+      def these_point_at_me
+        []
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/during.rb

@@ -0,0 +1,16 @@
+require_relative 'temporal_node'
+
+module ConceptQL
+  module Nodes
+    class During < TemporalNode
+      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 })))
+            .|(Sequel.expr(Proc.new { r__start_date <= l__end_date}).&(Sequel.expr( Proc.new { l__end_date <= r__end_date })))
+        else
+          [Proc.new { r__start_date <= l__start_date}, Proc.new { l__end_date <= r__end_date }]
+        end
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/except.rb

@@ -0,0 +1,11 @@
+require_relative 'binary_operator_node'
+
+module ConceptQL
+  module Nodes
+    class Except < BinaryOperatorNode
+      def query(db)
+        left.evaluate(db).except(right.evaluate(db))
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/first.rb

@@ -0,0 +1,24 @@
+require_relative 'occurrence'
+
+module ConceptQL
+  module Nodes
+    # Represents a node that will grab the first occurrence of something
+    #
+    # The node 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
+    #
+    # 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
+    class First < Occurrence
+      def occurrence
+        1
+      end
+    end
+  end
+end
+

data/lib/conceptql/nodes/from.rb

@@ -0,0 +1,15 @@
+require_relative 'pass_thru'
+
+module ConceptQL
+  module Nodes
+    class From < Node
+      def query(db)
+        db.from(values.first)
+      end
+
+      def types
+        values[1..99].compact
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/gender.rb

@@ -0,0 +1,27 @@
+require_relative 'node'
+
+module ConceptQL
+  module Nodes
+    class Gender < Node
+      def types
+        [:person]
+      end
+
+      def query(db)
+        gender_concept_ids = values.map do |value|
+          case value.to_s
+          when /^m/i
+            8507
+          when /^f/i
+            8532
+          else
+            value.to_i
+          end
+        end
+
+        db.from(:person_with_dates)
+          .where(gender_concept_id: gender_concept_ids)
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/hcpcs.rb

@@ -0,0 +1,20 @@
+require_relative 'standard_vocabulary_node'
+
+module ConceptQL
+  module Nodes
+    class Hcpcs < StandardVocabularyNode
+      def table
+        :procedure_occurrence
+      end
+
+      def vocabulary_id
+        5
+      end
+
+      def concept_column
+        :procedure_concept_id
+      end
+    end
+  end
+end
+

data/lib/conceptql/nodes/icd10.rb

@@ -0,0 +1,23 @@
+require_relative 'source_vocabulary_node'
+
+module ConceptQL
+  module Nodes
+    class Icd10 < SourceVocabularyNode
+      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/nodes/icd9.rb

@@ -0,0 +1,23 @@
+require_relative 'source_vocabulary_node'
+
+module ConceptQL
+  module Nodes
+    class Icd9 < SourceVocabularyNode
+      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/nodes/icd9_procedure.rb

@@ -0,0 +1,20 @@
+require_relative 'standard_vocabulary_node'
+
+module ConceptQL
+  module Nodes
+    class Icd9Procedure < StandardVocabularyNode
+      def table
+        :procedure_occurrence
+      end
+
+      def vocabulary_id
+        3
+      end
+
+      def concept_column
+        :procedure_concept_id
+      end
+    end
+  end
+end
+

data/lib/conceptql/nodes/intersect.rb

@@ -0,0 +1,29 @@
+require_relative 'pass_thru'
+
+module ConceptQL
+  module Nodes
+    class Intersect < PassThru
+      def types
+        values.map(&:types).flatten.uniq
+      end
+
+      def query(db)
+        exprs = {}
+        values.each do |expression|
+          expression.types.each do |type|
+            (exprs[type] ||= []) << expression.evaluate(db)
+          end
+        end
+        typed_queries = exprs.map do |type, queries|
+          queries.inject do |q, query|
+            q.intersect(query, all: true)
+          end
+        end
+
+        typed_queries.inject do |q, query|
+          q.union(query, all: true)
+        end
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/last.rb

@@ -0,0 +1,24 @@
+require_relative 'occurrence'
+
+module ConceptQL
+  module Nodes
+    # Represents a node that will grab the last occurrence of something
+    #
+    # The node 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
+    #
+    # 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
+    class Last < Occurrence
+      def occurrence
+        -1
+      end
+    end
+  end
+end
+

data/lib/conceptql/nodes/loinc.rb

@@ -0,0 +1,20 @@
+require_relative 'standard_vocabulary_node'
+
+module ConceptQL
+  module Nodes
+    class Loinc < StandardVocabularyNode
+      def table
+        :observation
+      end
+
+      def vocabulary_id
+        6
+      end
+
+      def concept_column
+        :observation_concept_id
+      end
+    end
+  end
+end
+

data/lib/conceptql/nodes/node.rb

@@ -0,0 +1,71 @@
+require 'active_support/core_ext/hash'
+module ConceptQL
+  module Nodes
+    class Node
+      KNOWN_TYPES = %i(
+        condition_occurrence
+        death
+        drug_cost
+        drug_exposure
+        observation
+        payer_plan_period
+        procedure_cost
+        procedure_occurrence
+        visit_occurrence
+      )
+
+      attr :values, :options
+      def initialize(*args)
+        args.flatten!
+        if args.last.is_a?(Hash)
+          @options = args.pop.symbolize_keys
+        end
+        @options ||= {}
+        @values = args.flatten
+      end
+
+      def evaluate(db)
+        select_it(query(db))
+      end
+
+      def select_it(query, select_types=types)
+        query.select(*columns(select_types))
+      end
+
+      def types
+        @types ||= children.map(&:types).flatten.uniq
+      end
+
+      def children
+        @children ||= values.select { |v| v.is_a?(Node) }
+      end
+
+      def stream
+        @stream ||= children.first
+      end
+
+      def arguments
+        @arguments ||= values.reject { |v| v.is_a?(Node) }
+      end
+
+      def columns(select_types = types)
+        [:person_id___person_id] + KNOWN_TYPES.map do |known_type|
+          select_types.include?(known_type) ? "#{known_type}_id___#{known_type}_id".to_sym : Sequel.expr(nil).cast(:bigint).as("#{known_type}_id".to_sym)
+        end + date_columns
+      end
+
+      def date_columns
+        [:start_date, :end_date]
+      end
+
+      private
+      def type_id(type)
+        (type.to_s + '_id').to_sym
+      end
+
+      def make_table_name(table)
+        "#{table}_with_dates___tab".to_sym
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/occurrence.rb

@@ -0,0 +1,47 @@
+require_relative 'node'
+
+module ConceptQL
+  module Nodes
+    # Represents a node 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 node 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
+    #
+    # 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 node returns nothing for that person
+    class Occurrence < Node
+      def query(db)
+        db.from(stream.evaluate(db)
+          .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 += types.map { |t| Sequel.asc(type_id(t)) }
+      end
+    end
+  end
+end
+

data/lib/conceptql/nodes/pass_thru.rb

@@ -0,0 +1,11 @@
+require_relative 'node'
+
+module ConceptQL
+  module Nodes
+    class PassThru < Node
+      def types
+        values.map(&:types).flatten.uniq
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/person.rb

@@ -0,0 +1,25 @@
+require_relative 'casting_node'
+
+module ConceptQL
+  module Nodes
+    class Person < CastingNode
+      def my_type
+        :person
+      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 node, all
+        # types will be converted to person
+        []
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/person_filter.rb

@@ -0,0 +1,12 @@
+require_relative 'binary_operator_node'
+
+module ConceptQL
+  module Nodes
+    class PersonFilter < BinaryOperatorNode
+      def query(db)
+        db.from(left.evaluate(db))
+          .where(person_id: right.evaluate(db).select_group(:person_id))
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/place_of_service_code.rb

@@ -0,0 +1,23 @@
+require_relative 'node'
+
+module ConceptQL
+  module Nodes
+    # Represents a node that will grab all person rows that match the given place_of_service_codes
+    #
+    # PlaceOfServiceCode parameters are passed in as a set of strings.  Each string represents
+    # a single place_of_service_code.  The place_of_service_code string must match one of the values in the
+    # concept_name column of the concept table.  If you misspell the place_of_service_code name
+    # you won't get any matches
+    class PlaceOfServiceCode < Node
+      def types
+        [:visit_occurrence]
+      end
+
+      def query(db)
+        db.from(:visit_occurrence_with_dates___v)
+          .join(:vocabulary__concept___vc, { vc__concept_id: :v__place_of_service_concept_id })
+          .where(vc__concept_code: arguments.map(&:to_s))
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/procedure_occurrence.rb

@@ -0,0 +1,21 @@
+require_relative 'casting_node'
+
+module ConceptQL
+  module Nodes
+    class ProcedureOccurrence < CastingNode
+      def my_type
+        :procedure_occurrence
+      end
+
+      def i_point_at
+        [ :person ]
+      end
+
+      def these_point_at_me
+        %i[
+          procedure_cost
+        ]
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/race.rb

@@ -0,0 +1,23 @@
+require_relative 'node'
+
+module ConceptQL
+  module Nodes
+    # Represents a node that will grab all person rows that match the given races
+    #
+    # Race parameters are passed in as a set of strings.  Each string represents
+    # a single race.  The race string must match one of the values in the
+    # concept_name column of the concept table.  If you misspell the race name
+    # you won't get any matches
+    class Race < Node
+      def types
+        [:person]
+      end
+
+      def query(db)
+        db.from(:person_with_dates___p)
+          .join(:vocabulary__concept___vc, { vc__concept_id: :p__race_concept_id })
+          .where(Sequel.function(:lower, :vc__concept_name) => arguments.map(&:downcase))
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/rxnorm.rb

@@ -0,0 +1,20 @@
+require_relative 'standard_vocabulary_node'
+
+module ConceptQL
+  module Nodes
+    class Rxnorm < StandardVocabularyNode
+      def table
+        :drug_exposure
+      end
+
+      def vocabulary_id
+        8
+      end
+
+      def concept_column
+        :drug_concept_id
+      end
+    end
+  end
+end
+

data/lib/conceptql/nodes/snomed.rb

@@ -0,0 +1,19 @@
+require_relative 'standard_vocabulary_node'
+
+module ConceptQL
+  module Nodes
+    class Snomed < StandardVocabularyNode
+      def table
+        :condition_occurrence
+      end
+
+      def vocabulary_id
+        1
+      end
+
+      def concept_column
+        :condition_concept_id
+      end
+    end
+  end
+end

data/lib/conceptql/nodes/source_vocabulary_node.rb

@@ -0,0 +1,54 @@
+require_relative 'node'
+
+module ConceptQL
+  module Nodes
+    # A SourceVocabularyNode is a superclass for a node 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 SourceVocabularyNode < Node
+      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 types
+        [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
+