conceptql 0.2.0 → 0.4.0

data/lib/conceptql/behaviors/debuggable.rb

@@ -1,70 +0,0 @@
-require_relative '../behaviors/dottable'
-require_relative '../operators/operator'
-require_relative '../operators/binary_operator_operator'
-require 'csv'
-module ConceptQL
-  module Behaviors
-    module Debuggable
-      include Dottable
-      class ResultPrinter
-        attr :db, :dir, :type, :watch_ids, :operator
-        def initialize(db, dir, type, watch_ids, operator)
-          @db = db
-          @dir = dir
-          @type = type
-          @watch_ids = watch_ids
-          @operator = operator
-        end
-
-        def make_file
-          CSV.open(file_path, 'w') do |csv|
-            csv << ConceptQL::Operators::Operator::COLUMNS
-            results.each do |result|
-              csv << result
-            end
-          end
-          file_path
-        end
-
-        def file_path
-          @file_path ||= dir + file_name
-        end
-
-        def file_name
-          @file_name ||= [operator.operator_name, abbreviate(type)].join('_')
-        end
-
-        def results
-          q = operator.evaluate(db)
-            .from_self
-            .where(criterion_type: type.to_s)
-          unless watch_ids.empty?
-            q = q.where(person_id: watch_ids)
-          end
-
-          q.order([:person_id, :criterion_type, :start_date, :end_date, :criterion_id])
-            .select_map(ConceptQL::Operators::Operator::COLUMNS)
-        end
-
-        def abbreviate(type)
-          type.to_s.split('_').map(&:chars).map(&:first).join('')
-        end
-      end
-
-      def print_results(db, dir, watch_ids)
-        print_prep(db) if respond_to?(:print_prep)
-        kids = upstreams
-        if self.is_a?(ConceptQL::Operators::BinaryOperatorOperator)
-          kids = [left, right]
-        end
-        files = kids.map do |upstream|
-          upstream.print_results(db, dir, watch_ids)
-        end
-        files += types.map do |type|
-          ResultPrinter.new(db, dir, type, watch_ids, self).make_file
-        end
-      end
-    end
-  end
-end
-

data/lib/conceptql/behaviors/dottable.rb

@@ -1,103 +0,0 @@
-require 'facets/string/snakecase'
-require 'facets/string/titlecase'
-
-module ConceptQL
-  module Behaviors
-    module Dottable
-      @@counter = 0
-      TYPE_COLORS = {
-        person: 'blue',
-        visit_occurrence: 'orange',
-        condition_occurrence: 'red',
-        procedure_occurrence: 'green3',
-        procedure_cost: 'gold',
-        death: 'brown',
-        payer_plan_period: 'blue',
-        drug_exposure: 'purple',
-        observation: 'magenta',
-        misc: 'black'
-      }
-
-      def operator_number
-        @__operator_number ||= (@@counter += 1)
-      end
-
-      def reset_operator_number
-        @@counter = 0
-      end
-
-      def operator_name
-        @__operator_name ||= self.class.name.split('::').last.snakecase.gsub(/\W/, '_').downcase + "_#{operator_number}"
-      end
-
-      def display_name
-        @__display_name ||= begin
-          output = self.class.name.split('::').last.snakecase.titlecase
-          #output += " #{operator_number}"
-          output += ": #{arguments.join(', ')}" unless arguments.empty?
-          if output.length > 100
-            parts = output.split
-            output = parts.each_slice(output.length / parts.count).map do |subparts|
-              subparts.join(' ')
-            end.join ('\n')
-          end
-          output += "\n#{options.map{|k,v| "#{k}: #{v}"}.join("\n")}" unless options.nil? || options.empty?
-          output
-        end
-      end
-
-      def type_color(*types)
-        types.flatten!
-        types.length == 1 ? TYPE_COLORS[types.first] || 'black' : 'black'
-      end
-
-      def graph_operator(g)
-        @__graph_operator ||= begin
-          me = g.add_nodes(operator_name)
-          me[:label] = display_name
-          me[:color] = type_color(types)
-          me[:shape] = shape if respond_to?(:shape)
-          me
-        end
-      end
-
-      def link_to(g, dest_operator, db = nil)
-        edge_options = {}
-
-        types.each do |type|
-          if db
-            my_n = my_n(db, type)
-            label = [' rows=' + my_count(db, type).to_s + ' ']
-            label << ' n=' + my_n.to_s + ' '
-            edge_options[:label] = label.join("\n")
-            edge_options[:style] = 'dashed' if my_n.zero?
-          end
-          e = g.add_edges(graph_operator(g), dest_operator, edge_options)
-          e[:color] = type_color(type)
-        end
-      end
-
-      def graph_it(g, db)
-        graph_prep(db) if respond_to?(:graph_prep)
-        upstreams.each do |upstream|
-          upstream.graph_it(g, db)
-        end
-        operator = graph_operator(g)
-        upstreams.each do |upstream|
-          upstream.link_to(g, graph_operator(g), db)
-        end
-        operator
-      end
-
-      def my_count(db, type)
-        puts "counting #{operator_name} #{type}"
-        evaluate(db).from_self.where(criterion_type: type.to_s).count
-      end
-
-      def my_n(db, type)
-        evaluate(db).from_self.where(criterion_type: type.to_s).select_group(:person_id).count
-      end
-    end
-  end
-end
-

data/lib/conceptql/behaviors/preppable.rb

@@ -1,20 +0,0 @@
-module ConceptQL
-  module Behaviors
-    module Preppable
-      attr_accessor :prep_proc
-      def prep
-        prep_proc.call if prep_proc
-      end
-
-      def all(*args)
-        prep
-        super
-      end
-
-      def count(*args)
-        prep
-        super
-      end
-    end
-  end
-end

data/lib/conceptql/converter.rb

@@ -1,65 +0,0 @@
-require 'facets/array/extract_options'
-require 'facets/hash/deep_rekey'
-require 'facets/hash/update_values'
-
-module ConceptQL
-  class Converter
-    def convert(statement)
-      traverse(statement).to_list_syntax
-    end
-
-  private
-    class Operator
-      attr :type, :values, :options
-      def initialize(type, *values)
-        @type, @values = type, values.flatten
-        @options = @values.extract_options!.deep_rekey
-        @values = @values
-      end
-
-      def args
-        values.select { |s| !s.is_a?(Operator) }
-      end
-
-      def upstreams
-        values.select { |s| s.is_a?(Operator) }
-      end
-
-      def converted_options
-        options.update_values do |value|
-          if value.is_a?(Operator)
-            value.to_list_syntax
-          else
-            value
-          end
-        end
-      end
-
-      def to_list_syntax
-        stmt = [type]
-        stmt += args unless args.empty?
-        stmt += upstreams.map(&:to_list_syntax) unless upstreams.empty?
-        stmt << converted_options unless options.empty?
-        stmt
-      end
-    end
-
-    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 = Operator.new(type, values)
-        obj
-      when Array
-        obj.map { |value| traverse(value) }
-      else
-        obj
-      end
-    end
-  end
-end

data/lib/conceptql/debugger.rb

@@ -1,48 +0,0 @@
-require_relative 'tree'
-require_relative 'operators/operator'
-require_relative 'behaviors/debuggable'
-
-module ConceptQL
-  class Debugger
-    attr :statement, :db, :watch_ids
-    def initialize(statement, opts = {})
-      @statement = statement
-      @db = opts.fetch(:db, nil)
-      @tree = opts.fetch(:tree, Tree.new)
-      ConceptQL::Operators::Operator.send(:include, ConceptQL::Behaviors::Debuggable)
-      @watch_ids = opts.fetch(:watch_ids, [])
-      raise "Please specify one or more person_ids you'd like to debug" unless @watch_ids
-    end
-
-    def capture_results(path)
-      raise "Please specify path for debug file" unless path
-      Dir.mktmpdir do |dir|
-        dir = Pathname.new(dir)
-        operators = tree.root(self)
-        operators.first.reset_operator_number
-        csv_files = operators.map.with_index do |last_operator, index|
-          last_operator.print_results(db, dir, watch_ids)
-        end.flatten
-        system("csv2xlsx #{path} #{csv_files.join(' ')}")
-      end
-    end
-
-    private
-    attr :yaml, :tree, :db
-
-    def build_graph(g)
-      tree.root(self).each.with_index do |last_operator, index|
-        last_operator.graph_it(g, db)
-        if dangler
-          blank_operator = g.add_nodes("_#{index}")
-          blank_operator[:shape] = 'none'
-          blank_operator[:height] = 0
-          blank_operator[:label] = ''
-          blank_operator[:fixedsize] = true
-          last_operator.link_to(g, blank_operator, db)
-        end
-      end
-    end
-  end
-end
-

data/lib/conceptql/fake_grapher.rb

@@ -1,20 +0,0 @@
-require_relative 'graph'
-require_relative 'tree'
-require_relative 'graph_nodifier'
-
-module ConceptQL
-  class FakeGrapher
-    attr :options
-
-    def initialize(options = {})
-      @options = {
-        dangler: true,
-        tree: ConceptQL::Tree.new(nodifier: ConceptQL::GraphNodifier.new)
-      }.merge(options)
-    end
-
-    def graph_it(statement, output_file)
-      ConceptQL::Graph.new(statement, options).graph_it(output_file)
-    end
-  end
-end

data/lib/conceptql/graph.rb

@@ -1,52 +0,0 @@
-require 'psych'
-require 'graphviz'
-require_relative 'tree'
-require_relative 'operators/operator'
-require_relative 'behaviors/dottable'
-
-module ConceptQL
-  class Graph
-    attr :g, :file_path, :dangler, :title, :statement, :db, :suffix
-    def initialize(statement, opts = {})
-      @statement = statement
-      @db = opts.fetch(:db, nil)
-      @dangler = opts.fetch(:dangler, false)
-      @tree = opts.fetch(:tree, Tree.new)
-      @title = opts.fetch(:title, nil)
-      @suffix = opts.fetch(:suffix, 'pdf')
-      ConceptQL::Operators::Operator.send(:include, ConceptQL::Behaviors::Dottable)
-    end
-
-    def graph_it(file_path)
-      build_graph(g)
-      graph.output(suffix.to_sym =>  file_path + ".#{suffix}")
-    end
-
-    def graph
-      @graph ||= begin
-        opts = { type: :digraph }
-        opts[:label] = title if title
-        GraphViz.new(:G, opts)
-      end
-    end
-
-    private
-    attr :yaml, :tree, :db
-
-    def build_graph(g)
-      tree.root(self).each.with_index do |last_operator, index|
-        last_operator.build_temp_tables(db)
-        last_operator.graph_it(g, db)
-        if dangler
-          blank_operator = g.add_nodes("_#{index}")
-          blank_operator[:shape] = 'none'
-          blank_operator[:height] = 0
-          blank_operator[:label] = ''
-          blank_operator[:fixedsize] = true
-          last_operator.link_to(g, blank_operator, db)
-        end
-      end
-    end
-  end
-end
-

data/lib/conceptql/graph_nodifier.rb

@@ -1,203 +0,0 @@
-require_relative 'behaviors/dottable'
-require_relative 'operators/operator'
-
-module ConceptQL
-  class GraphNodifier
-    class DotOperator < ConceptQL::Operators::Operator
-      include ConceptQL::Behaviors::Dottable
-
-      TYPES = {
-        # Conditions
-        condition: :condition_occurrence,
-        primary_diagnosis: :condition_occurrence,
-        icd9: :condition_occurrence,
-        icd10: :condition_occurrence,
-        condition_type: :condition_occurrence,
-        medcode: :condition_occurrence,
-
-        # Procedures
-        procedure: :procedure_occurrence,
-        cpt: :procedure_occurrence,
-        drg: :procedure_occurrence,
-        hcpcs: :procedure_occurrence,
-        icd9_procedure: :procedure_occurrence,
-        procedure_cost: :procedure_cost,
-        medcode_procedure: :procedure_occurrence,
-
-        # Visits
-        visit_occurrence: :visit_occurrence,
-        place_of_service: :visit_occurrence,
-        place_of_service_code: :visit_occurrence,
-
-        # Person
-        person: :person,
-        gender: :person,
-        race: :person,
-
-        # Payer
-        payer: :payer_plan_period,
-
-        # Death
-        death: :death,
-
-        # Observation
-        loinc: :observation,
-        from_seer_visits: :observation,
-        to_seer_visits: :observation,
-
-        # Drug
-        drug_exposure: :drug_exposure,
-        rxnorm: :drug_exposure,
-        drug_cost: :drug_cost,
-        drug_type_concept_id: :drug_exposure,
-        drug_type_concept: :drug_exposure,
-        prodcode: :drug_exposure,
-
-        # Date Operators
-        date_range: :date,
-
-        # Miscelaneous operators
-        concept: :misc,
-        vsac: :misc
-      }
-
-      attr :values, :name
-      def initialize(name, values)
-        @name = name.to_s
-        super(values)
-      end
-
-      def display_name
-        @__display_name ||= begin
-          output = @name.dup
-          output += ": #{arguments.join(', ')}" unless arguments.empty?
-          if output.length > 100
-            parts = output.split
-            output = parts.each_slice(output.length / parts.count).map do |subparts|
-              subparts.join(' ')
-            end.join ('\n')
-          end
-          output += "\n#{options.map{|k,v| "#{k}: #{v}"}.join("\n")}" unless options.nil? || options.empty?
-          output
-        end
-      end
-
-      def types
-        types = [TYPES[name.to_sym] || upstreams.map(&:types)].flatten.uniq
-        types.empty? ? [:misc] : types
-      end
-    end
-
-    class BinaryOperatorOperator < DotOperator
-      def display_name
-        output = name
-        output += "\n#{displayable_options.map{|k,v| "#{k}: #{v}"}.join("\n")}"
-        output
-      end
-
-      def displayable_options
-        options.select{ |k,v| ![:left, :right].include?(k) } || {}
-      end
-
-      def left
-        options[:left]
-      end
-
-      def right
-        options[:right]
-      end
-
-      def graph_it(g, db)
-        left.graph_it(g, db)
-        right.graph_it(g, db)
-        cluster_name = "cluster_#{operator_name}"
-        me = g.send(cluster_name) do |sub|
-          sub[rank: 'same', label: display_name, color: 'black']
-          sub.send("#{cluster_name}_left").send('[]', shape: 'point', color: type_color(types))
-          sub.send("#{cluster_name}_right").send('[]', shape: 'point')
-        end
-        left.link_to(g, me.send("#{cluster_name}_left"))
-        right.link_to(g, me.send("#{cluster_name}_right"))
-        @__graph_operator = me.send("#{cluster_name}_left")
-      end
-
-      def types
-        left.types
-      end
-
-      def arguments
-        options.values
-      end
-    end
-
-    class LetOperator < DotOperator
-      def graph_it(g, db)
-        cluster_name = "cluster_#{operator_name}"
-        linkable = nil
-        g.send(cluster_name) do |sub|
-          linkable = upstreams.reverse.map do |upstream|
-            upstream.graph_it(sub, db)
-          end.first
-          sub[label: display_name, color: 'black']
-        end
-        @__graph_operator = linkable
-      end
-
-      def types
-        upstreams.last.types
-      end
-    end
-
-    class DefineOperator < DotOperator
-      def shape
-        :cds
-      end
-    end
-
-    class RecallOperator < DotOperator
-      def shape
-        :cds
-      end
-    end
-
-    class VsacOperator < DotOperator
-      def initialize(name, values, types)
-        @types = types
-        super(name, values)
-      end
-
-      def types
-        [ @types ].flatten.compact.map(&:to_sym)
-      end
-    end
-
-    BINARY_OPERATOR_TYPES = %w(before after meets met_by started_by starts contains during overlaps overlapped_by finished_by finishes coincides except person_filter less_than less_than_or_equal equal not_equal greater_than greater_than_or_equal filter).map { |temp| [temp, "not_#{temp}"] }.flatten.map(&:to_sym)
-
-    def temp_tables
-      @temp_tables ||= {}
-    end
-
-    def types
-      @types ||= {}
-    end
-
-    def create(type, values, tree)
-      operator = if BINARY_OPERATOR_TYPES.include?(type)
-        BinaryOperatorOperator.new(type, values)
-      elsif type == :let
-        LetOperator.new(type, values)
-      elsif type == :define
-        DefineOperator.new(type, values)
-      elsif type == :recall
-        RecallOperator.new(type, values)
-      elsif type == :vsac
-        types = values.pop
-        VsacOperator.new(type, values, types)
-      else
-        DotOperator.new(type, values)
-      end
-      operator.tree = self
-      operator
-    end
-  end
-end

data/lib/conceptql/logger.rb

@@ -1,10 +0,0 @@
-require 'logger'
-module ConceptQL
-  def self.logger
-    @logger ||= begin
-      l = Logger.new('/tmp/cql.log')
-      l.level = Logger::DEBUG
-      l
-    end
-  end
-end

data/lib/conceptql/operators/complement.rb

@@ -1,38 +0,0 @@
-require_relative 'pass_thru'
-
-module ConceptQL
-  module Operators
-    class Complement < PassThru
-      desc 'Splits up the incoming result set by type and passes through all results for each type that are NOT in the current set.'
-      allows_one_upstream
-      category 'Set Logic'
-
-      def query(db)
-        upstream = upstreams.first
-        upstream.types.map do |type|
-          positive_query = db.from(upstream.evaluate(db))
-            .select(:criterion_id)
-            .exclude(:criterion_id => nil)
-            .where(:criterion_type => type.to_s)
-          query = db.from(make_table_name(type))
-            .exclude(make_type_id(type) => positive_query)
-          db.from(select_it(query, type))
-        end.inject do |union_query, q|
-          union_query.union(q, all: true)
-        end
-      end
-
-
-      # This is an alternate, but equally accurate way to do complement.
-      # We'll need to benchmark which is faster.
-      def query2(db)
-        upstream = upstreams.first
-        froms = upstream.types.map do |type|
-          select_it(db.from(make_table_name(type)), type)
-        end
-        big_from = froms.inject { |union_query, q| union_query.union(q, all:true) }
-        db.from(big_from).except(upstream.evaluate(db))
-      end
-    end
-  end
-end

data/lib/conceptql/operators/concept.rb

@@ -1,70 +0,0 @@
-require_relative 'operator'
-require_relative '../query'
-
-module ConceptQL
-  module Operators
-    class Concept < Operator
-      desc 'Given the UUID of another ConceptQL statement, returns the results of that statement.'
-      attr :cql_query
-      def query(db)
-        set_cql_query(db)
-        db.from(cql_query.query.from_self)
-      end
-
-      def upstreams
-        @upstreams ||= cql_query.operators
-      end
-
-      def graph_prep(db)
-        set_cql_query(db)
-        puts statement.inspect
-        @arguments = [description(db)]
-      end
-
-      def print_prep(db)
-        set_cql_query(db)
-      end
-
-      def ensure_temp_tables(db)
-        set_cql_query(db)
-        super
-      end
-
-      def build_temp_tables(db)
-        set_cql_query(db)
-        super
-      end
-
-      private
-
-      def set_cql_query(db)
-        @cql_query ||= begin
-          set_statement(db)
-          Query.new(db, statement)
-        end
-      end
-
-      def statement
-        raise "Statement is nil!" unless @statement
-        @statement
-      end
-
-      def set_statement(db)
-        @statement ||= get_statement(db)
-      end
-
-      def get_statement(db)
-        concept = db[:concepts].where(concept_id: arguments.first).limit(1)
-        statement = concept.select_map(:statement).first.tap { |f| ConceptQL.logger.debug f.inspect }
-        statement = JSON.parse(statement) if statement.is_a?(String)
-        statement
-      end
-
-      def description(db)
-        @description ||= db[:concepts].where(concept_id: arguments.first).select_map(:label).first
-      end
-    end
-  end
-end
-
-