conceptql 0.2.0 → 0.4.0

data/lib/conceptql/window/table.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ConceptQL
+  module Window
+    # Provides a scope window based on the ConceptQL result set of another table
+    class Table < Base
+      def call(op, query, options = {})
+        l_table = Sequel[:l]
+        r_table = Sequel[:r]
+        r_start_date = apply_adjustments(op, r_table[:start_date], adjust_start)
+        r_end_date = apply_adjustments(op, r_table[:end_date], adjust_end)
+
+        exprs = []
+        exprs << Sequel.expr(l_table[:person_id] => r_table[:person_id])
+
+        query = Sequel[query] if query.is_a?(Symbol)
+
+        unless options[:timeless]
+          exprs << (r_start_date <= l_table[event_start_date_column])
+          exprs << (l_table[event_end_date_column] <= r_end_date)
+        end
+        expr = exprs.inject(&:&)
+
+        rhs = query.db[get_table_window(query)]
+
+        unless opts[:precalculated_window_id]
+          rhs = remove_window_id(rhs)
+          rhs = rhs
+                .select_group(:person_id, :start_date, :end_date)
+                .select_append do
+                  row_number.function.over(order: %i[person_id start_date end_date])
+                            .as(:window_id)
+                end
+        end
+
+        rhs = rhs.as(:r)
+
+        remove_window_id(query)
+          .from_self(alias: :l)
+          .join(rhs, expr)
+          .select_all(:l)
+          .select_append(r_table[:window_id])
+          .from_self
+      end
+
+      # The persons this window covers. An operator that runs a window
+      # function over a whole table filters on this first, because a database
+      # cannot push the window join (#call) below that function.
+      def person_ids(db)
+        db[get_table_window(nil)].select(:person_id)
+      end
+
+      def remove_window_id(ds)
+        cols = ds.opts[:select]
+        if cols && !cols.empty? && cols.any? { |c| !c.is_a?(Symbol) }
+          # When select has non-symbol expressions (e.g. CAST...AS),
+          # select_remove can't match them by symbol name, so filter manually
+          ds.select(*cols.reject { |c| window_id_column?(c) })
+        else
+          ds.select_remove(:window_id)
+        end
+      end
+
+      def window_id_column?(col)
+        case col
+        when Symbol
+          col == :window_id
+        when Sequel::SQL::AliasedExpression
+          col.alias == :window_id
+        when Sequel::SQL::QualifiedIdentifier
+          col.column == :window_id
+        else
+          false
+        end
+      end
+
+      def get_table_window(_query)
+        case table_window
+        when Array
+          cdb.query(table_window).query(force_temp_tables: false)
+        when String
+          tables = table_window.split(".")
+          tables.length == 2 ? Sequel.qualify(*tables) : Sequel.identifier(table_window)
+        when Symbol
+          Sequel[table_window]
+        else
+          table_window
+        end
+      end
+
+      def apply_adjustments(op, column, adjustment)
+        return column unless adjustment
+
+        DateAdjuster.new(op, adjustment).adjust(column)
+      end
+
+      def table_window
+        opts[:window_table]
+      end
+
+      def cdb
+        opts[:cdb]
+      end
+
+      def adjust_start
+        opts[:adjust_window_start]
+      end
+
+      def adjust_end
+        opts[:adjust_window_end]
+      end
+    end
+  end
+end

data/lib/conceptql/window.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "window/table"
+require_relative "window/date_range"
+
+module ConceptQL
+  # Provides a singleton method which will return a series of scope windows
+  # that should be applied to each selection operator in a ConceptQL statement
+  module Window
+    class << self
+      EVENT_DATE_COLUMNS = {
+        nil => %i[start_date start_date],
+        start_date: %i[start_date start_date],
+        end_date: %i[end_date end_date],
+        date_range: %i[start_date end_date]
+      }.freeze
+
+      def from(opts)
+        fetch_windows(prep_options(opts))
+      end
+
+      def fetch_windows(opts)
+        windows = []
+
+        windows << date_range_window(opts) if use_date_range?(opts)
+
+        windows << table_window(opts) if use_table_window?(opts)
+
+        windows << person_filter(opts) if use_person_filter?(opts)
+
+        windows
+      end
+
+      def use_date_range?(opts)
+        opts[:start_date] && opts[:end_date]
+      end
+
+      def use_table_window?(opts)
+        opts[:window_table]
+      end
+
+      def use_person_filter?(opts)
+        opts[:person_ids]
+      end
+
+      def date_range_window(opts)
+        DateRange.new(opts)
+      end
+
+      def person_filter(opts)
+        lambda do |_, ds, _options = {}|
+          ds.where(person_id: opts[:person_ids])
+        end
+      end
+
+      def table_window(opts)
+        Table.new(opts)
+      end
+
+      def prep_options(opts)
+        scope_by = opts.fetch(:scope_by, :start_date).to_sym
+        raise "Unknown scope_by value #{scope_by.inspect}" unless EVENT_DATE_COLUMNS.key?(scope_by)
+
+        start_col, end_col = *(EVENT_DATE_COLUMNS[scope_by])
+        opts.merge(
+          event_start_date_column: start_col,
+          event_end_date_column: end_col
+        )
+      end
+    end
+  end
+end

data/lib/conceptql.rb

@@ -1,7 +1,70 @@
+# frozen_string_literal: true
+
 require "conceptql/version"
-require "conceptql/logger"
+require "conceptql/paths"
+require "conceptql/utils"
+require "conceptql/operators/operator"
+require "conceptql/behaviors/code_lister"
+require "conceptql/behaviors/timeless"
+require "conceptql/behaviors/windowable"
+require "conceptql/behaviors/utilizable"
+require "conceptql/vocabularies/dynamic_vocabularies"
+require "conceptql/visitors/metadata_extractor"
 require "conceptql/query"
+require "conceptql/database"
+require "conceptql/data_model"
+require "conceptql/columnizer"
+require "conceptql/diagram"
+
+# byebug is only required during development
+begin
+  require "pry-byebug"
+rescue LoadError
+  nil
+end
+
+Dir.glob("#{File.dirname(__FILE__)}/../lib/conceptql/query_modifiers/**/*.rb").sort.each do |file|
+  require_relative file
+end
 
 module ConceptQL
-  # Your code goes here...
+  DEFAULT_DATA_MODEL = :gdm
+
+  def self.avoid_ctes?
+    ENV["CONCEPTQL_AVOID_CTES"] == "true"
+  end
+
+  def self.metadata(cdb, opts = {})
+    {
+      categories: categories,
+      operators: ConceptQL::Nodifier.new(cdb).to_metadata(opts)
+    }
+  end
+
+  def self.categories
+    [
+      "Select by Clinical Codes",
+      "Select by Property",
+      "Get Related Data",
+      "Modify Data",
+      "Combine Streams",
+      "Filter by Comparing",
+      "Filter Single Stream"
+    ].map.with_index do |name, priority|
+      { name: name, priority: priority }
+    end
+  end
+end
+
+# Require all built-in operator classes eagerly. Each registers itself in
+# ConceptQL::Operators.static_operators as its file loads.
+#
+# Vocabulary operators are not built here: each ConceptQL::Database builds its
+# own from config/vocabularies.csv and its own lexicon (Database#operators), so
+# loading the library touches no database.
+Dir.new("#{File.dirname(__FILE__)}/conceptql/operators")
+   .entries
+   .each do |filename|
+  require_relative "conceptql/operators/#{filename}" if filename =~ /\.rb\z/ && filename != File.basename(__FILE__)
 end
+ConceptQL::Operators.static_operators.each_value(&:freeze)

data/lib/sequel/extensions/pg_ctas_explain.rb

@@ -0,0 +1,22 @@
+# frozen-string-literal: true
+
+# Allows for EXPLAIN ANALYZE to be run on a CTAS statement
+module Sequel
+  # Module that overrides #create_table_as and #create_table_as_sql
+  module PgCtasExplain
+    def create_table_as(name, sql, options)
+      return super unless options[:explain]
+
+      sql = sql.sql if sql.is_a?(Sequel::Dataset)
+      explain(create_table_as_sql(name, sql, options), options)
+    end
+
+    def explain(sql, options = {})
+      operations = [ "EXPLAIN" ]
+      operations << "ANALYZE" if options[:analyze]
+      log_info(fetch("#{operations.join(' ')} #{sql}").map(:'QUERY PLAN').join("\r\n"))
+    end
+  end
+
+  Database.register_extension(:pg_ctas_explain, PgCtasExplain)
+end

data/lib/sequel/extensions/pg_vacuum_table.rb

@@ -0,0 +1,23 @@
+# frozen-string-literal: true
+
+# Adds DB#vacuum_table method
+module Sequel
+  # Adds DB#vacuum_table method
+  module PgVacuumTable
+    def vacuum_table(table_name, opts = {})
+      run(vacuum_table_sql(table_name, opts))
+    end
+
+    def vacuum_table_sql(table_name, opts)
+      dataset.with_sql(vacuum_operations(opts).join(" "), table_name).sql
+    end
+
+    def vacuum_operations(opts)
+      operations = [ "VACUUM" ]
+      operations << "ANALYZE" if opts[:analyze]
+      operations << "?"
+    end
+  end
+
+  Database.register_extension(:pg_vacuum_table, PgVacuumTable)
+end