dbee-active_record 2.0.0 → 2.1.0.pre.alpha

data/lib/dbee/providers/active_record_provider/expression_builder/where.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Dbee
+  module Providers
+    class ActiveRecordProvider
+      class ExpressionBuilder
+        # Derives Arel#where predicates.
+        class Where
+          include Singleton
+
+          def make(filter, arel_column)
+            values = normalize(filter.value)
+
+            if filter.is_a?(Query::Filters::Equals) && values.length > 1
+              arel_column.in(values)
+            elsif filter.is_a?(Query::Filters::NotEquals) && values.length > 1
+              arel_column.not_in(values)
+            else
+              use_or(filter, arel_column)
+            end
+          end
+
+          private
+
+          FILTER_EVALUATORS = {
+            Query::Filters::Contains => ->(node, val) { node.matches("%#{val}%") },
+            Query::Filters::Equals => ->(node, val) { node.eq(val) },
+            Query::Filters::GreaterThan => ->(node, val) { node.gt(val) },
+            Query::Filters::GreaterThanOrEqualTo => ->(node, val) { node.gteq(val) },
+            Query::Filters::LessThan => ->(node, val) { node.lt(val) },
+            Query::Filters::LessThanOrEqualTo => ->(node, val) { node.lteq(val) },
+            Query::Filters::NotContain => ->(node, val) { node.does_not_match("%#{val}%") },
+            Query::Filters::NotEquals => ->(node, val) { node.not_eq(val) },
+            Query::Filters::NotStartWith => ->(node, val) { node.does_not_match("#{val}%") },
+            Query::Filters::StartsWith => ->(node, val) { node.matches("#{val}%") }
+          }.freeze
+
+          private_constant :FILTER_EVALUATORS
+
+          def normalize(value)
+            value ? Array(value).flatten : [nil]
+          end
+
+          def use_or(filter, arel_column)
+            predicates = normalize(filter.value).map do |coerced_value|
+              method = FILTER_EVALUATORS[filter.class]
+
+              raise ArgumentError, "cannot compile filter: #{filter}" unless method
+
+              method.call(arel_column, coerced_value)
+            end
+
+            predicates.inject(predicates.shift) do |memo, predicate|
+              memo.or(predicate)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dbee/providers/active_record_provider/version.rb

@@ -10,7 +10,7 @@
 module Dbee
   module Providers
     class ActiveRecordProvider
-      VERSION = '2.0.0'
+      VERSION = '2.1.0-alpha'
     end
   end
 end

data/spec/db_helper.rb

@@ -10,6 +10,27 @@
 # Enable logging using something like:
 # ActiveRecord::Base.logger = Logger.new(STDERR)
 
+class Field < ActiveRecord::Base
+  has_many :patient_field_values
+end
+
+class Patient < ActiveRecord::Base
+  has_many :patient_field_values
+  has_many :patient_payments
+
+  accepts_nested_attributes_for :patient_field_values
+  accepts_nested_attributes_for :patient_payments
+end
+
+class PatientFieldValue < ActiveRecord::Base
+  belongs_to :patient
+  belongs_to :field
+end
+
+class PatientPayment < ActiveRecord::Base
+  belongs_to :patient
+end
+
 def connect_to_db(name)
   config = yaml_file_read('spec', 'config', 'database.yaml')[name.to_s]
   ActiveRecord::Base.establish_connection(config)
@@ -17,39 +38,40 @@ end
 
 def load_schema
   ActiveRecord::Schema.define do
+    # Movie Theater Schema
     create_table :theaters do |t|
-      t.column :name, :string
+      t.column :name,      :string
       t.column :partition, :string
-      t.column :active, :boolean
+      t.column :active,    :boolean
       t.column :inspected, :boolean
       t.timestamps
     end
 
     create_table :members do |t|
-      t.column :tid, :integer
+      t.column :tid,            :integer
       t.column :account_number, :string
-      t.column :partition, :string
+      t.column :partition,      :string
       t.timestamps
     end
 
     create_table :demographics do |t|
       t.column :member_id, :integer
-      t.column :name, :string
+      t.column :name,      :string
       t.timestamps
     end
 
     create_table :phone_numbers do |t|
       t.column :demographic_id, :integer
-      t.column :phone_type, :string
-      t.column :phone_number, :string
+      t.column :phone_type,     :string
+      t.column :phone_number,   :string
       t.timestamps
     end
 
     create_table :movies do |t|
       t.column :member_id, :integer
-      t.column :name, :string
-      t.column :genre, :string
-      t.column :favorite, :boolean, default: false, null: false
+      t.column :name,      :string
+      t.column :genre,     :string
+      t.column :favorite,  :boolean, default: false, null: false
       t.timestamps
     end
 
@@ -60,10 +82,10 @@ def load_schema
 
     create_table :animals do |t|
       t.column :owner_id, :integer
-      t.column :toy_id, :integer
-      t.column :type, :string
-      t.column :name, :string
-      t.column :deleted, :boolean
+      t.column :toy_id,   :integer
+      t.column :type,     :string
+      t.column :name,     :string
+      t.column :deleted,  :boolean
       t.timestamps
     end
 
@@ -76,5 +98,99 @@ def load_schema
       t.column :laser, :boolean
       t.timestamps
     end
+
+    # Patient Schema
+    create_table :fields do |t|
+      t.column :section, :string
+      t.column :key,     :string
+      t.timestamps
+    end
+
+    create_table :patients do |t|
+      t.column :first,  :string
+      t.column :middle, :string
+      t.column :last,   :string
+      t.timestamps
+    end
+
+    create_table :patient_field_values do |t|
+      t.column :patient_id, :integer
+      t.column :field_id,   :integer
+      t.column :value,      :string
+      t.timestamps
+    end
+
+    create_table :patient_payments do |t|
+      t.column :patient_id, :integer
+      t.column :amount,     :decimal
+      t.timestamps
+    end
   end
 end
+
+def load_data
+  demo_dob_field              = Field.create!(section: 'demographics', key: 'dob')
+  demo_drivers_license_field  = Field.create!(section: 'demographics', key: 'drivers_license')
+  demo_notes_field            = Field.create!(section: 'demographics', key: 'notes')
+
+  contact_phone_number_field  = Field.create!(section: 'contact', key: 'phone_number')
+  contact_notes_field         = Field.create!(section: 'contact', key: 'notes')
+
+  Patient.create!(
+    first: 'Bozo',
+    middle: 'The',
+    last: 'Clown',
+    patient_field_values_attributes: [
+      {
+        field: demo_dob_field,
+        value: '1904-04-04'
+      },
+      {
+        field: demo_notes_field,
+        value: 'The patient is funny!'
+      },
+      {
+        field: demo_drivers_license_field,
+        value: '82-54-hut-hut-hike!'
+      },
+      {
+        field: contact_phone_number_field,
+        value: '555-555-5555'
+      },
+      {
+        field: contact_notes_field,
+        value: 'Do not call this patient at night!'
+      }
+    ],
+    patient_payments_attributes: [
+      { amount: 5 },
+      { amount: 10 },
+      { amount: 15 }
+    ]
+  )
+
+  Patient.create!(
+    first: 'Frank',
+    last: 'Rizzo',
+    patient_payments_attributes: [
+      { amount: 50 },
+      { amount: 150 }
+    ]
+  )
+
+  Patient.create!(
+    first: 'Bugs',
+    middle: 'The',
+    last: 'Bunny',
+    patient_field_values_attributes: [
+      {
+        field: demo_dob_field,
+        value: '2040-01-01'
+      },
+      {
+        field: contact_notes_field,
+        value: 'Call anytime!!'
+      }
+    ]
+  )
+end

data/spec/dbee/providers/active_record_provider_spec.rb

@@ -79,7 +79,7 @@ describe Dbee::Providers::ActiveRecordProvider do
       end
     end
 
-    context 'Executing SQL' do
+    context 'Shallow SQL Execution' do
       %w[sqlite].each do |dbms|
         context dbms do
           before(:all) do
@@ -108,4 +108,105 @@ describe Dbee::Providers::ActiveRecordProvider do
       end
     end
   end
+
+  describe 'Deep SQL execution' do
+    before(:all) do
+      connect_to_db(:sqlite)
+      load_schema
+      load_data
+    end
+
+    describe 'pivoting' do
+      let(:snapshot_path) do
+        %w[
+          spec
+          fixtures
+          active_record_snapshots
+          two_table_query_with_pivoting.yaml
+        ]
+      end
+
+      let(:snapshot) { yaml_file_read(*snapshot_path) }
+      let(:query)    { Dbee::Query.make(snapshot['query']) }
+      let(:model)    { Dbee::Model.make(models['Patients']) }
+
+      it 'pivots table rows into columns' do
+        sql = described_class.new.sql(model, query)
+
+        results = ActiveRecord::Base.connection.execute(sql)
+
+        expect(results[0]).to include(
+          'First Name' => 'Bozo',
+          'Date of Birth' => '1904-04-04',
+          'Drivers License #' => '82-54-hut-hut-hike!',
+          'Demographic Notes' => 'The patient is funny!',
+          'Contact Notes' => 'Do not call this patient at night!'
+        )
+
+        expect(results[1]).to include(
+          'First Name' => 'Frank',
+          'Date of Birth' => nil,
+          'Drivers License #' => nil,
+          'Demographic Notes' => nil,
+          'Contact Notes' => nil
+        )
+
+        expect(results[2]).to include(
+          'First Name' => 'Bugs',
+          'Date of Birth' => '2040-01-01',
+          'Drivers License #' => nil,
+          'Demographic Notes' => nil,
+          'Contact Notes' => 'Call anytime!!'
+        )
+      end
+    end
+
+    describe 'aggregation' do
+      let(:snapshot_path) do
+        %w[
+          spec
+          fixtures
+          active_record_snapshots
+          two_table_query_with_aggregation.yaml
+        ]
+      end
+
+      let(:snapshot) { yaml_file_read(*snapshot_path) }
+      let(:query)    { Dbee::Query.make(snapshot['query']) }
+      let(:model)    { Dbee::Model.make(models['Patients']) }
+
+      it 'executes correct SQL aggregate functions' do
+        sql = described_class.new.sql(model, query)
+
+        results = ActiveRecord::Base.connection.execute(sql)
+
+        expect(results[0]).to include(
+          'First Name' => 'Bozo',
+          'Ave Payment' => 10,
+          'Number of Payments' => 3,
+          'Max Payment' => 15,
+          'Min Payment' => 5,
+          'Total Paid' => 30
+        )
+
+        expect(results[1]).to include(
+          'First Name' => 'Frank',
+          'Ave Payment' => 100,
+          'Number of Payments' => 2,
+          'Max Payment' => 150,
+          'Min Payment' => 50,
+          'Total Paid' => 200
+        )
+
+        expect(results[2]).to include(
+          'First Name' => 'Bugs',
+          'Ave Payment' => nil,
+          'Number of Payments' => 0,
+          'Max Payment' => nil,
+          'Min Payment' => nil,
+          'Total Paid' => nil
+        )
+      end
+    end
+  end
 end

data/spec/fixtures/active_record_snapshots/one_table_query_with_filters.yaml

@@ -45,6 +45,10 @@ query:
         - 'Netflix'
         - 'Hulu'
       key_path: name
+    - type: not_equals
+      value:
+        - 'YouTube Super Video'
+      key_path: name
     - type: not_contain
       value:
         - 'tfli'
@@ -59,67 +63,71 @@ sqlite_readable: |+
   SELECT "theaters"."id" AS 'ID #',
   "theaters"."name" AS 'name'
   FROM "theaters" "theaters"
-  WHERE ("theaters"."name" = 'AMC' OR "theaters"."name" = 'Regal') AND
+  WHERE "theaters"."name" IN ('AMC', 'Regal') AND
   "theaters"."name" LIKE 'A%' AND
   "theaters"."name" LIKE '%m%' AND
   "theaters"."active" = 'false' AND
-  (("theaters"."active" = 't' OR "theaters"."active" = 'f') OR "theaters"."active" IS NULL) AND
-  (("theaters"."inspected" = 'f' OR "theaters"."inspected" = 't') OR "theaters"."inspected" IS NULL) AND
+  "theaters"."active" IN ('t', 'f', NULL) AND
+  "theaters"."inspected" IN ('f', 't', NULL) AND
   "theaters"."created_at" <= '2019-03-04' AND
   "theaters"."created_at" < '2018-03-04' AND
   "theaters"."created_at" >= '2001-03-04' AND
   "theaters"."created_at" > '2002-03-04' AND
-  ("theaters"."name" != 'Netflix' OR "theaters"."name" != 'Hulu') AND
+  "theaters"."name" NOT IN ('Netflix', 'Hulu') AND
+  "theaters"."name" != 'YouTube Super Video' AND
   ("theaters"."name" NOT LIKE '%tfli%' OR "theaters"."name" NOT LIKE '%ul%') AND
   ("theaters"."name" NOT LIKE 'netf%' OR "theaters"."name" NOT LIKE 'hu%')
 sqlite_not_readable: |+
   SELECT "t0"."id" AS 'c0',
   "t0"."name" AS 'c1'
   FROM "theaters" "t0"
-  WHERE ("t0"."name" = 'AMC' OR "t0"."name" = 'Regal') AND
+  WHERE "t0"."name" IN ('AMC', 'Regal') AND
   "t0"."name" LIKE 'A%' AND
   "t0"."name" LIKE '%m%' AND
   "t0"."active" = 'false' AND
-  (("t0"."active" = 't' OR "t0"."active" = 'f') OR "t0"."active" IS NULL) AND
-  (("t0"."inspected" = 'f' OR "t0"."inspected" = 't') OR "t0"."inspected" IS NULL) AND
+  "t0"."active" IN ('t', 'f', NULL) AND
+  "t0"."inspected" IN ('f', 't', NULL) AND
   "t0"."created_at" <= '2019-03-04' AND
   "t0"."created_at" < '2018-03-04' AND
   "t0"."created_at" >= '2001-03-04' AND
   "t0"."created_at" > '2002-03-04' AND
-  ("t0"."name" != 'Netflix' OR "t0"."name" != 'Hulu') AND
+  "t0"."name" NOT IN ('Netflix', 'Hulu') AND
+  "t0"."name" != 'YouTube Super Video' AND
   ("t0"."name" NOT LIKE '%tfli%' OR "t0"."name" NOT LIKE '%ul%') AND
   ("t0"."name" NOT LIKE 'netf%' OR "t0"."name" NOT LIKE 'hu%')
 mysql_readable: |+
   SELECT `theaters`.`id` AS 'ID #',
   `theaters`.`name` AS 'name'
   FROM `theaters` `theaters`
-  WHERE (`theaters`.`name` = 'AMC' OR `theaters`.`name` = 'Regal') AND
+  WHERE `theaters`.`name` IN ('AMC', 'Regal') AND
   `theaters`.`name` LIKE 'A%' AND
   `theaters`.`name` LIKE '%m%' AND
   `theaters`.`active` = 'false' AND
-  ((`theaters`.`active` = TRUE OR `theaters`.`active` = FALSE) OR `theaters`.`active` IS NULL) AND
-  ((`theaters`.`inspected` = FALSE OR `theaters`.`inspected` = TRUE) OR `theaters`.`inspected` IS NULL) AND
+  `theaters`.`active` IN (TRUE, FALSE, NULL) AND
+  `theaters`.`inspected` IN (FALSE, TRUE, NULL) AND
   `theaters`.`created_at` <= '2019-03-04' AND
   `theaters`.`created_at` < '2018-03-04' AND
   `theaters`.`created_at` >= '2001-03-04' AND
   `theaters`.`created_at` > '2002-03-04' AND
-  (`theaters`.`name` != 'Netflix' OR `theaters`.`name` != 'Hulu') AND
+  `theaters`.`name` NOT IN ('Netflix', 'Hulu') AND
+  `theaters`.`name` != 'YouTube Super Video' AND
   (`theaters`.`name` NOT LIKE '%tfli%' OR `theaters`.`name` NOT LIKE '%ul%') AND
   (`theaters`.`name` NOT LIKE 'netf%' OR `theaters`.`name` NOT LIKE 'hu%')
 mysql_not_readable: |+
   SELECT `t0`.`id` AS 'c0',
   `t0`.`name` AS 'c1'
   FROM `theaters` `t0`
-  WHERE (`t0`.`name` = 'AMC' OR `t0`.`name` = 'Regal') AND
+  WHERE `t0`.`name` IN ('AMC', 'Regal') AND
   `t0`.`name` LIKE 'A%' AND
   `t0`.`name` LIKE '%m%' AND
   `t0`.`active` = 'false' AND
-  ((`t0`.`active` = TRUE OR `t0`.`active` = FALSE) OR `t0`.`active` IS NULL) AND
-  ((`t0`.`inspected` = FALSE OR `t0`.`inspected` = TRUE) OR `t0`.`inspected` IS NULL) AND
+  `t0`.`active` IN (TRUE, FALSE, NULL) AND
+  `t0`.`inspected` IN (FALSE, TRUE, NULL) AND
   `t0`.`created_at` <= '2019-03-04' AND
   `t0`.`created_at` < '2018-03-04' AND
   `t0`.`created_at` >= '2001-03-04' AND
   `t0`.`created_at` > '2002-03-04' AND
-  (`t0`.`name` != 'Netflix' OR `t0`.`name` != 'Hulu') AND
+  `t0`.`name` NOT IN ('Netflix', 'Hulu') AND
+  `t0`.`name` != 'YouTube Super Video' AND
   (`t0`.`name` NOT LIKE '%tfli%' OR `t0`.`name` NOT LIKE '%ul%') AND
   (`t0`.`name` NOT LIKE 'netf%' OR `t0`.`name` NOT LIKE 'hu%')