dbee-active_record 2.1.0.pre.alpha.1 → 2.3.0

data/spec/db_helper.rb

@@ -106,6 +106,8 @@ def load_schema
       t.timestamps
     end
 
+    add_index :fields, %i[section key], unique: true
+
     create_table :patients do |t|
       t.column :first,  :string
       t.column :middle, :string
@@ -114,14 +116,16 @@ def load_schema
     end
 
     create_table :patient_field_values do |t|
-      t.column :patient_id, :integer
-      t.column :field_id,   :integer
+      t.column :patient_id, :integer, foreign_key: true
+      t.column :field_id,   :integer, foreign_key: true
       t.column :value,      :string
       t.timestamps
     end
 
+    add_index :patient_field_values, %i[patient_id field_id], unique: true
+
     create_table :patient_payments do |t|
-      t.column :patient_id, :integer
+      t.column :patient_id, :integer, foreign_key: true
       t.column :amount,     :decimal
       t.timestamps
     end

data/spec/dbee/providers/active_record_provider/expression_builder_spec.rb

@@ -0,0 +1,90 @@
+# 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.
+#
+
+require 'spec_helper'
+require 'db_helper'
+
+describe Dbee::Providers::ActiveRecordProvider::ExpressionBuilder do
+  let(:schema)      { Dbee::Schema.new(models['Patients']) }
+  let(:alias_maker) { Dbee::Providers::ActiveRecordProvider::SafeAliasMaker.new }
+
+  let(:empty_query) { Dbee::Query.make(from: :patients) }
+
+  let(:id_and_average_query) do
+    Dbee::Query.make(
+      from: :patients,
+      fields: [
+        {
+          key_path: :id,
+          display: 'ID #'
+        },
+        {
+          key_path: 'patient_payments.amount',
+          display: 'Ave Payment',
+          aggregator: :ave
+        }
+      ],
+      sorters: [
+        {
+          key_path: :id
+        }
+      ],
+      filters: [
+        {
+          key_path: :id,
+          value: 123
+        }
+      ]
+    )
+  end
+
+  let(:first_and_count_query) do
+    Dbee::Query.make(
+      from: :patients,
+      fields: [
+        {
+          key_path: :first,
+          display: 'First Name'
+        },
+        {
+          key_path: 'patient_payments.amount',
+          display: 'Number of Payments',
+          aggregator: :count
+        }
+      ]
+    )
+  end
+
+  subject { described_class.new(schema, alias_maker, alias_maker) }
+
+  before(:all) do
+    connect_to_db(:sqlite)
+  end
+
+  describe '#to_sql' do
+    specify 'when called with no fields, then called with fields removes star select' do
+      expect(subject.to_sql(empty_query)).to include('*')
+      expect(subject.to_sql(id_and_average_query)).not_to include('*')
+    end
+
+    context 'with aggregation' do
+      it 'generates the same sql when called multiple times' do
+        first_sql  = subject.to_sql(id_and_average_query)
+        second_sql = subject.to_sql(id_and_average_query)
+
+        expect(first_sql).to eq(second_sql)
+
+        third_sql  = subject.to_sql(first_and_count_query)
+        fourth_sql = subject.to_sql(first_and_count_query)
+
+        expect(third_sql).to eq(fourth_sql)
+      end
+    end
+  end
+end

data/spec/dbee/providers/active_record_provider/makers/where_spec.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-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.
+#
+
+require 'spec_helper'
+require 'db_helper'
+
+# rubocop:disable Layout/LineLength
+# Disable the line length cop beause there are some lengthy 'expected' SQL strings in spec which
+# cannot be shortened.
+describe Dbee::Providers::ActiveRecordProvider::Makers::Where do
+  before(:all) { connect_to_db(:sqlite) }
+
+  let(:subject) { described_class.instance }
+  let(:column) { Arel::Table.new(:test)[:foo] }
+
+  describe 'equals' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" = 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[("test"."foo" IS NULL OR "test"."foo" IN ('a', 'c'))]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: %w[a b c])
+      expect(subject.make(filter, column).to_sql).to eq %q["test"."foo" IN ('a', 'b', 'c')]
+    end
+  end
+
+  describe 'not equals' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" != 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NOT NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[("test"."foo" IS NOT NULL OR "test"."foo" NOT IN ('a', 'c'))]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: %w[a b c])
+      expect(subject.make(filter, column).to_sql).to eq %q["test"."foo" NOT IN ('a', 'b', 'c')]
+    end
+  end
+
+  describe 'contains' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" LIKE '%bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" LIKE '%a%') OR "test"."foo" LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" LIKE '%a%' OR "test"."foo" LIKE '%b%') OR "test"."foo" LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'not contains' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" NOT LIKE '%bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NOT NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NOT NULL OR "test"."foo" NOT LIKE '%a%') OR "test"."foo" NOT LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" NOT LIKE '%a%' OR "test"."foo" NOT LIKE '%b%') OR "test"."foo" NOT LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'starts with' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" LIKE 'bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" LIKE 'a%') OR "test"."foo" LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" LIKE 'a%' OR "test"."foo" LIKE 'b%') OR "test"."foo" LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'not start with' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" NOT LIKE 'bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NOT NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NOT NULL OR "test"."foo" NOT LIKE 'a%') OR "test"."foo" NOT LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" NOT LIKE 'a%' OR "test"."foo" NOT LIKE 'b%') OR "test"."foo" NOT LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'greater than' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" > 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" > 'a') OR "test"."foo" > 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" > 'a' OR "test"."foo" > 'b') OR "test"."foo" > 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'greater than or equal to' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" >= 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" >= 'a') OR "test"."foo" >= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" >= 'a' OR "test"."foo" >= 'b') OR "test"."foo" >= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'less than' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" < 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" < 'a') OR "test"."foo" < 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" < 'a' OR "test"."foo" < 'b') OR "test"."foo" < 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'less than or equal to' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" <= 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" <= 'a') OR "test"."foo" <= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" <= 'a' OR "test"."foo" <= 'b') OR "test"."foo" <= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+end
+# rubocop:enable Layout/LineLength

data/spec/dbee/providers/active_record_provider_spec.rb

@@ -11,22 +11,19 @@ require 'spec_helper'
 require 'db_helper'
 
 describe Dbee::Providers::ActiveRecordProvider do
-  let(:models) { yaml_fixture('models.yaml') }
-
   describe '#sql' do
     before(:all) do
       connect_to_db(:sqlite)
     end
 
     it 'errors when joining tables with no constraints' do
-      model_hash = {
-        name: :users,
-        models: [
-          { name: :logins }
-        ]
+      schema_hash = {
+        users: { relationships: { logins: nil } },
+        logins: nil
       }
 
       query_hash = {
+        from: :users,
         fields: [
           { key_path: 'id' },
           { key_path: 'logins.id' }
@@ -34,11 +31,11 @@ describe Dbee::Providers::ActiveRecordProvider do
       }
 
       query = Dbee::Query.make(query_hash)
-      model = Dbee::Model.make(model_hash)
+      schema = Dbee::Schema.new(schema_hash)
 
       error_class = Dbee::Providers::ActiveRecordProvider::ExpressionBuilder::MissingConstraintError
 
-      expect { described_class.new.sql(model, query) }.to raise_error(error_class)
+      expect { described_class.new.sql(schema, query) }.to raise_error(error_class)
     end
   end
 
@@ -57,12 +54,13 @@ describe Dbee::Providers::ActiveRecordProvider do
               yaml_fixture_files('active_record_snapshots').each_pair do |filename, snapshot|
                 specify File.basename(filename) do
                   model_name = snapshot['model_name']
+
                   query = Dbee::Query.make(snapshot['query'])
-                  model = Dbee::Model.make(models[model_name])
+                  schema = Dbee::Schema.new(models[model_name])
 
                   expected_5_sql  = snapshot[key].to_s.chomp.tr("\n", ' ')
                   expected_6_sql  = expected_5_sql.gsub('  ', ' ').gsub("'t'", '1').gsub("'f'", '0')
-                  actual_sql      = described_class.new(readable: readable).sql(model, query)
+                  actual_sql      = described_class.new(readable: readable).sql(schema, query)
 
                   error_msg = <<~ERROR_MSG
                     Expected 5 SQL: #{expected_5_sql}
@@ -95,9 +93,9 @@ describe Dbee::Providers::ActiveRecordProvider do
                 specify File.basename(filename) do
                   model_name = snapshot['model_name']
                   query = Dbee::Query.make(snapshot['query'])
-                  model = Dbee::Model.make(models[model_name])
+                  schema = Dbee::Schema.new(models[model_name])
 
-                  sql = described_class.new(readable: readable).sql(model, query)
+                  sql = described_class.new(readable: readable).sql(schema, query)
 
                   expect { ActiveRecord::Base.connection.execute(sql) }.to_not raise_error
                 end
@@ -128,10 +126,10 @@ describe Dbee::Providers::ActiveRecordProvider do
 
       let(:snapshot) { yaml_file_read(*snapshot_path) }
       let(:query)    { Dbee::Query.make(snapshot['query']) }
-      let(:model)    { Dbee::Model.make(models['Patients']) }
+      let(:schema)   { Dbee::Schema.new(models['Patients']) }
 
       it 'pivots table rows into columns' do
-        sql = described_class.new.sql(model, query)
+        sql = described_class.new.sql(schema, query)
 
         results = ActiveRecord::Base.connection.execute(sql)
 
@@ -173,11 +171,10 @@ describe Dbee::Providers::ActiveRecordProvider do
 
       let(:snapshot) { yaml_file_read(*snapshot_path) }
       let(:query)    { Dbee::Query.make(snapshot['query']) }
-      let(:model)    { Dbee::Model.make(models['Patients']) }
+      let(:schema) { Dbee::Schema.new(models['Patients']) }
 
       it 'executes correct SQL aggregate functions' do
-        sql = described_class.new.sql(model, query)
-
+        sql     = described_class.new.sql(schema, query)
         results = ActiveRecord::Base.connection.execute(sql)
 
         expect(results[0]).to include(

data/spec/fixtures/active_record_snapshots/five_table_query.yaml

@@ -1,5 +1,6 @@
 model_name: Theaters, Members, and Movies
 query:
+  from: theaters
   fields:
     - key_path: members.demos.phone_numbers.phone_number
       display: PHONE NUMBER

data/spec/fixtures/active_record_snapshots/multiple_same_table_query_with_static_constraints.yaml

@@ -1,5 +1,6 @@
 model_name: Theaters, Members, and Movies
 query:
+  from: theaters
   fields:
     - key_path: id
     - key_path: name

data/spec/fixtures/active_record_snapshots/one_table_empty_query.yaml

@@ -0,0 +1,11 @@
+model_name: Patients
+query:
+  from: patients
+sqlite_readable: |+
+  SELECT "patients".* FROM "patients" "patients"
+sqlite_not_readable: |+
+  SELECT "t0".* FROM "patients" "t0"
+mysql_readable: |+
+  SELECT `patients`.* FROM `patients` `patients`
+mysql_not_readable: |+
+  SELECT `t0`.* FROM `patients` `t0`

data/spec/fixtures/active_record_snapshots/one_table_query.yaml

@@ -1,5 +1,6 @@
 model_name: Theaters, Members, and Movies
 query:
+  from: theaters
   fields:
     - key_path: id
       display: 'ID #'

data/spec/fixtures/active_record_snapshots/one_table_query_with_ascending_sort.yaml

@@ -1,5 +1,6 @@
 model_name: Theaters, Members, and Movies
 query:
+  from: theaters
   fields:
     - key_path: id
     - key_path: name

data/spec/fixtures/active_record_snapshots/one_table_query_with_descending_sort.yaml

@@ -1,5 +1,6 @@
 model_name: Theaters, Members, and Movies
 query:
+  from: theaters
   fields:
     - key_path: id
     - key_path: name

data/spec/fixtures/active_record_snapshots/one_table_query_with_filters.yaml

@@ -1,5 +1,6 @@
 model_name: Theaters, Members, and Movies
 query:
+  from: theaters
   fields:
     - key_path: id
       display: 'ID #'

data/spec/fixtures/active_record_snapshots/one_table_query_with_limit.yaml

@@ -1,5 +1,6 @@
 model_name: Theaters, Members, and Movies
 query:
+  from: theaters
   fields:
     - key_path: id
     - key_path: name

data/spec/fixtures/active_record_snapshots/one_table_query_with_multiple_sorts.yaml

@@ -1,5 +1,6 @@
 model_name: Theaters, Members, and Movies
 query:
+  from: theaters
   fields:
     - key_path: id
     - key_path: name

data/spec/fixtures/active_record_snapshots/partitioner_example_1_query.yaml

@@ -1,5 +1,6 @@
 model_name: Partitioner Example 1
 query:
+  from: dogs
   fields:
     - key_path: id
 sqlite_readable: |+

data/spec/fixtures/active_record_snapshots/partitioner_example_2_query.yaml

@@ -1,5 +1,6 @@
 model_name: Partitioner Example 2
 query:
+  from: owners
   fields:
     - key_path: id
     - key_path: dogs.id

data/spec/fixtures/active_record_snapshots/reverse_polymorphic_query.yaml

@@ -1,5 +1,6 @@
 model_name: Reverse Polymorphic Example
 query:
+  from: animals
   fields:
     - key_path: id
     - key_path: type

data/spec/fixtures/active_record_snapshots/two_table_query.yaml

@@ -1,11 +1,13 @@
 model_name: Theaters, Members, and Movies
 query:
+  from: theaters
   fields:
     - key_path: id
     - key_path: name
     - key_path: members.id
     - key_path: members.account_number
   limit: 12
+  offset: 25
 sqlite_readable: |+
   SELECT
    "theaters"."id" AS 'id',
@@ -15,6 +17,7 @@ sqlite_readable: |+
   FROM "theaters" "theaters"
   LEFT OUTER JOIN "members" "members" ON "members"."tid" = "theaters"."id" AND "members"."partition" = "theaters"."partition"
   LIMIT 12
+  OFFSET 25
 sqlite_not_readable: |+
   SELECT
    "t0"."id" AS 'c0',
@@ -24,6 +27,7 @@ sqlite_not_readable: |+
   FROM "theaters" "t0"
   LEFT OUTER JOIN "members" "t1" ON "t1"."tid" = "t0"."id" AND "t1"."partition" = "t0"."partition"
   LIMIT 12
+  OFFSET 25
 mysql_readable: |+
   SELECT
    `theaters`.`id` AS 'id',
@@ -33,6 +37,7 @@ mysql_readable: |+
   FROM `theaters` `theaters`
   LEFT OUTER JOIN `members` `members` ON `members`.`tid` = `theaters`.`id` AND `members`.`partition` = `theaters`.`partition`
   LIMIT 12
+  OFFSET 25
 mysql_not_readable: |+
   SELECT
    `t0`.`id` AS 'c0',
@@ -42,3 +47,4 @@ mysql_not_readable: |+
   FROM `theaters` `t0`
   LEFT OUTER JOIN `members` `t1` ON `t1`.`tid` = `t0`.`id` AND `t1`.`partition` = `t0`.`partition`
   LIMIT 12
+  OFFSET 25

data/spec/fixtures/active_record_snapshots/two_table_query_with_aggregation.yaml

@@ -1,5 +1,6 @@
 model_name: Patients
 query:
+  from: patients
   fields:
     - key_path: id
       display: 'ID #'

data/spec/fixtures/active_record_snapshots/two_table_query_with_pivoting.yaml

@@ -1,5 +1,6 @@
 model_name: Patients
 query:
+  from: patients
   fields:
     - key_path: id
       display: 'ID #'