torque-postgresql 1.1.5 → 2.0.3

data/spec/factories/texts.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :text do
+    content { Faker::Lorem.sentence }
+  end
+end

data/spec/factories/users.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :user do
+    name { Faker::Name.name }
+    role { 'visitor' }
+  end
+end

data/spec/factories/videos.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :video do
+    title { Faker::Lorem.sentence }
+  end
+end

data/spec/mocks/cache_query.rb

@@ -0,0 +1,16 @@
+module Mocks
+  module CacheQuery
+    def get_last_executed_query(&block)
+      conn = ActiveRecord::Base.connection
+      conn.instance_variable_set(:@query_cache_enabled, true)
+
+      block.call
+      result = conn.query_cache.keys.first
+
+      conn.instance_variable_set(:@query_cache_enabled, false)
+      conn.instance_variable_get(:@query_cache).delete(result)
+
+      result
+    end
+  end
+end

data/spec/mocks/create_table.rb

@@ -0,0 +1,35 @@
+module Mocks
+  module CreateTable
+    def mock_create_table
+      path = ActiveRecord::Base.connection.method(:create_table).super_method.source_location[0]
+
+      before :all do
+        ActiveRecord::ConnectionAdapters::SchemaStatements.send(:define_method, :create_table) do |table_name, **options, &block|
+          td = create_table_definition(table_name, **options)
+
+          # Does things as the same as schema statements
+          if options[:id] != false && !options[:as]
+            pk = options.fetch(:primary_key) do
+              ActiveRecord::Base.get_primary_key table_name.to_s.singularize
+            end
+
+            if pk.is_a?(Array)
+              td.primary_keys pk
+            else
+              td.primary_key pk, options.fetch(:id, :primary_key), **options
+            end
+          end
+
+          block.call(td) if block.present?
+
+          # Now generate the SQL and return it
+          schema_creation.accept td
+        end
+      end
+
+      after :all do
+        load path
+      end
+    end
+  end
+end

data/spec/models/activity.rb

@@ -0,0 +1,3 @@
+class Activity < ActiveRecord::Base
+  belongs_to :author
+end

data/spec/models/activity_book.rb

@@ -0,0 +1,4 @@
+require_relative 'activity'
+
+class ActivityBook < Activity
+end

data/spec/models/activity_post.rb

@@ -0,0 +1,7 @@
+require_relative 'activity'
+
+class ActivityPost < Activity
+  belongs_to :post
+end
+
+require_relative 'activity_post/sample'

data/spec/models/activity_post/sample.rb

@@ -0,0 +1,4 @@
+class ActivityPost < Activity
+  class Sample < ActivityPost
+  end
+end

data/spec/models/author.rb

@@ -0,0 +1,4 @@
+class Author < ActiveRecord::Base
+  has_many :activities, -> { cast_records }
+  has_many :posts
+end

data/spec/models/author_journalist.rb

@@ -0,0 +1,4 @@
+require_relative 'author'
+
+class AuthorJournalist < Author
+end

data/spec/models/comment.rb

@@ -0,0 +1,3 @@
+class Comment < ActiveRecord::Base
+  belongs_to :user
+end

data/spec/models/course.rb

@@ -0,0 +1,2 @@
+class Course < ActiveRecord::Base
+end

data/spec/models/geometry.rb

@@ -0,0 +1,2 @@
+class Geometry < ActiveRecord::Base
+end

data/spec/models/guest_comment.rb

@@ -0,0 +1,4 @@
+require_relative 'comment'
+
+class GuestComment < Comment
+end

data/spec/models/post.rb

@@ -0,0 +1,6 @@
+class Post < ActiveRecord::Base
+  belongs_to :author
+  belongs_to :activity
+
+  scope :test_scope, -> { where('1=1') }
+end

data/spec/models/tag.rb

@@ -0,0 +1,2 @@
+class Tag < ActiveRecord::Base
+end

data/spec/models/text.rb

@@ -0,0 +1,2 @@
+class Text < ActiveRecord::Base
+end

data/spec/models/time_keeper.rb

@@ -0,0 +1,2 @@
+class TimeKeeper < ActiveRecord::Base
+end

data/spec/models/user.rb

@@ -0,0 +1,8 @@
+class User < ActiveRecord::Base
+  has_many :comments
+
+  auxiliary_statement :last_comment do |cte|
+    cte.query Comment.distinct_on(:user_id).order(:user_id, id: :desc)
+    cte.attributes id: :comment_id, content: :comment_content
+  end
+end

data/spec/models/video.rb

@@ -0,0 +1,2 @@
+class Video < ActiveRecord::Base
+end

data/spec/schema.rb

@@ -0,0 +1,141 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended that you check this file into your version control system.
+
+begin
+  version = 61
+
+  raise SystemExit if ActiveRecord::Migrator.current_version == version
+  ActiveRecord::Schema.define(version: version) do
+    self.verbose = false
+
+    # These are extensions that must be enabled in order to support this database
+    enable_extension "plpgsql"
+
+    # These are user-defined types used on this database
+    create_enum "content_status", ["created", "draft", "published", "archived"], force: :cascade
+    create_enum "specialties", ["books", "movies", "plays"], force: :cascade
+    create_enum "roles", ["visitor", "assistant", "manager", "admin"], force: :cascade
+    create_enum "conflicts", ["valid", "invalid", "untrusted"], force: :cascade
+    create_enum "types", ["A", "B", "C", "D"], force: :cascade
+
+    create_table "geometries", force: :cascade do |t|
+      t.point   "point"
+      t.line    "line"
+      t.lseg    "lseg"
+      t.box     "box"
+      t.path    "closed_path"
+      t.path    "open_path"
+      t.polygon "polygon"
+      t.circle  "circle"
+    end
+
+    create_table "time_keepers", force: :cascade do |t|
+      t.daterange "available"
+      t.tsrange   "period"
+      t.tstzrange "tzperiod"
+      t.interval  "th"
+    end
+
+    create_table "tags", force: :cascade do |t|
+      t.string "name"
+    end
+
+    create_table "videos", force: :cascade do |t|
+      t.bigint   "tag_ids", array: true
+      t.string   "title"
+      t.string   "url"
+      t.enum     "type", subtype: :types
+      t.enum     "conflicts", subtype: :conflicts, array: true
+      t.datetime "created_at", null: false
+      t.datetime "updated_at", null: false
+    end
+
+    create_table "authors", force: :cascade do |t|
+      t.string   "name"
+      t.string   "type"
+      t.enum     "specialty", subtype: :specialties
+    end
+
+    create_table "texts", force: :cascade do |t|
+      t.integer  "user_id"
+      t.string   "content"
+      t.enum     "conflict",  subtype: :conflicts
+    end
+
+    create_table "comments", force: :cascade do |t|
+      t.integer "user_id",    null: false
+      t.integer "comment_id"
+      t.text    "content",    null: false
+      t.string  "kind"
+      t.index ["user_id"], name: "index_comments_on_user_id", using: :btree
+      t.index ["comment_id"], name: "index_comments_on_comment_id", using: :btree
+    end
+
+    create_table "courses", force: :cascade do |t|
+      t.string   "title",      null: false
+      t.interval "duration"
+      t.enum     "types", subtype: :types, array: true, default: [:A, :B]
+      t.datetime "created_at", null: false
+      t.datetime "updated_at", null: false
+    end
+
+    create_table "images", force: :cascade, id: false do |t|
+      t.string "file"
+    end
+
+    create_table "posts", force: :cascade do |t|
+      t.integer  "author_id"
+      t.integer  "activity_id"
+      t.string   "title"
+      t.text     "content"
+      t.enum     "status",    subtype: :content_status
+      t.index ["author_id"], name: "index_posts_on_author_id", using: :btree
+    end
+
+    create_table "users", force: :cascade do |t|
+      t.string   "name",       null: false
+      t.enum     "role",                    subtype: :roles, default: :visitor
+      t.datetime "created_at", null: false
+      t.datetime "updated_at", null: false
+    end
+
+    create_table "activities", force: :cascade do |t|
+      t.integer  "author_id"
+      t.string   "title"
+      t.boolean  "active"
+      t.enum     "kind",                    subtype: :types
+      t.datetime "created_at", null: false
+      t.datetime "updated_at", null: false
+    end
+
+    create_table "activity_books", force: :cascade, inherits: :activities do |t|
+      t.text     "description"
+      t.string   "url"
+      t.boolean  "activated"
+    end
+
+    create_table "activity_posts", force: :cascade, inherits: [:activities, :images] do |t|
+      t.integer  "post_id"
+      t.string   "url"
+      t.integer  "activated"
+    end
+
+    create_table "activity_post_samples", force: :cascade, inherits: :activity_posts
+
+    # create_table "activity_blanks", force: :cascade, inherits: :activities
+
+    # create_table "activity_images", force: :cascade, inherits: [:activities, :images]
+
+    add_foreign_key "posts", "authors"
+  end
+rescue SystemExit
+end

data/spec/spec_helper.rb

@@ -0,0 +1,59 @@
+require 'torque-postgresql'
+require 'database_cleaner'
+require 'factory_bot'
+require 'dotenv'
+require 'faker'
+require 'rspec'
+require 'byebug'
+
+Dotenv.load
+
+ActiveRecord::Base.establish_connection(ENV['DATABASE_URL'])
+cache = ActiveRecord::Base.connection.schema_cache
+
+cleaner = ->() do
+  cache.instance_variable_set(:@inheritance_loaded, false)
+  cache.instance_variable_set(:@inheritance_dependencies, {})
+  cache.instance_variable_set(:@inheritance_associations, {})
+end
+
+load File.join('schema.rb')
+Dir.glob(File.join('spec', '{models,factories,mocks}', '*.rb')) do |file|
+  require file[5..-4]
+end
+
+cleaner.call
+I18n.load_path << Pathname.pwd.join('spec', 'en.yml')
+RSpec.configure do |config|
+  config.extend Mocks::CreateTable
+  config.include Mocks::CacheQuery
+
+  config.formatter = :documentation
+  config.color     = true
+  config.tty       = true
+
+  # Handles acton before rspec initialize
+  config.before(:suite) do
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  config.before(:each, js: true) do
+    DatabaseCleaner.strategy = :truncation
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+
+  config.before(:each) do
+    cleaner.call
+  end
+end

data/spec/tests/arel_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+RSpec.describe 'Arel' do
+  context 'on inflix operation' do
+    let(:list) { Torque::PostgreSQL::Arel::INFLIX_OPERATION }
+    let(:collector) { ::Arel::Collectors::SQLString }
+    let(:attribute) { ::Arel::Table.new('a')['sample'] }
+    let(:conn) { ActiveRecord::Base.connection }
+    let(:visitor) { ::Arel::Visitors::PostgreSQL.new(conn) }
+
+    [
+      [:overlaps,            [1, 2],                       "ARRAY[1, 2]"],
+      [:contains,            [3, 4],                       "ARRAY[3, 4]"],
+      [:contained_by,        [5, 6],                       "ARRAY[5, 6]"],
+      [:has_key,             ::Arel.sql("'a'"),            "'a'"],
+      [:has_all_keys,        ['b', 'c'],                   "ARRAY['b', 'c']"],
+      [:has_any_keys,        ['d', 'e'],                   "ARRAY['d', 'e']"],
+
+      [:strictly_left,       ::Arel.sql('numrange(1, 2)'), 'numrange(1, 2)'],
+      [:strictly_right,      ::Arel.sql('numrange(3, 4)'), 'numrange(3, 4)'],
+      [:doesnt_right_extend, ::Arel.sql('numrange(5, 6)'), 'numrange(5, 6)'],
+      [:doesnt_left_extend,  ::Arel.sql('numrange(7, 8)'), 'numrange(7, 8)'],
+      [:adjacent_to,         ::Arel.sql('numrange(9, 0)'), 'numrange(9, 0)'],
+    ].each do |(operator, value, quoted_value)|
+      klass_name = operator.to_s.camelize
+
+      context "##{operator}" do
+        let(:instance) { attribute.public_send(operator, value) }
+
+        context 'for attribute' do
+          let(:klass) { ::Arel::Nodes.const_get(klass_name) }
+
+          it "returns a new #{klass_name}" do
+            expect(instance).to be_a(klass)
+          end
+        end
+
+        context 'for visitor' do
+          let(:result) { visitor.accept(instance, collector.new).value }
+
+          it 'returns a formatted operation' do
+            expect(result).to be_eql("\"a\".\"sample\" #{list[klass_name]} #{quoted_value}")
+          end
+        end
+      end
+    end
+  end
+
+  context 'on cast' do
+    it 'provides an array method' do
+      sample1 = ::Arel.array(1, 2, 3, 4)
+      sample2 = ::Arel.array([1, 2, 3, 4])
+      sample3 = ::Arel.array(1, 2, 3, 4, cast: 'bigint')
+      sample4 = ::Arel.array([1, 2, 3, 4], [5, 6, 7, 8], cast: 'integer')
+
+      expect(sample1.to_sql).to be_eql('ARRAY[1, 2, 3, 4]')
+      expect(sample2.to_sql).to be_eql('ARRAY[1, 2, 3, 4]')
+      expect(sample3.to_sql).to be_eql('ARRAY[1, 2, 3, 4]::bigint[]')
+      expect(sample4.to_sql).to be_eql('ARRAY[ARRAY[1, 2, 3, 4], ARRAY[5, 6, 7, 8]]::integer[]')
+    end
+
+    it 'provides a cast method' do
+      attribute = ::Arel::Table.new('a')['sample']
+      quoted = ::Arel::Nodes::build_quoted([1])
+      casted = ::Arel::Nodes::build_quoted(1, attribute)
+
+      expect(attribute.cast('text').to_sql).to be_eql('"a"."sample"::text')
+      expect(quoted.cast('bigint', true).to_sql).to be_eql('ARRAY[1]::bigint[]')
+      expect(casted.cast('string').to_sql).to be_eql("1::string")
+    end
+  end
+end

data/spec/tests/auxiliary_statement_spec.rb

@@ -0,0 +1,593 @@
+require 'spec_helper'
+
+RSpec.describe 'AuxiliaryStatement' do
+  before :each do
+    User.auxiliary_statements_list = {}
+  end
+
+  context 'on relation' do
+    let(:klass) { User }
+    let(:true_value) { 'TRUE' }
+    subject { klass.unscoped }
+
+    it 'has its method' do
+      expect(subject).to respond_to(:with)
+    end
+
+    it 'can perform simple queries' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes content: :comment_content
+      end
+
+      result = 'WITH "comments" AS'
+      result << ' (SELECT "comments"."user_id", "comments"."content" AS comment_content FROM "comments")'
+      result << ' SELECT "users".*, "comments"."comment_content" FROM "users"'
+      result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+      expect(subject.with(:comments).arel.to_sql).to eql(result)
+    end
+
+    it 'can perform more complex queries' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.distinct_on(:user_id).order(:user_id, id: :desc)
+        cte.attributes content: :last_comment
+      end
+
+      result = 'WITH "comments" AS (SELECT DISTINCT ON ( "comments"."user_id" )'
+      result << ' "comments"."user_id", "comments"."content" AS last_comment'
+      result << ' FROM "comments" ORDER BY "comments"."user_id" ASC,'
+      result << ' "comments"."id" DESC) SELECT "users".*,'
+      result << ' "comments"."last_comment" FROM "users" INNER JOIN "comments"'
+      result << ' ON "comments"."user_id" = "users"."id"'
+      expect(subject.with(:comments).arel.to_sql).to eql(result)
+    end
+
+    it 'accepts extra select columns' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes content: :comment_content
+      end
+
+      result = 'WITH "comments" AS'
+      result << ' (SELECT "comments"."user_id", "comments"."content" AS comment_content, "comments"."slug" AS comment_slug FROM "comments")'
+      result << ' SELECT "users".*, "comments"."comment_content", "comments"."comment_slug" FROM "users"'
+      result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+      expect(subject.with(:comments, select: {slug: :comment_slug}).arel.to_sql).to eql(result)
+    end
+
+    it 'accepts extra join columns' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes content: :comment_content
+      end
+
+      result = 'WITH "comments" AS'
+      result << ' (SELECT "comments"."user_id", "comments"."active", "comments"."content" AS comment_content FROM "comments")'
+      result << ' SELECT "users".*, "comments"."comment_content" FROM "users"'
+      result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id" AND "comments"."active" = "users"."active"'
+      expect(subject.with(:comments, join: {active: :active}).arel.to_sql).to eql(result)
+    end
+
+    it 'accepts extra conditions' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes content: :comment_content
+      end
+
+      result = 'WITH "comments" AS'
+      result << ' (SELECT "comments"."user_id", "comments"."content" AS comment_content'
+      result << ' FROM "comments" WHERE "comments"."active" = $1)'
+      result << ' SELECT "users".*, "comments"."comment_content" FROM "users"'
+      result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+      expect(subject.with(:comments, where: {active: true}).arel.to_sql).to eql(result)
+    end
+
+    it 'accepts scopes from both sides' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.where(id: 1).all
+        cte.attributes content: :comment_content
+      end
+
+      query = subject.where(id: 2).with(:comments)
+
+      result = 'WITH "comments" AS'
+      result << ' (SELECT "comments"."user_id", "comments"."content" AS comment_content FROM "comments"'
+      result << ' WHERE "comments"."id" = $1)'
+      result << ' SELECT "users".*, "comments"."comment_content" FROM "users"'
+      result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+      result << ' WHERE "users"."id" = $2'
+
+      expect(query.arel.to_sql).to eql(result)
+      expect(query.send(:bound_attributes).map(&:value_before_type_cast)).to eql([1, 2])
+    end
+
+    it 'accepts string as attributes' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes sql('MAX(id)') => :comment_id
+      end
+
+      result = 'WITH "comments" AS'
+      result << ' (SELECT "comments"."user_id", MAX(id) AS comment_id FROM "comments")'
+      result << ' SELECT "users".*, "comments"."comment_id" FROM "users"'
+      result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+      expect(subject.with(:comments).arel.to_sql).to eql(result)
+    end
+
+    it 'accepts complex string as attributes' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes sql('ROW_NUMBER() OVER (PARTITION BY ORDER BY "comments"."id")') => :comment_id
+      end
+
+      result = 'WITH "comments" AS'
+      result << ' (SELECT "comments"."user_id", ROW_NUMBER() OVER (PARTITION BY ORDER BY "comments"."id") AS comment_id FROM "comments")'
+      result << ' SELECT "users".*, "comments"."comment_id" FROM "users"'
+      result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+      expect(subject.with(:comments).arel.to_sql).to eql(result)
+    end
+
+    it 'accepts arel attribute as attributes' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes col(:id).minimum => :comment_id
+      end
+
+      result = 'WITH "comments" AS'
+      result << ' (SELECT "comments"."user_id", MIN("comments"."id") AS comment_id FROM "comments")'
+      result << ' SELECT "users".*, "comments"."comment_id" FROM "users"'
+      result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+      expect(subject.with(:comments).arel.to_sql).to eql(result)
+    end
+
+    it 'accepts custom join properties' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes content: :comment_content
+        cte.join name: :id, 'a.col' => :col
+      end
+
+      result = 'WITH "comments" AS (SELECT "comments"."id", "comments"."col",'
+      result << ' "comments"."content" AS comment_content FROM "comments") SELECT "users".*,'
+      result << ' "comments"."comment_content" FROM "users" INNER JOIN "comments"'
+      result << ' ON "comments"."id" = "users"."name" AND "comments"."col" = "a"."col"'
+      expect(subject.with(:comments).arel.to_sql).to eql(result)
+    end
+
+    it 'can perform other types of joins' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes content: :comment_content
+        cte.join_type :left
+      end
+
+      result = 'WITH "comments" AS (SELECT "comments"."user_id",'
+      result << ' "comments"."content" AS comment_content FROM "comments") SELECT "users".*,'
+      result << ' "comments"."comment_content" FROM "users" LEFT OUTER JOIN "comments"'
+      result << ' ON "comments"."user_id" = "users"."id"'
+      expect(subject.with(:comments).arel.to_sql).to eql(result)
+    end
+
+    it 'can manually define the association' do
+      klass.has_many :sample_comment, class_name: 'Comment', foreign_key: :a_user_id
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.through :sample_comment
+        cte.attributes content: :sample_content
+      end
+
+      result = 'WITH "comments" AS'
+      result << ' (SELECT "comments"."a_user_id", "comments"."content" AS sample_content FROM "comments")'
+      result << ' SELECT "users".*, "comments"."sample_content" FROM "users"'
+      result << ' INNER JOIN "comments" ON "comments"."a_user_id" = "users"."id"'
+      expect(subject.with(:comments).arel.to_sql).to eql(result)
+    end
+
+    it 'accepts complex scopes from dependencies' do
+      klass.send(:auxiliary_statement, :comments1) do |cte|
+        cte.query Comment.where(id: 1).all
+        cte.attributes content: :comment_content1
+      end
+
+      klass.send(:auxiliary_statement, :comments2) do |cte|
+        cte.requires :comments1
+        cte.query Comment.where(id: 2).all
+        cte.attributes content: :comment_content2
+      end
+
+      query = subject.where(id: 3).with(:comments2)
+
+      result = 'WITH '
+      result << '"comments1" AS (SELECT "comments"."user_id", "comments"."content" AS comment_content1 FROM "comments" WHERE "comments"."id" = $1), '
+      result << '"comments2" AS (SELECT "comments"."user_id", "comments"."content" AS comment_content2 FROM "comments" WHERE "comments"."id" = $2)'
+      result << ' SELECT "users".*, "comments1"."comment_content1", "comments2"."comment_content2" FROM "users"'
+      result << ' INNER JOIN "comments1" ON "comments1"."user_id" = "users"."id"'
+      result << ' INNER JOIN "comments2" ON "comments2"."user_id" = "users"."id"'
+      result << ' WHERE "users"."id" = $3'
+
+      expect(query.arel.to_sql).to eql(result)
+      expect(query.send(:bound_attributes).map(&:value_before_type_cast)).to eql([1, 2, 3])
+    end
+
+    context 'with dependency' do
+      before :each do
+        klass.send(:auxiliary_statement, :comments1) do |cte|
+          cte.query Comment.all
+          cte.attributes content: :comment_content1
+        end
+
+        klass.send(:auxiliary_statement, :comments2) do |cte|
+          cte.requires :comments1
+          cte.query Comment.all
+          cte.attributes content: :comment_content2
+        end
+      end
+
+      it 'can requires another statement as dependency' do
+        result = 'WITH '
+        result << '"comments1" AS (SELECT "comments"."user_id", "comments"."content" AS comment_content1 FROM "comments"), '
+        result << '"comments2" AS (SELECT "comments"."user_id", "comments"."content" AS comment_content2 FROM "comments")'
+        result << ' SELECT "users".*, "comments1"."comment_content1", "comments2"."comment_content2" FROM "users"'
+        result << ' INNER JOIN "comments1" ON "comments1"."user_id" = "users"."id"'
+        result << ' INNER JOIN "comments2" ON "comments2"."user_id" = "users"."id"'
+        expect(subject.with(:comments2).arel.to_sql).to eql(result)
+      end
+
+      it 'can uses already already set dependent' do
+        result = 'WITH '
+        result << '"comments1" AS (SELECT "comments"."user_id", "comments"."content" AS comment_content1 FROM "comments"), '
+        result << '"comments2" AS (SELECT "comments"."user_id", "comments"."content" AS comment_content2 FROM "comments")'
+        result << ' SELECT "users".*, "comments1"."comment_content1", "comments2"."comment_content2" FROM "users"'
+        result << ' INNER JOIN "comments1" ON "comments1"."user_id" = "users"."id"'
+        result << ' INNER JOIN "comments2" ON "comments2"."user_id" = "users"."id"'
+        expect(subject.with(:comments1, :comments2).arel.to_sql).to eql(result)
+      end
+
+      it 'raises an error if the dependent does not exist' do
+        klass.send(:auxiliary_statement, :comments2) do |cte|
+          cte.requires :comments3
+          cte.query Comment.all
+          cte.attributes content: :comment_content2
+        end
+        expect{ subject.with(:comments2).arel.to_sql }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'query as string' do
+      it 'performs correctly' do
+        klass.send(:auxiliary_statement, :comments) do |cte|
+          cte.query :comments, 'SELECT * FROM comments'
+          cte.attributes content: :comment
+          cte.join id: :user_id
+        end
+
+        result = 'WITH "comments" AS (SELECT * FROM comments)'
+        result << ' SELECT "users".*, "comments"."comment" FROM "users"'
+        result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+        expect(subject.with(:comments).arel.to_sql).to eql(result)
+      end
+
+      it 'accepts arguments to format the query' do
+        klass.send(:auxiliary_statement, :comments) do |cte|
+          cte.query :comments, 'SELECT * FROM comments WHERE active = %{active}'
+          cte.attributes content: :comment
+          cte.join id: :user_id
+        end
+
+        result = "WITH \"comments\" AS (SELECT * FROM comments WHERE active = #{true_value})"
+        result << ' SELECT "users".*, "comments"."comment" FROM "users"'
+        result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+        expect(subject.with(:comments, args: {active: true}).arel.to_sql).to eql(result)
+      end
+
+      it 'raises an error when join columns are not given' do
+        klass.send(:auxiliary_statement, :comments) do |cte|
+          cte.query :comments, 'SELECT * FROM comments'
+          cte.attributes content: :comment
+        end
+
+        expect{ subject.with(:comments).arel.to_sql }.to raise_error(ArgumentError, /join columns/)
+      end
+
+      it 'raises an error when not given the table name as first argument' do
+        klass.send(:auxiliary_statement, :comments) do |cte|
+          cte.query 'SELECT * FROM comments'
+          cte.attributes content: :comment
+          cte.join id: :user_id
+        end
+
+        expect{ subject.with(:comments).arel.to_sql }.to raise_error(ArgumentError, /table name/)
+      end
+    end
+
+    context 'query as proc' do
+      it 'performs correctly for result as relation' do
+        klass.send(:auxiliary_statement, :comments) do |cte|
+          cte.query :comments, -> { Comment.all }
+          cte.attributes content: :comment
+          cte.join id: :user_id
+        end
+
+        result = 'WITH "comments" AS'
+        result << ' (SELECT "comments"."user_id", "comments"."content" AS comment FROM "comments")'
+        result << ' SELECT "users".*, "comments"."comment" FROM "users"'
+        result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+        expect(subject.with(:comments).arel.to_sql).to eql(result)
+      end
+
+      it 'performs correctly for anything that has a call method' do
+        obj = Struct.new(:call, :arity).new('SELECT * FROM comments', 0)
+        klass.send(:auxiliary_statement, :comments) do |cte|
+          cte.query :comments, obj
+          cte.attributes content: :comment
+          cte.join id: :user_id
+        end
+
+        result = 'WITH "comments" AS (SELECT * FROM comments)'
+        result << ' SELECT "users".*, "comments"."comment" FROM "users"'
+        result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+        expect(subject.with(:comments).arel.to_sql).to eql(result)
+      end
+
+      it 'performs correctly for result as string' do
+        klass.send(:auxiliary_statement, :comments) do |cte|
+          cte.query :comments, -> { 'SELECT * FROM comments' }
+          cte.attributes content: :comment
+          cte.join id: :user_id
+        end
+
+        result = 'WITH "comments" AS (SELECT * FROM comments)'
+        result << ' SELECT "users".*, "comments"."comment" FROM "users"'
+        result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+        expect(subject.with(:comments).arel.to_sql).to eql(result)
+      end
+
+      it 'performs correctly when the proc requires arguments' do
+        klass.send(:auxiliary_statement, :comments) do |cte|
+          cte.query :comments, -> (args) { Comment.where(id: args.id) }
+          cte.attributes content: :comment
+          cte.join id: :user_id
+        end
+
+        query = subject.with(:comments, args: {id: 1})
+
+        result = 'WITH "comments" AS'
+        result << ' (SELECT "comments"."user_id", "comments"."content" AS comment'
+        result << ' FROM "comments" WHERE "comments"."id" = $1)'
+        result << ' SELECT "users".*, "comments"."comment" FROM "users"'
+        result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+
+        expect(query.arel.to_sql).to eql(result)
+        expect(query.send(:bound_attributes).map(&:value_before_type_cast)).to eql([1])
+      end
+
+      it 'raises an error when join columns are not given' do
+        klass.send(:auxiliary_statement, :comments) do |cte|
+          cte.query :comments, -> { Author.all }
+          cte.attributes content: :comment
+        end
+
+        expect{ subject.with(:comments).arel.to_sql }.to raise_error(ArgumentError, /join columns/)
+      end
+
+      it 'raises an error when not given the table name as first argument' do
+        klass.send(:auxiliary_statement, :comments) do |cte|
+          cte.query -> { Comment.all }
+          cte.attributes content: :comment
+          cte.join id: :user_id
+        end
+
+        expect{ subject.with(:comments).arel.to_sql }.to raise_error(ArgumentError, /table name/)
+      end
+
+      it 'raises an error when the result of the proc is an invalid type' do
+        klass.send(:auxiliary_statement, :comments) do |cte|
+          cte.query :comments, -> { false }
+          cte.attributes content: :comment
+          cte.join id: :user_id
+        end
+
+        expect{ subject.with(:comments).arel.to_sql }.to raise_error(ArgumentError, /query objects/)
+      end
+    end
+
+    context 'with inheritance' do
+      let(:base) { Activity }
+      let(:klass) { ActivityBook }
+
+      it 'accepts ancestors auxiliary statements' do
+        base.send(:auxiliary_statement, :authors) do |cte|
+          cte.query Author.all
+          cte.attributes name: :author_name
+          cte.join author_id: :id
+        end
+
+        result = 'WITH "authors" AS'
+        result << ' (SELECT "authors"."id", "authors"."name" AS author_name FROM "authors")'
+        result << ' SELECT "activity_books".*, "authors"."author_name" FROM "activity_books"'
+        result << ' INNER JOIN "authors" ON "authors"."id" = "activity_books"."author_id"'
+        expect(subject.with(:authors).arel.to_sql).to eql(result)
+      end
+
+      it 'can replace ancestors auxiliary statements' do
+        base.send(:auxiliary_statement, :authors) do |cte|
+          cte.query Author.all
+          cte.attributes name: :author_name
+          cte.join author_id: :id
+        end
+
+        klass.send(:auxiliary_statement, :authors) do |cte|
+          cte.query Author.all
+          cte.attributes type: :author_type
+          cte.join author_id: :id
+        end
+
+        result = 'WITH "authors" AS'
+        result << ' (SELECT "authors"."id", "authors"."type" AS author_type FROM "authors")'
+        result << ' SELECT "activity_books".*, "authors"."author_type" FROM "activity_books"'
+        result << ' INNER JOIN "authors" ON "authors"."id" = "activity_books"."author_id"'
+        expect(subject.with(:authors).arel.to_sql).to eql(result)
+      end
+
+      it 'raises an error when no class has the auxiliary statement' do
+        expect{ subject.with(:comments).arel.to_sql }.to raise_error(ArgumentError)
+      end
+    end
+
+    it 'works with count and does not add extra columns' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes content: :comment_content
+      end
+
+      result = 'WITH "comments" AS'
+      result << ' (SELECT "comments"."user_id", "comments"."content" AS comment_content FROM "comments")'
+      result << ' SELECT COUNT(*) FROM "users"'
+      result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+
+      query = get_last_executed_query{ subject.with(:comments).count }
+      expect(query).to eql(result)
+    end
+
+    it 'works with sum and does not add extra columns' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes id: :value
+      end
+
+      result = 'WITH "comments" AS'
+      result << ' (SELECT "comments"."user_id", "comments"."id" AS value FROM "comments")'
+      result << ' SELECT SUM("comments"."value") FROM "users"'
+      result << ' INNER JOIN "comments" ON "comments"."user_id" = "users"."id"'
+
+      query = get_last_executed_query{ subject.with(:comments).sum(comments: :value) }
+      expect(query).to eql(result)
+    end
+
+    it 'raises an error when using an invalid type of object as query' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query :string, String
+      end
+
+      expect{ subject.with(:comments).arel.to_sql }.to raise_error(ArgumentError, /object types/)
+    end
+
+    it 'raises an error when traying to use a statement that is not defined' do
+      expect{ subject.with(:does_not_exist).arel.to_sql }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an error when using an invalid type of join' do
+      klass.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes content: :comment_content
+        cte.join_type :invalid
+      end
+
+      expect{ subject.with(:comments).arel.to_sql }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'on model' do
+    subject { User }
+
+    it 'has its configurator' do
+      expect(subject.protected_methods).to include(:cte)
+      expect(subject.protected_methods).to include(:auxiliary_statement)
+    end
+
+    it 'allows configurate new auxiliary statements' do
+      subject.send(:auxiliary_statement, :cte1)
+      expect(subject.auxiliary_statements_list).to include(:cte1)
+      expect(subject.const_defined?('Cte1_AuxiliaryStatement')).to be_truthy
+    end
+
+    it 'has its query method' do
+      expect(subject).to respond_to(:with)
+    end
+
+    it 'returns a relation when using the method' do
+      subject.send(:auxiliary_statement, :comments) do |cte|
+        cte.query Comment.all
+        cte.attributes content: :comment_content
+      end
+      expect(subject.with(:comments)).to be_a(ActiveRecord::Relation)
+    end
+  end
+
+  context 'on external' do
+    let(:klass) { Torque::PostgreSQL::AuxiliaryStatement }
+    subject { User }
+
+    it 'has the external method available' do
+      expect(klass).to respond_to(:create)
+    end
+
+    it 'accepts simple auxiliary statement definition' do
+      sample = klass.create(Comment.all)
+      query = subject.with(sample, select: {content: :comment_content}).arel.to_sql
+
+      result = 'WITH "comment" AS'
+      result << ' (SELECT "comments"."user_id", "comments"."content" AS comment_content FROM "comments")'
+      result << ' SELECT "users".*, "comment"."comment_content" FROM "users"'
+      result << ' INNER JOIN "comment" ON "comment"."user_id" = "users"."id"'
+      expect(query).to eql(result)
+    end
+
+    it 'accepts a hash auxiliary statement definition' do
+      sample = klass.create(query: Comment.all, select: {content: :comment_content})
+      query = subject.with(sample).arel.to_sql
+
+      result = 'WITH "comment" AS'
+      result << ' (SELECT "comments"."user_id", "comments"."content" AS comment_content FROM "comments")'
+      result << ' SELECT "users".*, "comment"."comment_content" FROM "users"'
+      result << ' INNER JOIN "comment" ON "comment"."user_id" = "users"."id"'
+      expect(query).to eql(result)
+    end
+
+    it 'accepts a block when creating the auxiliary statement' do
+      sample = klass.create(:all_comments) do |cte|
+        cte.query Comment.all
+        cte.select content: :comment_content
+      end
+
+      result = 'WITH "all_comments" AS'
+      result << ' (SELECT "comments"."user_id", "comments"."content" AS comment_content FROM "comments")'
+      result << ' SELECT "users".*, "all_comments"."comment_content" FROM "users"'
+      result << ' INNER JOIN "all_comments" ON "all_comments"."user_id" = "users"."id"'
+
+      query = subject.with(sample).arel.to_sql
+      expect(query).to eql(result)
+    end
+  end
+
+  context 'on settings' do
+    let(:base) { User }
+    let(:statement_klass) do
+      base.send(:auxiliary_statement, :statement)
+      base::Statement_AuxiliaryStatement
+    end
+
+    subject do
+      Torque::PostgreSQL::AuxiliaryStatement::Settings.new(base, statement_klass)
+    end
+
+    it 'has access to base' do
+      expect(subject.base).to eql(User)
+      expect(subject.base_table).to be_a(Arel::Table)
+    end
+
+    it 'has access to statement table' do
+      expect(subject.table_name).to eql('statement')
+      expect(subject.table).to be_a(Arel::Table)
+    end
+
+    it 'has access to the query arel table' do
+      subject.query Comment.all
+      expect(subject.query_table).to be_a(Arel::Table)
+    end
+
+    it 'raises an error when trying to access query table before defining the query' do
+      expect{ subject.with(:comments).arel.to_sql }.to raise_error(StandardError)
+    end
+  end
+end