torque-postgresql 2.2.3 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e9379e388022831a9441cb6b3b646ff8bdea7340cba61f0dd197bcdbf589f72
-  data.tar.gz: cfb88b94086027202e92a2120ad8ba1a5e939ef089aea5dcdfd85e05a7d122ea
+  metadata.gz: c2a382953b6a3c1d87e05837454cdf523f4be237fdd66c85f0b155278eafa203
+  data.tar.gz: e72effb133a0ae945b85b1d46de72b16a098eb1d469f3720926b0267e7f3c11b
 SHA512:
-  metadata.gz: 809642eb8f6ee574e7b3b9557590baa58624fec54d1c69b6f341999dfc4217aea5010abc1b438119b3213f958918ce00ddd1af1df3a4714321b1f6153f8ee57d
-  data.tar.gz: e81cf089a977d964326548144b14dd4ab7ce4be0612f2e923e34add1aa951aa2e5467daaa544da42ac17773fb2cc047335a297f3807a1e72f8dc1942f1df4195
+  metadata.gz: 554eb1ae3c30abd27acbbd9ce7e2f78d37e42c730ed811b5d617209cbb12a2c1bd34163f63ab25273f542e1cb6bfc36ee6d64484fd66f8a5b489e4aaea6ae628
+  data.tar.gz: d018ee26970f64a83e552f1929e55e281235054064771a851e5b4fc714e69a95e6247e95338deffe8b1732d6ae2dad1bc2b5602146a1c4fb4d763ad19fc13c97

data/README.rdoc

@@ -128,6 +128,23 @@ reconfigured on the model, and then can be used during querying process.
 
   {Learn more}[link:classes/Torque/PostgreSQL/AuxiliaryStatement.html]
 
+* Multiple Schemas
+
+Allows models and modules to have a schema associated with them, so that
+developers can better organize their tables into schemas and build features in
+a way that the database can better represent how they are separated.
+
+   create_schema "internal", force: :cascade
+
+   module Internal
+     class User < ActiveRecord::Base
+       self.schema = 'internal'
+     end
+   end
+
+   Internal::User.all
+
+  {Learn more}[link:classes/Torque/PostgreSQL/Adapter/DatabaseStatements.html]
 
 == Download and installation
 

data/lib/torque/postgresql/adapter/database_statements.rb

@@ -12,6 +12,26 @@ module Torque
           @_dump_mode = !!!@_dump_mode
         end
 
+        # List of schemas blocked by the application in the current connection
+        def schemas_blacklist
+          @schemas_blacklist ||= Torque::PostgreSQL.config.schemas.blacklist +
+            (@config.dig(:schemas, 'blacklist') || [])
+        end
+
+        # List of schemas used by the application in the current connection
+        def schemas_whitelist
+          @schemas_whitelist ||= Torque::PostgreSQL.config.schemas.whitelist +
+            (@config.dig(:schemas, 'whitelist') || [])
+        end
+
+        # A list of schemas on the search path sanitized
+        def schemas_search_path_sanitized
+          @schemas_search_path_sanitized ||= begin
+            db_user = @config[:username] || ENV['USER'] || ENV['USERNAME']
+            schema_search_path.split(',').map { |item| item.strip.sub('"$user"', db_user) }
+          end
+        end
+
         # Check if a given type is valid.
         def valid_type?(type)
           super || extended_types.include?(type)
@@ -22,6 +42,17 @@ module Torque
           EXTENDED_DATABASE_TYPES
         end
 
+        # Checks if a given schema exists in the database. If +filtered+ is
+        # given as false, then it will check regardless of whitelist and
+        # blacklist
+        def schema_exists?(name, filtered: true)
+          return user_defined_schemas.include?(name.to_s) if filtered
+
+          query_value(<<-SQL) == 1
+            SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = '#{name}'
+          SQL
+        end
+
         # Returns true if type exists.
         def type_exists?(name)
           user_defined_types.key? name.to_s
@@ -115,18 +146,41 @@ module Torque
         # Get the list of inherited tables associated with their parent tables
         def inherited_tables
           tables = query(<<-SQL, 'SCHEMA')
-            SELECT child.relname             AS table_name,
-                   array_agg(parent.relname) AS inheritances
+            SELECT inhrelid::regclass  AS table_name,
+                   inhparent::regclass AS inheritances
             FROM pg_inherits
             JOIN pg_class parent ON pg_inherits.inhparent = parent.oid
             JOIN pg_class child  ON pg_inherits.inhrelid  = child.oid
-            GROUP BY child.relname, pg_inherits.inhrelid
-            ORDER BY pg_inherits.inhrelid
+            ORDER BY inhrelid
           SQL
 
-          tables.map do |(table, refs)|
-            [table, PG::TextDecoder::Array.new.decode(refs)]
-          end.to_h
+          tables.each_with_object({}) do |(child, parent), result|
+            (result[child] ||= []) << parent
+          end
+        end
+
+        # Get the list of schemas that were created by the user
+        def user_defined_schemas
+          query_values(user_defined_schemas_sql, 'SCHEMA')
+        end
+
+        # Build the query for allowed schemas
+        def user_defined_schemas_sql
+          conditions = []
+          conditions << <<-SQL if schemas_blacklist.any?
+            nspname NOT LIKE ANY (ARRAY['#{schemas_blacklist.join("', '")}'])
+          SQL
+
+          conditions << <<-SQL if schemas_whitelist.any?
+            nspname LIKE ANY (ARRAY['#{schemas_whitelist.join("', '")}'])
+          SQL
+
+          <<-SQL.squish
+            SELECT nspname
+            FROM pg_catalog.pg_namespace
+            WHERE 1=1 AND #{conditions.join(' AND ')}
+            ORDER BY oid
+          SQL
         end
 
         # Get the list of columns, and their definition, but only from the

data/lib/torque/postgresql/adapter/schema_definitions.rb

@@ -12,16 +12,16 @@ module Torque
           args.each { |name| column(name, :interval, **options) }
         end
 
-        # Creates a column with an enum type, needing to specify the subtype,
+        # Creates a column with an enum type, needing to specify the enum_type,
         # which is basically the name of the type defined prior creating the
         # column
         def enum(*args, **options)
-          subtype = options.delete(:subtype)
-          args.each { |name| column(name, (subtype || name), **options) }
+          enum_type = [options.delete(:subtype), options.delete(:enum_type)].compact.first
+          args.each { |name| column(name, (enum_type || name), **options) }
         end
 
         # Creates a column with an enum array type, needing to specify the
-        # subtype, which is basically the name of the type defined prior
+        # enum_type, which is basically the name of the type defined prior
         # creating the column
         def enum_set(*args, **options)
           super(*args, **options.merge(array: true))
@@ -47,7 +47,7 @@ module Torque
 
       if ActiveRecord::ConnectionAdapters::PostgreSQL.const_defined?('ColumnDefinition')
         module ColumnDefinition
-          attr_accessor :subtype
+          attr_accessor :subtype, :enum_type
         end
 
         ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnDefinition.include ColumnDefinition

data/lib/torque/postgresql/adapter/schema_dumper.rb

@@ -14,6 +14,7 @@ module Torque
 
         def extensions(stream) # :nodoc:
           super
+          user_defined_schemas(stream)
           user_defined_types(stream)
         end
 
@@ -22,12 +23,12 @@ module Torque
           column.type == :enum_set ? :enum : super
         end
 
-        # Adds +:subtype+ option to the default set
+        # Adds +:enum_type+ option to the default set
         def prepare_column_options(column)
           spec = super
 
-          if subtype = schema_subtype(column)
-            spec[:subtype] = subtype
+          if enum_type = schema_enum_type(column)
+            spec[:enum_type] = enum_type
           end
 
           spec
@@ -35,13 +36,15 @@ module Torque
 
         private
 
-          def schema_subtype(column)
+          def schema_enum_type(column)
             column.sql_type.to_sym.inspect if column.type == :enum || column.type == :enum_set
           end
 
           def tables(stream) # :nodoc:
             inherited_tables = @connection.inherited_tables
-            sorted_tables = @connection.tables.sort - @connection.views
+            sorted_tables = (@connection.tables - @connection.views).sort_by do |table_name|
+              table_name.split(/(?:public)?\./).reverse
+            end
 
             stream.puts "  # These are the common tables"
             (sorted_tables - inherited_tables.keys).each do |table_name|
@@ -58,7 +61,7 @@ module Torque
 
                 # Add the inherits setting
                 sub_stream.rewind
-                inherits.map!(&:to_sym)
+                inherits.map! { |parent| parent.to_s.sub(/\Apublic\./, '') }
                 inherits = inherits.first if inherits.size === 1
                 inherits = ", inherits: #{inherits.inspect} do |t|"
                 table_dump = sub_stream.read.gsub(/ do \|t\|$/, inherits)
@@ -84,12 +87,27 @@ module Torque
             triggers(stream) if defined?(::Fx::SchemaDumper::Trigger)
           end
 
+          # Make sure to remove the schema from the table name
+          def remove_prefix_and_suffix(table)
+            super(table.sub(/\A[a-z0-9_]*\./, ''))
+          end
+
+          # Dump user defined schemas
+          def user_defined_schemas(stream)
+            return if (list = (@connection.user_defined_schemas - ['public'])).empty?
+
+            stream.puts "  # Custom schemas defined in this database."
+            list.each { |name| stream.puts "  create_schema \"#{name}\", force: :cascade" }
+            stream.puts
+          end
+
           # Dump user defined types like enum
           def user_defined_types(stream)
             types = @connection.user_defined_types('e')
             return unless types.any?
 
-            stream.puts "  # These are user-defined types used on this database"
+            stream.puts "  # Custom types defined in this database."
+            stream.puts "  # Note that some types may not work with other database engines. Be careful if changing database."
             types.sort_by(&:first).each { |(name, type)| send(type.to_sym, name, stream) }
             stream.puts
           rescue => e

data/lib/torque/postgresql/adapter/schema_statements.rb

@@ -7,6 +7,21 @@ module Torque
 
         TableDefinition = ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
 
+        # Create a new schema
+        def create_schema(name, options = {})
+          drop_schema(name, options) if options[:force]
+
+          check = 'IF NOT EXISTS' if options.fetch(:check, true)
+          execute("CREATE SCHEMA #{check} #{quote_schema_name(name.to_s)}")
+        end
+
+        # Drop an existing schema
+        def drop_schema(name, options = {})
+          force = options.fetch(:force, '').upcase
+          check = 'IF EXISTS' if options.fetch(:check, true)
+          execute("DROP SCHEMA #{check} #{quote_schema_name(name.to_s)} #{force}")
+        end
+
         # Drops a type.
         def drop_type(name, options = {})
           force = options.fetch(:force, '').upcase
@@ -79,12 +94,37 @@ module Torque
 
         # Rewrite the method that creates tables to easily accept extra options
         def create_table(table_name, **options, &block)
+          table_name = "#{options[:schema]}.#{table_name}" if options[:schema].present?
+
           options[:id] = false if options[:inherits].present? &&
             options[:primary_key].blank? && options[:id].blank?
 
           super table_name, **options, &block
         end
 
+        # Add the schema option when extracting table options
+        def table_options(table_name)
+          parts = table_name.split('.').reverse
+          return super unless parts.size == 2 && parts[1] != 'public'
+
+          (super || {}).merge(schema: parts[1])
+        end
+
+        # When dumping the schema we need to add all schemas, not only those
+        # active for the current +schema_search_path+
+        def quoted_scope(name = nil, type: nil)
+          return super unless name.nil?
+
+          super.merge(schema: "ANY ('{#{user_defined_schemas.join(',')}}')")
+        end
+
+        # Fix the query to include the schema on tables names when dumping
+        def data_source_sql(name = nil, type: nil)
+          return super unless name.nil?
+
+          super.sub('SELECT c.relname FROM', "SELECT n.nspname || '.' || c.relname FROM")
+        end
+
         private
 
           def quote_enum_values(name, values, options)

data/lib/torque/postgresql/adapter.rb

@@ -31,9 +31,9 @@ module Torque
         )
       end
 
-      # Add `inherits` to the list of extracted table options
+      # Add `inherits` and `schema` to the list of extracted table options
       def extract_table_options!(options)
-        super.merge(options.extract!(:inherits))
+        super.merge(options.extract!(:inherits, :schema))
       end
 
       # Allow filtered bulk insert by adding the where clause. This method is

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
 
@@ -24,6 +36,11 @@ module Torque
 
           # Define helper methods to return the class of the given records
           subclass.auxiliary_statement record_class do |cte|
+            ActiveSupport::Deprecation.warn(<<~MSG.squish)
+              Inheritance does not use this auxiliary statement and it can be removed.
+              You can replace it with `model.select_extra_values << 'tableoid::regclass'`.
+            MSG
+
             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))
@@ -36,18 +53,11 @@ module Torque
           # 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?
-
-            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'])
+            klass = self.class
+            next klass.table_name unless klass.physically_inheritances?
 
-            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
 

data/lib/torque/postgresql/config.rb

@@ -40,6 +40,19 @@ module Torque
       end.to_h
     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 associations features
     config.nested(:associations) do |assoc|
 

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

@@ -5,16 +5,26 @@ 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 a schema
+        def create_schema(*args, &block)
+          record(:create_schema, args, &block)
+        end
+
+        # Inverts the creation of a schema
+        def invert_create_schema(args)
+          [:drop_schema, [args.first]]
+        end
+
         # Records the creation of the enum to be reverted.
         def create_enum(*args, &block)
           record(:create_enum, args, &block)

data/lib/torque/postgresql/reflection/abstract_reflection.rb

@@ -6,9 +6,6 @@ module Torque
       module AbstractReflection
         AREL_ATTR = ::Arel::Attributes::Attribute
 
-        ARR_NO_CAST = 'bigint'
-        ARR_CAST = 'bigint[]'
-
         # Check if the foreign key actually exists
         def connected_through_array?
           false
@@ -40,34 +37,29 @@ module Torque
           result
         end
 
-        # Build the id constraint checking if both types are perfect matching
+        # Build the id constraint checking if both types are perfect matching.
+        # The klass attribute (left side) will always be a column attribute
         def build_id_constraint(klass_attr, source_attr)
           return klass_attr.eq(source_attr) unless connected_through_array?
 
           # Klass and key are associated with the reflection Class
           klass_type = klass.columns_hash[join_keys.key.to_s]
-          # active_record and foreign_key are associated with the source Class
-          source_type = active_record.columns_hash[join_keys.foreign_key.to_s]
 
-          # If both are attributes but the left side is not an array, and the
-          # right side is, use the ANY operation
-          any_operation = arel_array_to_any(klass_attr, source_attr, klass_type, source_type)
-          return klass_attr.eq(any_operation) if any_operation
+          # Apply an ANY operation which checks if the single value on the left
+          # side exists in the array on the right side
+          if source_attr.is_a?(AREL_ATTR)
+            any_value = [klass_attr, source_attr]
+            any_value.reverse! if klass_type.try(:array?)
+            return any_value.shift.eq(::Arel::Nodes::NamedFunction.new('ANY', any_value))
+          end
 
           # If the left side is not an array, just use the IN condition
           return klass_attr.in(source_attr) unless klass_type.try(:array)
 
-          # Decide if should apply a cast to ensure same type comparision
-          should_cast = klass_type.type.eql?(:integer) && source_type.type.eql?(:integer)
-          should_cast &= !klass_type.sql_type.eql?(source_type.sql_type)
-          should_cast |= !(klass_attr.is_a?(AREL_ATTR) && source_attr.is_a?(AREL_ATTR))
-
-          # Apply necessary transformations to values
-          klass_attr = cast_constraint_to_array(klass_type, klass_attr, should_cast)
-          source_attr = cast_constraint_to_array(source_type, source_attr, should_cast)
-
-          # Return the overlap condition
-          klass_attr.overlaps(source_attr)
+          # Build the overlap condition (array && array) ensuring that the right
+          # side has the same type as the left side
+          source_attr = ::Arel::Nodes.build_quoted(Array.wrap(source_attr))
+          klass_attr.overlaps(source_attr.cast(klass_type.sql_type_metadata.sql_type))
         end
 
         if PostgreSQL::AR610
@@ -85,24 +77,6 @@ module Torque
 
             build_id_constraint(klass_attr, source_attr)
           end
-
-          # Prepare a value for an array constraint overlap condition
-          def cast_constraint_to_array(type, value, should_cast)
-            base_ready = type.try(:array) && value.is_a?(AREL_ATTR)
-            return value if base_ready && (type.sql_type.eql?(ARR_NO_CAST) || !should_cast)
-
-            value = ::Arel::Nodes.build_quoted(Array.wrap(value)) unless base_ready
-            value = value.cast(ARR_CAST) if should_cast
-            value
-          end
-
-          # Check if it's possible to turn both attributes into an ANY condition
-          def arel_array_to_any(klass_attr, source_attr, klass_type, source_type)
-            return unless !klass_type.try(:array) && source_type.try(:array) &&
-              klass_attr.is_a?(AREL_ATTR) && source_attr.is_a?(AREL_ATTR)
-
-            ::Arel::Nodes::NamedFunction.new('ANY', [source_attr])
-          end
       end
 
       ::ActiveRecord::Reflection::AbstractReflection.prepend(AbstractReflection)

data/lib/torque/postgresql/schema_cache.rb

@@ -117,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 = '2.2.3'
+    VERSION = '2.3.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/lib/torque/range.rb

@@ -1,6 +1,7 @@
 module Torque
   module Range
     def intersection(other)
+      ActiveSupport::Deprecation.warn('Range extensions will be removed in future versions')
       raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
 
       new_min = self.cover?(other.min) ? other.min : other.cover?(min) ? min : nil
@@ -11,6 +12,7 @@ module Torque
     alias_method :&, :intersection
 
     def union(other)
+      ActiveSupport::Deprecation.warn('Range extensions will be removed in future versions')
       raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
 
       ([min, other.min].min)..([max, other.max].max)

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

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-version = 77
+version = 1
 
 return if ActiveRecord::Migrator.current_version == version
 ActiveRecord::Schema.define(version: version) do
@@ -20,7 +20,11 @@ ActiveRecord::Schema.define(version: version) do
   enable_extension "pgcrypto"
   enable_extension "plpgsql"
 
-  # These are user-defined types used on this database
+  # 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"], force: :cascade
   create_enum "specialties", ["books", "movies", "plays"], force: :cascade
   create_enum "roles", ["visitor", "assistant", "manager", "admin"], force: :cascade
@@ -53,8 +57,8 @@ ActiveRecord::Schema.define(version: version) do
     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.enum     "type", enum_type: :types
+    t.enum     "conflicts", enum_type: :conflicts, array: true
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
   end
@@ -62,13 +66,13 @@ ActiveRecord::Schema.define(version: version) do
   create_table "authors", force: :cascade do |t|
     t.string   "name"
     t.string   "type"
-    t.enum     "specialty", subtype: :specialties
+    t.enum     "specialty", enum_type: :specialties
   end
 
   create_table "texts", force: :cascade do |t|
     t.integer  "user_id"
     t.string   "content"
-    t.enum     "conflict",  subtype: :conflicts
+    t.enum     "conflict",  enum_type: :conflicts
   end
 
   create_table "comments", force: :cascade do |t|
@@ -84,7 +88,7 @@ ActiveRecord::Schema.define(version: version) do
   create_table "courses", force: :cascade do |t|
     t.string   "title",      null: false
     t.interval "duration"
-    t.enum     "types", subtype: :types, array: true
+    t.enum     "types", enum_type: :types, array: true
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
   end
@@ -98,7 +102,7 @@ ActiveRecord::Schema.define(version: version) do
     t.integer  "activity_id"
     t.string   "title"
     t.text     "content"
-    t.enum     "status",    subtype: :content_status
+    t.enum     "status",    enum_type: :content_status
     t.index ["author_id"], name: "index_posts_on_author_id", using: :btree
   end
 
@@ -111,16 +115,23 @@ ActiveRecord::Schema.define(version: version) do
 
   create_table "users", force: :cascade do |t|
     t.string   "name",       null: false
-    t.enum     "role",                    subtype: :roles, default: :visitor
+    t.enum     "role",                    enum_type: :roles, default: :visitor
+    t.datetime "created_at", null: false
+    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"
     t.boolean  "active"
-    t.enum     "kind",                    subtype: :types
+    t.enum     "kind",                    enum_type: :types
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
   end

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
+    ActiveSupport::Deprecation.silenced = true
     DatabaseCleaner.clean_with(:truncation)
   end
 
@@ -46,10 +47,6 @@ RSpec.configure do |config|
     DatabaseCleaner.strategy = :transaction
   end
 
-  config.before(:each, js: true) do
-    DatabaseCleaner.strategy = :truncation
-  end
-
   config.before(:each) do
     DatabaseCleaner.start
   end

data/spec/tests/arel_spec.rb

@@ -68,26 +68,37 @@ RSpec.describe 'Arel' do
 
     it 'works properly when column is an array' do
       expect { connection.add_column(:authors, :tag_ids, :bigint, array: true, default: []) }.not_to raise_error
-      expect(Author.columns_hash['tag_ids'].default).to eq([])
+      expect(Author.new.tag_ids).to eq([])
     end
 
-    it 'works with an array with enum values' do
+    it 'works with an array with enum values for a new enum' do
+      value = ['a', 'b']
+
+      expect do
+        connection.create_enum(:samples, %i[a b c d])
+        connection.add_column(:authors, :samples, :samples, array: true, default: value)
+      end.not_to raise_error
+
+      expect(Author.new.samples).to eq(value)
+    end
+
+    it 'works with an array with enum values for an existing enum' do
       value = ['visitor', 'assistant']
       expect { connection.add_column(:authors, :roles, :roles, array: true, default: value) }.not_to raise_error
-      expect(Author.columns_hash['roles'].default).to eq(value)
+      expect(Author.new.roles).to eq(value)
     end
 
     it 'works with multi dimentional array' do
       value = [['1', '2'], ['3', '4']]
       expect { connection.add_column(:authors, :tag_ids, :string, array: true, default: value) }.not_to raise_error
-      expect(Author.columns_hash['tag_ids'].default).to eq(value)
+      expect(Author.new.tag_ids).to eq(value)
     end
 
     it 'works with change column default value' do
       value = ['2', '3']
       connection.add_column(:authors, :tag_ids, :string, array: true)
       expect { connection.change_column_default(:authors, :tag_ids, { from: nil, to: value }) }.not_to raise_error
-      expect(Author.columns_hash['tag_ids'].default).to eq(value)
+      expect(Author.new.tag_ids).to eq(value)
     end
   end
 

data/spec/tests/belongs_to_many_spec.rb

@@ -392,4 +392,53 @@ RSpec.describe 'BelongsToMany' do
       end
     end
   end
+
+  context 'using uuid' do
+    let(:connection) { ActiveRecord::Base.connection }
+    let(:game) { Class.new(ActiveRecord::Base) }
+    let(:player) { Class.new(ActiveRecord::Base) }
+    let(:other) { player.create }
+
+    # TODO: Set as a shred example
+    before do
+      connection.create_table(:players, id: :uuid) { |t| t.string :name }
+      connection.create_table(:games, id: :uuid) { |t| t.uuid :player_ids, array: true }
+
+      options = { anonymous_class: player, foreign_key: :player_ids }
+      options[:inverse_of] = false if Torque::PostgreSQL::AR610
+
+      game.table_name = 'games'
+      player.table_name = 'players'
+      game.belongs_to_many :players, **options
+    end
+
+    subject { game.create }
+
+    it 'loads associated records' do
+      subject.update(player_ids: [other.id])
+      expect(subject.players.to_sql).to be_eql(<<-SQL.squish)
+        SELECT "players".* FROM "players" WHERE "players"."id" IN ('#{other.id}')
+      SQL
+
+      expect(subject.players.load).to be_a(ActiveRecord::Associations::CollectionProxy)
+      expect(subject.players.to_a).to be_eql([other])
+    end
+
+    it 'can preload records' do
+      records = 5.times.map { player.create }
+      subject.players.concat(records)
+
+      entries = game.all.includes(:players).load
+
+      expect(entries.size).to be_eql(1)
+      expect(entries.first.players).to be_loaded
+      expect(entries.first.players.size).to be_eql(5)
+    end
+
+    it 'can joins records' do
+      query = game.all.joins(:players)
+      expect(query.to_sql).to match(/INNER JOIN "players"/)
+      expect { query.load }.not_to raise_error
+    end
+  end
 end

data/spec/tests/enum_set_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe 'Enum' do
     subject { table_definition.new(connection, 'articles') }
 
     it 'can be defined as an array' do
-      subject.enum(:content_status, array: true)
+      subject.enum(:content_status, array: true, enum_type: :content_status)
       expect(subject['content_status'].name).to be_eql('content_status')
       expect(subject['content_status'].type).to be_eql(:content_status)
 
@@ -42,18 +42,19 @@ RSpec.describe 'Enum' do
   end
 
   context 'on schema' do
+    let(:dump_result) do
+      ActiveRecord::SchemaDumper.dump(connection, (dump_result = StringIO.new))
+      dump_result.string
+    end
+
     it 'can be used on tables' do
-      dump_io = StringIO.new
-      checker = /t\.enum +"conflicts", +array: true, +subtype: :conflicts/
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      expect(dump_io.string).to match checker
+      checker = /t\.enum +"conflicts", +array: true, +enum_type: :conflicts/
+      expect(dump_result).to match checker
     end
 
     xit 'can have a default value as an array of symbols' do
-      dump_io = StringIO.new
-      checker = /t\.enum +"types", +default: \[:A, :B\], +array: true, +subtype: :types/
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      expect(dump_io.string).to match checker
+      checker = /t\.enum +"types", +default: \[:A, :B\], +array: true, +enum_type: :types/
+      expect(dump_result).to match checker
     end
   end
 

data/spec/tests/enum_spec.rb

@@ -99,13 +99,19 @@ RSpec.describe 'Enum' do
     end
 
     it 'can be used in a multiple form' do
-      subject.enum('foo', 'bar', 'baz', subtype: :content_status)
+      subject.enum('foo', 'bar', 'baz', enum_type: :content_status)
       expect(subject['foo'].type).to be_eql(:content_status)
       expect(subject['bar'].type).to be_eql(:content_status)
       expect(subject['baz'].type).to be_eql(:content_status)
     end
 
     it 'can have custom type' do
+      subject.enum('foo', enum_type: :content_status)
+      expect(subject['foo'].name).to be_eql('foo')
+      expect(subject['foo'].type).to be_eql(:content_status)
+    end
+
+    it 'can use the deprecated subtype option' do
       subject.enum('foo', subtype: :content_status)
       expect(subject['foo'].name).to be_eql('foo')
       expect(subject['foo'].type).to be_eql(:content_status)
@@ -143,13 +149,13 @@ RSpec.describe 'Enum' do
     it 'can be used on tables too' do
       dump_io = StringIO.new
       ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      expect(dump_io.string).to match /t\.enum +"status", +subtype: :content_status/
+      expect(dump_io.string).to match /t\.enum +"status", +enum_type: :content_status/
     end
 
     it 'can have a default value as symbol' do
       dump_io = StringIO.new
       ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      expect(dump_io.string).to match /t\.enum +"role", +default: :visitor, +subtype: :roles/
+      expect(dump_io.string).to match /t\.enum +"role", +default: :visitor, +enum_type: :roles/
     end
   end
 

data/spec/tests/has_many_spec.rb

@@ -411,4 +411,50 @@ RSpec.describe 'HasMany' do
       expect { query.load }.not_to raise_error
     end
   end
+
+  context 'using uuid' do
+    let(:connection) { ActiveRecord::Base.connection }
+    let(:game) { Class.new(ActiveRecord::Base) }
+    let(:player) { Class.new(ActiveRecord::Base) }
+
+    # TODO: Set as a shred example
+    before do
+      connection.create_table(:players, id: :uuid) { |t| t.string :name }
+      connection.create_table(:games, id: :uuid) { |t| t.uuid :player_ids, array: true }
+
+      options = { anonymous_class: game, foreign_key: :player_ids }
+      options[:inverse_of] = false if Torque::PostgreSQL::AR610
+
+      game.table_name = 'games'
+      player.table_name = 'players'
+      player.has_many :games, array: true, **options
+    end
+
+    subject { player.create }
+
+    it 'loads associated records' do
+      expect(subject.games.to_sql).to match(Regexp.new(<<-SQL.squish))
+        SELECT "games"\\.\\* FROM "games"
+        WHERE \\(?"games"\\."player_ids" && ARRAY\\['#{subject.id}'\\]::uuid\\[\\]\\)?
+      SQL
+
+      expect(subject.games.load).to be_a(ActiveRecord::Associations::CollectionProxy)
+      expect(subject.games.to_a).to be_eql([])
+    end
+
+    it 'can preload records' do
+      5.times { game.create(player_ids: [subject.id]) }
+      entries = player.all.includes(:games).load
+
+      expect(entries.size).to be_eql(1)
+      expect(entries.first.games).to be_loaded
+      expect(entries.first.games.size).to be_eql(5)
+    end
+
+    it 'can joins records' do
+      query = player.all.joins(:games)
+      expect(query.to_sql).to match(/INNER JOIN "games"/)
+      expect { query.load }.not_to raise_error
+    end
+  end
 end

data/spec/tests/schema_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+RSpec.describe 'Schema' do
+  let(:connection) { ActiveRecord::Base.connection }
+
+  before do
+    connection.instance_variable_set(:@schmeas_blacklist, nil)
+    connection.instance_variable_set(:@schmeas_whitelist, nil)
+  end
+
+  context 'on migration' do
+    it 'can check for existance' do
+      expect(connection.schema_exists?(:information_schema)).to be_falsey
+      expect(connection.schema_exists?(:information_schema, filtered: false)).to be_truthy
+    end
+
+    it 'can be created' do
+      expect(connection.schema_exists?(:legacy, filtered: false)).to be_falsey
+      connection.create_schema(:legacy)
+      expect(connection.schema_exists?(:legacy, filtered: false)).to be_truthy
+    end
+
+    it 'can be deleted' do
+      expect(connection.schema_exists?(:legacy, filtered: false)).to be_falsey
+
+      connection.create_schema(:legacy)
+      expect(connection.schema_exists?(:legacy, filtered: false)).to be_truthy
+
+      connection.drop_schema(:legacy)
+      expect(connection.schema_exists?(:legacy, filtered: false)).to be_falsey
+    end
+
+    it 'works with whitelist' do
+      expect(connection.schema_exists?(:legacy)).to be_falsey
+      connection.create_schema(:legacy)
+
+      expect(connection.schema_exists?(:legacy)).to be_falsey
+      expect(connection.schema_exists?(:legacy, filtered: false)).to be_truthy
+
+      connection.schemas_whitelist.push('legacy')
+      expect(connection.schema_exists?(:legacy)).to be_truthy
+    end
+  end
+
+  context 'on schema' do
+    let(:dump_result) do
+      ActiveRecord::SchemaDumper.dump(connection, (dump_result = StringIO.new))
+      dump_result.string
+    end
+
+    it 'does not add when there is no extra schemas' do
+      connection.drop_schema(:internal, force: :cascade)
+      expect(dump_result).not_to match /Custom schemas defined in this database/
+    end
+
+    it 'does not include tables from blacklisted schemas' do
+      connection.schemas_blacklist.push('internal')
+      expect(dump_result).not_to match /create_table \"users\",.*schema: +"internal"/
+    end
+
+    context 'with internal schema whitelisted' do
+      before { connection.schemas_whitelist.push('internal') }
+
+      it 'dumps the schemas' do
+        expect(dump_result).to match /create_schema \"internal\"/
+      end
+
+      it 'shows the internal users table in the connection tables list' do
+        expect(connection.tables).to include('internal.users')
+      end
+
+      it 'dumps tables on whitelisted schemas' do
+        expect(dump_result).to match /create_table \"users\",.*schema: +"internal"/
+      end
+    end
+  end
+
+  context 'on relation' do
+    let(:model) { Internal::User }
+
+    it 'adds the schema to the query' do
+      expect(model.all.to_sql).to match(/FROM "internal"."users"/)
+    end
+
+    it 'can load the schema from the module' do
+      allow(Internal).to receive(:schema).and_return('internal')
+      allow(model).to receive(:schema).and_return(nil)
+
+      expect(model.all.to_sql).to match(/FROM "internal"."users"/)
+    end
+  end
+end

data/spec/tests/table_inheritance_spec.rb

@@ -73,37 +73,33 @@ RSpec.describe 'TableInheritance' do
   end
 
   context 'on schema' do
-    it 'dumps single inheritance with body' do
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
+    let(:dump_result) do
+      ActiveRecord::SchemaDumper.dump(connection, (dump_result = StringIO.new))
+      dump_result.string
+    end
 
+    it 'dumps single inheritance with body' do
       parts = '"activity_books"'
       parts << ', id: false'
       parts << ', force: :cascade'
-      parts << ', inherits: :activities'
-      expect(dump_io.string).to match(/create_table #{parts} do /)
+      parts << ', inherits: "activities"'
+      expect(dump_result).to match(/create_table #{parts} do /)
     end
 
     it 'dumps single inheritance without body' do
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-
       parts = '"activity_post_samples"'
       parts << ', id: false'
       parts << ', force: :cascade'
-      parts << ', inherits: :activity_posts'
-      expect(dump_io.string).to match(/create_table #{parts}(?! do \|t\|)/)
+      parts << ', inherits: "activity_posts"'
+      expect(dump_result).to match(/create_table #{parts}(?! do \|t\|)/)
     end
 
     it 'dumps multiple inheritance' do
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-
       parts = '"activity_posts"'
       parts << ', id: false'
       parts << ', force: :cascade'
-      parts << ', inherits: (\[:images, :activities\]|\[:activities, :images\])'
-      expect(dump_io.string).to match(/create_table #{parts}/)
+      parts << ', inherits: (\["images", "activities"\]|\["activities", "images"\])'
+      expect(dump_result).to match(/create_table #{parts}/)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 2.2.3
+  version: 2.3.0
 platform: ruby
 authors:
 - Carlos Silva
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-31 00:00:00.000000000 Z
+date: 2022-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -17,6 +17,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,6 +27,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -155,7 +161,7 @@ dependencies:
 description: Add support to complex resources of PostgreSQL, like data types, array
   associations, and auxiliary statements (CTE)
 email:
-- carlinhus.fsilva@gmail.com
+- me@carlosfsilva.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -231,6 +237,7 @@ files:
 - lib/torque/postgresql/relation/inheritance.rb
 - lib/torque/postgresql/relation/merger.rb
 - lib/torque/postgresql/schema_cache.rb
+- lib/torque/postgresql/table_name.rb
 - lib/torque/postgresql/version.rb
 - lib/torque/range.rb
 - spec/en.yml
@@ -254,6 +261,7 @@ files:
 - spec/models/course.rb
 - spec/models/geometry.rb
 - spec/models/guest_comment.rb
+- spec/models/internal/user.rb
 - spec/models/item.rb
 - spec/models/post.rb
 - spec/models/question.rb
@@ -281,13 +289,18 @@ files:
 - spec/tests/quoting_spec.rb
 - spec/tests/range_spec.rb
 - spec/tests/relation_spec.rb
+- spec/tests/schema_spec.rb
 - spec/tests/table_inheritance_spec.rb
 homepage: https://github.com/crashtech/torque-postgresql
 licenses:
 - MIT
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/crashtech/torque-postgresql
+  bug_tracker_uri: https://github.com/crashtech/torque-postgresql/issues
 post_install_message:
-rdoc_options: []
+rdoc_options:
+- "--title"
+- Torque PostgreSQL
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -327,6 +340,7 @@ test_files:
 - spec/models/course.rb
 - spec/models/geometry.rb
 - spec/models/guest_comment.rb
+- spec/models/internal/user.rb
 - spec/models/item.rb
 - spec/models/post.rb
 - spec/models/question.rb
@@ -354,4 +368,5 @@ test_files:
 - spec/tests/quoting_spec.rb
 - spec/tests/range_spec.rb
 - spec/tests/relation_spec.rb
+- spec/tests/schema_spec.rb
 - spec/tests/table_inheritance_spec.rb