torque-postgresql 3.0.1 → 3.2.0

data/lib/torque/postgresql/auxiliary_statement.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'auxiliary_statement/settings'
+require_relative 'auxiliary_statement/recursive'
 
 module Torque
   module PostgreSQL
@@ -8,17 +9,20 @@ module Torque
       TABLE_COLUMN_AS_STRING = /\A(?:"?(\w+)"?\.)?"?(\w+)"?\z/.freeze
 
       class << self
-        attr_reader :config
+        attr_reader :config, :table_name
 
         # Find or create the class that will handle statement
         def lookup(name, base)
           const = name.to_s.camelize << '_' << self.name.demodulize
           return base.const_get(const, false) if base.const_defined?(const, false)
-          base.const_set(const, Class.new(AuxiliaryStatement))
+
+          base.const_set(const, Class.new(self)).tap do |klass|
+            klass.instance_variable_set(:@table_name, name.to_s)
+          end
         end
 
         # Create a new instance of an auxiliary statement
-        def instantiate(statement, base, options = nil)
+        def instantiate(statement, base, **options)
           klass = while base < ActiveRecord::Base
             list = base.auxiliary_statements_list
             break list[statement] if list.present? && list.key?(statement)
@@ -26,15 +30,15 @@ module Torque
             base = base.superclass
           end
 
-          return klass.new(options) unless klass.nil?
+          return klass.new(**options) unless klass.nil?
           raise ArgumentError, <<-MSG.squish
             There's no '#{statement}' auxiliary statement defined for #{base.class.name}.
           MSG
         end
 
         # Fast access to statement build
-        def build(statement, base, options = nil, bound_attributes = [], join_sources = [])
-          klass = instantiate(statement, base, options)
+        def build(statement, base, bound_attributes = [], join_sources = [], **options)
+          klass = instantiate(statement, base, **options)
           result = klass.build(base)
 
           bound_attributes.concat(klass.bound_attributes)
@@ -56,7 +60,7 @@ module Torque
         # A way to create auxiliary statements outside of models configurations,
         # being able to use on extensions
         def create(table_or_settings, &block)
-          klass = Class.new(AuxiliaryStatement)
+          klass = Class.new(self)
 
           if block_given?
             klass.instance_variable_set(:@table_name, table_or_settings)
@@ -89,7 +93,8 @@ module Torque
         def configure(base, instance)
           return @config unless @config.respond_to?(:call)
 
-          settings = Settings.new(base, instance)
+          recursive = self < AuxiliaryStatement::Recursive
+          settings = Settings.new(base, instance, recursive)
           settings.instance_exec(settings, &@config)
           settings
         end
@@ -98,11 +103,6 @@ module Torque
         def table
           @table ||= ::Arel::Table.new(table_name)
         end
-
-        # Get the name of the table of the configurated statement
-        def table_name
-          @table_name ||= self.name.demodulize.split('_').first.underscore
-        end
       end
 
       delegate :config, :table, :table_name, :relation, :configure, :relation_query?,
@@ -111,15 +111,14 @@ module Torque
       attr_reader :bound_attributes, :join_sources
 
       # Start a new auxiliary statement giving extra options
-      def initialize(*args)
-        options = args.extract_options!
+      def initialize(*, **options)
         args_key = Torque::PostgreSQL.config.auxiliary_statement.send_arguments_key
 
         @join = options.fetch(:join, {})
         @args = options.fetch(args_key, {})
         @where = options.fetch(:where, {})
         @select = options.fetch(:select, {})
-        @join_type = options.fetch(:join_type, nil)
+        @join_type = options[:join_type]
 
         @bound_attributes = []
         @join_sources = []
@@ -131,7 +130,7 @@ module Torque
         @join_sources.clear
 
         # Prepare all the data for the statement
-        prepare(base)
+        prepare(base, configure(base, self))
 
         # Add the join condition to the list
         @join_sources << build_join(base)
@@ -141,9 +140,9 @@ module Torque
       end
 
       private
+
         # Setup the statement using the class configuration
-        def prepare(base)
-          settings = configure(base, self)
+        def prepare(base, settings)
           requires = Array.wrap(settings.requires).flatten.compact
           @dependencies = ensure_dependencies(requires, base).flatten.compact
 
@@ -151,14 +150,12 @@ module Torque
           @query = settings.query
 
           # Call a proc to get the real query
-          if @query.methods.include?(:call)
+          if @query.respond_to?(:call)
             call_args = @query.try(:arity) === 0 ? [] : [OpenStruct.new(@args)]
             @query = @query.call(*call_args)
-            @args = []
           end
 
-          # Manually set the query table when it's not an relation query
-          @query_table = settings.query_table unless relation_query?(@query)
+          # Merge select attributes provided on the instance creation
           @select = settings.attributes.merge(@select) if settings.attributes.present?
 
           # Merge join settings
@@ -168,7 +165,7 @@ module Torque
             @association = settings.through.to_s
           elsif relation_query?(@query)
             @association = base.reflections.find do |name, reflection|
-              break name if @query.klass.eql? reflection.klass
+              break name if @query.klass.eql?(reflection.klass)
             end
           end
         end
@@ -234,15 +231,6 @@ module Torque
             as a query object on #{self.class.name}.
           MSG
 
-          # Expose join columns
-          if relation_query?(@query)
-            query_table = @query.arel_table
-            conditions.children.each do |item|
-              @query.select_values += [query_table[item.left.name]] \
-                if item.left.relation.eql?(table)
-            end
-          end
-
           # Build the join based on the join type
           arel_join.new(table, table.create_on(conditions))
         end
@@ -263,21 +251,31 @@ module Torque
 
         # Mount the list of selected attributes
         def expose_columns(base, query_table = nil)
+          # Add the columns necessary for the join
+          list = @join_sources.each_with_object(@select) do |join, hash|
+            join.right.expr.children.each do |item|
+              hash[item.left.name] = nil if item.left.relation.eql?(table)
+            end
+          end
+
           # Add select columns to the query and get exposed columns
-          @select.map do |left, right|
-            base.select_extra_values += [table[right.to_s]]
-            project(left, query_table).as(right.to_s) if query_table
+          list.filter_map do |left, right|
+            base.select_extra_values += [table[right.to_s]] unless right.nil?
+            next unless query_table
+
+            col = project(left, query_table)
+            right.nil? ? col : col.as(right.to_s)
           end
         end
 
         # Ensure that all the dependencies are loaded in the base relation
         def ensure_dependencies(list, base)
           with_options = list.extract_options!.to_a
-          (list + with_options).map do |dependent, options|
-            dependent_klass = base.model.auxiliary_statements_list[dependent]
+          (list + with_options).map do |name, options|
+            dependent_klass = base.model.auxiliary_statements_list[name]
 
             raise ArgumentError, <<-MSG.squish if dependent_klass.nil?
-              The '#{dependent}' auxiliary statement dependency can't found on
+              The '#{name}' auxiliary statement dependency can't found on
               #{self.class.name}.
             MSG
 
@@ -285,7 +283,8 @@ module Torque
               cte.is_a?(dependent_klass)
             end
 
-            AuxiliaryStatement.build(dependent, base, options, bound_attributes, join_sources)
+            options ||= {}
+            AuxiliaryStatement.build(name, base, bound_attributes, join_sources, **options)
           end
         end
 

data/lib/torque/postgresql/base.rb

@@ -5,15 +5,27 @@ module Torque
     module Base
       extend ActiveSupport::Concern
 
+      ##
+      # :singleton-method: schema
+      # :call-seq: schema
+      #
+      # The schema to which the table belongs to.
+
       included do
         mattr_accessor :belongs_to_many_required_by_default, instance_accessor: false
+        class_attribute :schema, instance_writer: false
       end
 
       module ClassMethods
         delegate :distinct_on, :with, :itself_only, :cast_records, to: :all
 
-        # Wenever it's inherited, add a new list of auxiliary statements
-        # It also adds an auxiliary statement to load inherited records' relname
+        # Make sure that table name is an instance of TableName class
+        def reset_table_name
+          self.table_name = TableName.new(self, super)
+        end
+
+        # Whenever the base model is inherited, add a list of auxiliary
+        # statements like the one that loads inherited records' relname
         def inherited(subclass)
           super
 
@@ -22,32 +34,14 @@ module Torque
 
           record_class = ActiveRecord::Relation._record_class_attribute
 
-          # Define helper methods to return the class of the given records
-          subclass.auxiliary_statement record_class do |cte|
-            pg_class = ::Arel::Table.new('pg_class')
-            arel_query = ::Arel::SelectManager.new(pg_class)
-            arel_query.project(pg_class['oid'], pg_class['relname'].as(record_class.to_s))
-
-            cte.query 'pg_class', arel_query.to_sql
-            cte.attributes col(record_class) => record_class
-            cte.join tableoid: :oid
-          end
-
           # Define the dynamic attribute that returns the same information as
           # the one provided by the auxiliary statement
           subclass.dynamic_attribute(record_class) do
-            next self.class.table_name unless self.class.physically_inheritances?
+            klass = self.class
+            next klass.table_name unless klass.physically_inheritances?
 
-            pg_class = ::Arel::Table.new('pg_class')
-            source = ::Arel::Table.new(subclass.table_name, as: 'source')
-            quoted_id = ::Arel::Nodes::Quoted.new(id)
-
-            query = ::Arel::SelectManager.new(pg_class)
-            query.join(source).on(pg_class['oid'].eq(source['tableoid']))
-            query.where(source[subclass.primary_key].eq(quoted_id))
-            query.project(pg_class['relname'])
-
-            self.class.connection.select_value(query)
+            query = klass.unscoped.where(subclass.primary_key => id)
+            query.pluck(klass.arel_table['tableoid'].cast('regclass')).first
           end
         end
 
@@ -258,7 +252,7 @@ module Torque
           # attributes key:
           # Provides a map of attributes to be exposed to the main query.
           #
-          # For instace, if the statement query has an 'id' column that you
+          # For instance, if the statement query has an 'id' column that you
           # want it to be accessed on the main query as 'item_id',
           # you can use:
           #   attributes id: :item_id, 'MAX(id)' => :max_id,
@@ -299,6 +293,16 @@ module Torque
             klass.configurator(block)
           end
           alias cte auxiliary_statement
+
+          # Creates a new recursive auxiliary statement (CTE) under the base
+          # Very similar to the regular auxiliary statement, but with two-part
+          # query where one is executed first and the second recursively
+          def recursive_auxiliary_statement(table, &block)
+            klass = AuxiliaryStatement::Recursive.lookup(table, self)
+            auxiliary_statements_list[table.to_sym] = klass
+            klass.configurator(block)
+          end
+          alias recursive_cte recursive_auxiliary_statement
       end
     end
 

data/lib/torque/postgresql/config.rb

@@ -39,6 +39,19 @@ module Torque
 
     end
 
+    # Configure multiple schemas
+    config.nested(:schemas) do |schemas|
+
+      # Defines a list of LIKE-based schemas to not consider for a multiple
+      # schema database
+      schemas.blacklist = %w[information_schema pg_%]
+
+      # Defines a list of LIKE-based schemas to consider for a multiple schema
+      # database
+      schemas.whitelist = %w[public]
+
+    end
+
     # Configure auxiliary statement features
     config.nested(:auxiliary_statement) do |cte|
 
@@ -50,6 +63,10 @@ module Torque
       # auxiliary statement in order to perform detached CTEs
       cte.exposed_class = 'TorqueCTE'
 
+      # Estipulate a class name (which may contain namespace) that expose the
+      # recursive auxiliary statement in order to perform detached CTEs
+      cte.exposed_recursive_class = 'TorqueRecursiveCTE'
+
     end
 
     # Configure ENUM features

data/lib/torque/postgresql/inheritance.rb

@@ -55,7 +55,9 @@ module Torque
 
         # Check if the model's table depends on any inheritance
         def physically_inherited?
-          @physically_inherited ||= connection.schema_cache.dependencies(
+          return @physically_inherited if defined?(@physically_inherited)
+
+          @physically_inherited = connection.schema_cache.dependencies(
             defined?(@table_name) ? @table_name : decorated_table_name,
           ).present?
         rescue ActiveRecord::ConnectionNotEstablished

data/lib/torque/postgresql/migration/command_recorder.rb

@@ -5,24 +5,24 @@ module Torque
     module Migration
       module CommandRecorder
 
-        # Records the rename operation for types.
+        # Records the rename operation for types
         def rename_type(*args, &block)
           record(:rename_type, args, &block)
         end
 
-        # Inverts the type name.
+        # Inverts the type rename operation
         def invert_rename_type(args)
           [:rename_type, args.reverse]
         end
 
-        # Records the creation of the enum to be reverted.
-        def create_enum(*args, &block)
-          record(:create_enum, args, &block)
+        # Records the creation of a schema
+        def create_schema(*args, &block)
+          record(:create_schema, args, &block)
         end
 
-        # Inverts the creation of the enum.
-        def invert_create_enum(args)
-          [:drop_type, [args.first]]
+        # Inverts the creation of a schema
+        def invert_create_schema(args)
+          [:drop_schema, [args.first]]
         end
 
       end

data/lib/torque/postgresql/railtie.rb

@@ -30,11 +30,15 @@ module Torque
           Torque::PostgreSQL::Attributes::Enum.lookup(name).sample
         end
 
-        # Define the exposed constant for auxiliary statements
+        # Define the exposed constant for both types of auxiliary statements
         if torque_config.auxiliary_statement.exposed_class.present?
           *ns, name = torque_config.auxiliary_statement.exposed_class.split('::')
           base = ns.present? ? Object.const_get(ns.join('::')) : Object
           base.const_set(name, Torque::PostgreSQL::AuxiliaryStatement)
+
+          *ns, name = torque_config.auxiliary_statement.exposed_recursive_class.split('::')
+          base = ns.present? ? Object.const_get(ns.join('::')) : Object
+          base.const_set(name, Torque::PostgreSQL::AuxiliaryStatement::Recursive)
         end
       end
     end

data/lib/torque/postgresql/relation/auxiliary_statement.rb

@@ -10,22 +10,14 @@ module Torque
         # :nodoc:
         def auxiliary_statements_values=(value); set_value(:auxiliary_statements, value); end
 
-        # Set use of an auxiliary statement already configurated on the model
-        def with(*args)
-          spawn.with!(*args)
+        # Set use of an auxiliary statement
+        def with(*args, **settings)
+          spawn.with!(*args, **settings)
         end
 
         # Like #with, but modifies relation in place.
-        def with!(*args)
-          options = args.extract_options!
-          args.each do |table|
-            instance = table.is_a?(Class) && table < PostgreSQL::AuxiliaryStatement \
-              ? table.new(options) \
-              : PostgreSQL::AuxiliaryStatement.instantiate(table, self, options)
-
-            self.auxiliary_statements_values += [instance]
-          end
-
+        def with!(*args, **settings)
+          instantiate_auxiliary_statements(*args, **settings)
           self
         end
 
@@ -47,8 +39,23 @@ module Torque
           # Hook arel build to add the distinct on clause
           def build_arel(*)
             arel = super
-            subqueries = build_auxiliary_statements(arel)
-            subqueries.nil? ? arel : arel.with(subqueries)
+            type = auxiliary_statement_type
+            sub_queries = build_auxiliary_statements(arel)
+            sub_queries.nil? ? arel : arel.with(*type, *sub_queries)
+          end
+
+          # Instantiate one or more auxiliary statements for the given +klass+
+          def instantiate_auxiliary_statements(*args, **options)
+            klass = PostgreSQL::AuxiliaryStatement
+            klass = klass::Recursive if options.delete(:recursive).present?
+
+            self.auxiliary_statements_values += args.map do |table|
+              if table.is_a?(Class) && table < klass
+                table.new(**options)
+              else
+                klass.instantiate(table, self, **options)
+              end
+            end
           end
 
           # Build all necessary data for auxiliary statements
@@ -59,6 +66,12 @@ module Torque
             end
           end
 
+          # Return recursive if any auxiliary statement is recursive
+          def auxiliary_statement_type
+            klass = PostgreSQL::AuxiliaryStatement::Recursive
+            :recursive if auxiliary_statements_values.any?(klass)
+          end
+
           # Throw an error showing that an auxiliary statement of the given
           # table name isn't defined
           def auxiliary_statement_error(name)

data/lib/torque/postgresql/schema_cache.rb

@@ -109,7 +109,6 @@ module Torque
 
       # Try to find a model based on a given table
       def lookup_model(table_name, scoped_class = '')
-        # byebug if table_name == 'activities'
         scoped_class = scoped_class.name if scoped_class.is_a?(Class)
         return @data_sources_model_names[table_name] \
           if @data_sources_model_names.key?(table_name)
@@ -118,6 +117,12 @@ module Torque
         scopes = scoped_class.scan(/(?:::)?[A-Z][a-z]+/)
         scopes.unshift('Object::')
 
+        # Check if the table name comes with a schema
+        if table_name.include?('.')
+          schema, table_name = table_name.split('.')
+          scopes.insert(1, schema.camelize) if schema != 'public'
+        end
+
         # Consider the maximum namespaced possible model name
         max_name = table_name.tr('_', '/').camelize.split(/(::)/)
         max_name[-1] = max_name[-1].singularize

data/lib/torque/postgresql/table_name.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    class TableName < Delegator
+      def initialize(klass, table_name)
+        @klass = klass
+        @table_name = table_name
+      end
+
+      def schema
+        return @schema if defined?(@schema)
+
+        @schema = ([@klass] + @klass.module_parents[0..-2]).find do |klass|
+          next unless klass.respond_to?(:schema)
+          break klass.schema
+        end
+      end
+
+      def to_s
+        schema.nil? ? @table_name : "#{schema}.#{@table_name}"
+      end
+
+      alias __getobj__ to_s
+
+      def ==(other)
+        other.to_s =~ /("?#{schema | search_path_schemes.join('|')}"?\.)?"?#{@table_name}"?/
+      end
+
+      def __setobj__(value)
+        @table_name = value
+      end
+
+      private
+
+        def search_path_schemes
+          klass.connection.schemas_search_path_sanitized
+        end
+    end
+  end
+end

data/lib/torque/postgresql/version.rb

@@ -2,6 +2,6 @@
 
 module Torque
   module PostgreSQL
-    VERSION = '3.0.1'
+    VERSION = '3.2.0'
   end
 end

data/lib/torque/postgresql.rb

@@ -20,12 +20,13 @@ require 'torque/postgresql/associations'
 require 'torque/postgresql/attributes'
 require 'torque/postgresql/autosave_association'
 require 'torque/postgresql/auxiliary_statement'
-require 'torque/postgresql/base'
 require 'torque/postgresql/inheritance'
+require 'torque/postgresql/base' # Needs to be after inheritance
 require 'torque/postgresql/insert_all'
 require 'torque/postgresql/migration'
 require 'torque/postgresql/relation'
 require 'torque/postgresql/reflection'
 require 'torque/postgresql/schema_cache'
+require 'torque/postgresql/table_name'
 
 require 'torque/postgresql/railtie' if defined?(Rails)

data/spec/models/category.rb

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

data/spec/models/internal/user.rb

@@ -0,0 +1,5 @@
+module Internal
+  class User < ActiveRecord::Base
+    self.schema = 'internal'
+  end
+end

data/spec/schema.rb

@@ -20,6 +20,9 @@ ActiveRecord::Schema.define(version: version) do
   enable_extension "pgcrypto"
   enable_extension "plpgsql"
 
+  # Custom schemas used in this database.
+  create_schema "internal", force: :cascade
+
   # Custom types defined in this database.
   # Note that some types may not work with other database engines. Be careful if changing database.
   create_enum "content_status", ["created", "draft", "published", "archived"]
@@ -66,6 +69,11 @@ ActiveRecord::Schema.define(version: version) do
     t.enum     "specialty", enum_type: :specialties
   end
 
+  create_table "categories", force: :cascade do |t|
+    t.integer  "parent_id"
+    t.string   "title"
+  end
+
   create_table "texts", force: :cascade do |t|
     t.integer  "user_id"
     t.string   "content"
@@ -83,6 +91,7 @@ ActiveRecord::Schema.define(version: version) do
   end
 
   create_table "courses", force: :cascade do |t|
+    t.integer  "category_id"
     t.string   "title",      null: false
     t.interval "duration"
     t.enum     "types", enum_type: :types, array: true
@@ -117,6 +126,13 @@ ActiveRecord::Schema.define(version: version) do
     t.datetime "updated_at", null: false
   end
 
+  create_table "users", schema: "internal", force: :cascade do |t|
+    t.string   "email"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["email"], name: "index_internal_users_on_email", unique: true
+  end
+
   create_table "activities", force: :cascade do |t|
     t.integer  "author_id"
     t.string   "title"

data/spec/spec_helper.rb

@@ -22,7 +22,7 @@ cleaner = ->() do
 end
 
 load File.join('schema.rb')
-Dir.glob(File.join('spec', '{models,factories,mocks}', '*.rb')) do |file|
+Dir.glob(File.join('spec', '{models,factories,mocks}', '**', '*.rb')) do |file|
   require file[5..-4]
 end
 
@@ -39,6 +39,7 @@ RSpec.configure do |config|
 
   # Handles acton before rspec initialize
   config.before(:suite) do
+    Torque::PostgreSQL.config.schemas.whitelist << 'internal'
     ActiveSupport::Deprecation.silenced = true
     DatabaseCleaner.clean_with(:truncation)
   end