torque-postgresql 2.4.4 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3533ab897fec6762e3d3165d9b4795bf3167409724bfc9c77acd845747ee698c
-  data.tar.gz: 76e868de2923ff393e4fe8f9a836a4cd258588726e522811515b70bec1f5afbd
+  metadata.gz: d4fac19ef8680f477df0f79502331ddda06266658a54c8128321d68145a9f18b
+  data.tar.gz: 0e93ec49f80d40ec9ce9b7fcc5ef0eff65a882cad79a63e5429657ad9c66691b
 SHA512:
-  metadata.gz: 886466cc45f9581d18e7fabf3a287ad17b318be0a447fe611f33aa403e63e74de25d9f230f5ddf1475c6dc12e3658d54e98378af57ec8c92d7e5d6503e87a033
-  data.tar.gz: 0a940cb293cf793e5ca884203b328f346b0276ada4a1ea682ec0677c051d415c31f31abcb27dd2d27c197060335d8117556d87607367f4bc8b81a8a104e95280
+  metadata.gz: 4a9abd492b544296c29e0949e1ad0ad4852a1ed0c48379551e5ffbbaad7018579cad994ac2a841231603bdddd8da4b448d7771a9086312289f818124d842d6a6
+  data.tar.gz: 8019255d20eff471ed177078e1bd6042a0a9b95752d32578bdb8ce86afdf9cffbefa8ed181caab0143f0dbbf80cfc39c99fd005cfc2b28089687b26a635268ef

data/README.rdoc

@@ -128,23 +128,6 @@ 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,26 +12,6 @@ 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)
@@ -42,17 +22,6 @@ 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
@@ -65,6 +34,15 @@ module Torque
           execute("SET SESSION IntervalStyle TO 'iso_8601'", 'SCHEMA')
         end
 
+        # Since enums create new types, type map needs to be rebooted to include
+        # the new ones, both normal and array one
+        def create_enum(name, *)
+          super
+
+          oid = query_value("SELECT #{quote(name)}::regtype::oid", "SCHEMA").to_i
+          load_additional_types([oid])
+        end
+
         # Change some of the types being mapped
         def initialize_type_map(m = type_map)
           super
@@ -85,7 +63,7 @@ module Torque
 
         # Add the composite types to be loaded too.
         def torque_load_additional_types(oids = nil)
-          filter = "AND     a.typelem::integer IN (%s)" % oids.join(", ") if oids
+          filter = ("AND     a.typelem::integer IN (%s)" % oids.join(', ')) if oids
 
           query = <<-SQL
             SELECT      a.typelem AS oid, t.typname, t.typelem,
@@ -146,59 +124,39 @@ module Torque
         # Get the list of inherited tables associated with their parent tables
         def inherited_tables
           tables = query(<<-SQL, 'SCHEMA')
-            SELECT inhrelid::regclass  AS table_name,
-                   inhparent::regclass AS inheritances
+            SELECT child.relname             AS table_name,
+                   array_agg(parent.relname) 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
-            ORDER BY inhrelid
-          SQL
-
-          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("', '")}'])
+            GROUP BY child.relname, pg_inherits.inhrelid
+            ORDER BY pg_inherits.inhrelid
           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
+          tables.map do |(table, refs)|
+            [table, PG::TextDecoder::Array.new.decode(refs)]
+          end.to_h
         end
 
         # Get the list of columns, and their definition, but only from the
         # actual table, does not include columns that comes from inherited table
-        def column_definitions(table_name)
-          local = 'AND a.attislocal' if @_dump_mode
+        def column_definitions(table_name) # :nodoc:
+          # Only affects inheritance
+          local_condition = 'AND a.attislocal IS TRUE' if @_dump_mode
 
           query(<<-SQL, 'SCHEMA')
-            SELECT a.attname, format_type(a.atttypid, a.atttypmod),
-                    pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
-                    c.collname, col_description(a.attrelid, a.attnum) AS comment
-              FROM pg_attribute a
-              LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
-              LEFT JOIN pg_type t ON a.atttypid = t.oid
-              LEFT JOIN pg_collation c ON a.attcollation = c.oid AND a.attcollation <> t.typcollation
-              WHERE a.attrelid = #{quote(quote_table_name(table_name))}::regclass
-                AND a.attnum > 0 AND NOT a.attisdropped #{local}
-              ORDER BY a.attnum
+              SELECT a.attname, format_type(a.atttypid, a.atttypmod),
+                     pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
+             (SELECT c.collname FROM pg_collation c, pg_type t
+               WHERE c.oid = a.attcollation AND t.oid = a.atttypid AND a.attcollation <> t.typcollation),
+                     col_description(a.attrelid, a.attnum) AS comment
+                FROM pg_attribute a
+           LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+               WHERE a.attrelid = '#{quote_table_name(table_name)}'::regclass
+                 AND a.attnum > 0
+                 AND a.attisdropped IS FALSE
+                 #{local_condition}
+               ORDER BY a.attnum
           SQL
         end
 

data/lib/torque/postgresql/adapter/oid/enum_set.rb

@@ -14,7 +14,7 @@ module Torque
           end
 
           def type
-            :enum_set
+            :enum
           end
 
           def deserialize(value)

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

@@ -19,9 +19,6 @@ module Torque
       ActiveRecord::Type.register(:enum_set, OID::EnumSet,  adapter: :postgresql)
       ActiveRecord::Type.register(:line,     OID::Line,     adapter: :postgresql)
       ActiveRecord::Type.register(:segment,  OID::Segment,  adapter: :postgresql)
-
-      ActiveRecord::Type.register(:interval, OID::Interval, adapter: :postgresql) \
-        unless PostgreSQL::AR610
     end
   end
 end

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

@@ -22,27 +22,19 @@ module Torque
         end
 
         def quote_default_expression(value, column)
-          return super unless value.class <= Array &&
-            ((column.is_a?(ColumnDefinition) && column.dig(:options, :array)) ||
-            (column.is_a?(Column) && column.array?))
-
-          type = column.is_a?(Column) ? column.sql_type_metadata.sql_type : column.sql_type
-          quote(value) + '::' + type
+          return super unless value.class <= Array || value.class <= Set
+
+          type =
+            if column.is_a?(ColumnDefinition) && column.options.try(:[], :array)
+              # This is the general way
+              lookup_cast_type(column.sql_type)
+            elsif column.is_a?(Column) && column.array?
+              # When using +change_column_default+
+              lookup_cast_type_from_column(column)
+            end
+
+          type.nil? ? super : quote(type.serialize(value.to_a))
         end
-
-        private
-
-          def _quote(value)
-            return super unless value.is_a?(Array)
-
-            values = value.map(&method(:quote))
-            "ARRAY[#{values.join(','.freeze)}]"
-          end
-
-          def _type_cast(value)
-            return super unless value.is_a?(Array)
-            value.map(&method(:quote)).join(','.freeze)
-          end
       end
     end
   end

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

@@ -33,8 +33,7 @@ module Torque
           create_sql << "(#{statements.join(', ')})" \
             if statements.present? || o.inherits.present?
 
-          options = PostgreSQL::AR610 ? o : table_options(o)
-          add_table_options!(create_sql, options)
+          add_table_options!(create_sql, o)
 
           if o.inherits.present?
             tables = o.inherits.map(&method(:quote_table_name))

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

@@ -3,35 +3,7 @@
 module Torque
   module PostgreSQL
     module Adapter
-      module ColumnMethods
-
-        # Creates a column with an interval type, allowing span of times and
-        # dates to be stored without having to store a seconds-based integer
-        # or any sort of other approach
-        def interval(*args, **options)
-          args.each { |name| column(name, :interval, **options) }
-        end
-
-        # 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)
-          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
-        # 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))
-        end
-
-      end
-
       module TableDefinition
-        include ColumnMethods
-
         attr_reader :inherits
 
         def initialize(*args, **options)
@@ -42,16 +14,7 @@ module Torque
         end
       end
 
-      ActiveRecord::ConnectionAdapters::PostgreSQL::Table.include ColumnMethods
       ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.include TableDefinition
-
-      if ActiveRecord::ConnectionAdapters::PostgreSQL.const_defined?('ColumnDefinition')
-        module ColumnDefinition
-          attr_accessor :subtype, :enum_type
-        end
-
-        ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnDefinition.include ColumnDefinition
-      end
     end
   end
 end

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

@@ -12,39 +12,16 @@ module Torque
           stream
         end
 
-        def extensions(stream) # :nodoc:
-          super
-          user_defined_schemas(stream)
-          user_defined_types(stream)
-        end
-
         # Translate +:enum_set+ into +:enum+
         def schema_type(column)
           column.type == :enum_set ? :enum : super
         end
 
-        # Adds +:enum_type+ option to the default set
-        def prepare_column_options(column)
-          spec = super
-
-          if enum_type = schema_enum_type(column)
-            spec[:enum_type] = enum_type
-          end
-
-          spec
-        end
-
         private
 
-          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 - @connection.views).sort_by do |table_name|
-              table_name.split(/(?:public)?\./).reverse
-            end
+            sorted_tables = @connection.tables.sort - @connection.views
 
             stream.puts "  # These are the common tables"
             (sorted_tables - inherited_tables.keys).each do |table_name|
@@ -61,7 +38,7 @@ module Torque
 
                 # Add the inherits setting
                 sub_stream.rewind
-                inherits.map! { |parent| parent.to_s.sub(/\Apublic\./, '') }
+                inherits.map!(&:to_sym)
                 inherits = inherits.first if inherits.size === 1
                 inherits = ", inherits: #{inherits.inspect} do |t|"
                 table_dump = sub_stream.read.gsub(/ do \|t\|$/, inherits)
@@ -86,41 +63,6 @@ module Torque
             functions(stream) if defined?(::Fx::SchemaDumper::Function)
             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 "  # 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
-            stream.puts "# Could not dump user-defined types because of following #{e.class}"
-            stream.puts "#   #{e.message}"
-            stream.puts
-          end
-
-          # Dump enum custom type
-          def enum(name, stream)
-            values = @connection.enum_values(name).map { |v| "\"#{v}\"" }
-            stream.puts "  create_enum \"#{name}\", [#{values.join(', ')}], force: :cascade"
-          end
       end
 
       ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaDumper.prepend SchemaDumper

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

@@ -7,21 +7,6 @@ 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
@@ -33,28 +18,13 @@ module Torque
         end
 
         # Renames a type.
-        def rename_type(type_name, new_name, options = {})
+        def rename_type(type_name, new_name)
           execute <<-SQL.squish
-            ALTER TYPE #{quote_type_name(type_name, options[:schema])}
+            ALTER TYPE #{quote_type_name(type_name)}
             RENAME TO #{Quoting::Name.new(nil, new_name.to_s).quoted}
           SQL
         end
 
-        # Creates a new PostgreSQL enumerator type
-        #
-        # Example:
-        #   create_enum 'status', ['foo', 'bar']
-        #   create_enum 'status', ['foo', 'bar'], prefix: true
-        #   create_enum 'status', ['foo', 'bar'], suffix: 'test'
-        #   create_enum 'status', ['foo', 'bar'], force: true
-        def create_enum(name, values, options = {})
-          drop_type(name, options) if options[:force]
-          execute <<-SQL.squish
-            CREATE TYPE #{quote_type_name(name, options[:schema])} AS ENUM
-            (#{quote_enum_values(name, values, options).join(', ')})
-          SQL
-        end
-
         # Changes the enumerator by adding new values
         #
         # Example:
@@ -94,56 +64,14 @@ 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
 
-        # Simply add the schema to the table name when changing a table
-        def change_table(table_name, **options)
-          table_name = "#{options[:schema]}.#{table_name}" if options[:schema].present?
-          super table_name, **options
-        end
-
-        # Simply add the schema to the table name when dropping a table
-        def drop_table(table_name, **options)
-          table_name = "#{options[:schema]}.#{table_name}" if options[:schema].present?
-          super table_name, **options
-        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
 
-          # Remove the schema from the sequence name
-          def sequence_name_from_parts(table_name, column_name, suffix)
-            super(table_name.split('.').last, column_name, suffix)
-          end
-
           def quote_enum_values(name, values, options)
             prefix = options[:prefix]
             prefix = name if prefix === true

data/lib/torque/postgresql/adapter.rb

@@ -31,9 +31,9 @@ module Torque
         )
       end
 
-      # Add `inherits` and `schema` to the list of extracted table options
+      # Add `inherits` to the list of extracted table options
       def extract_table_options!(options)
-        super.merge(options.extract!(:inherits, :schema))
+        super.merge(options.extract!(:inherits))
       end
 
       # Allow filtered bulk insert by adding the where clause. This method is
@@ -49,15 +49,6 @@ module Torque
           end
         end
       end
-
-      # Extend the extract default value to support array
-      def extract_value_from_default(default)
-        return super unless Torque::PostgreSQL.config.use_extended_defaults
-        return super unless default&.match(/ARRAY\[(.*?)\](?:::"?([\w. ]+)"?(?:\[\])+)?$/)
-
-        arr = $1.split(/(?!\B\[[^\]]*), ?(?![^\[]*\]\B)/)
-        DeduplicatableArray.new(arr.map(&method(:extract_value_from_default)))
-      end
     end
 
     ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend Adapter

data/lib/torque/postgresql/associations/belongs_to_many_association.rb

@@ -12,9 +12,9 @@ module Torque
         ## CUSTOM
         def ids_reader
           if loaded?
-            target.pluck(reflection.active_record_primary_key)
+            target.pluck(reflection.association_primary_key)
           elsif !target.empty?
-            load_target.pluck(reflection.active_record_primary_key)
+            load_target.pluck(reflection.association_primary_key)
           else
             stale_state || column_default_value
           end
@@ -53,8 +53,8 @@ module Torque
 
         def load_target
           if stale_target? || find_target?
-            new_records = PostgreSQL::AR615 ? target.extract!(&:persisted?) : []
-            @target = merge_target_lists((find_target || []) + new_records, target)
+            persisted_records = (find_target || []) + target.extract!(&:persisted?)
+            @target = merge_target_lists(persisted_records, target)
           end
 
           loaded!
@@ -228,8 +228,9 @@ module Torque
           end
 
           def invertible_for?(record)
-            inverse = inverse_reflection_for(record)
-            inverse && (inverse.has_many? && inverse.connected_through_array?)
+            return unless (inverse = inverse_reflection_for(record))
+            collection_class = ::ActiveRecord::Associations::HasManyAssociation
+            inverse.is_a?(collection_class) && inverse.connected_through_array?
           end
 
           def stale_state

data/lib/torque/postgresql/associations/{association.rb → foreign_association.rb}

@@ -3,7 +3,7 @@
 module Torque
   module PostgreSQL
     module Associations
-      module Association
+      module ForeignAssociation
 
         # There is no problem of adding temporary items on target because
         # CollectionProxy will handle memory and persisted relationship
@@ -33,9 +33,6 @@ module Torque
           end
 
       end
-
-      ::ActiveRecord::Associations::Association.prepend(Association)
-      ::ActiveRecord::Associations::HasManyAssociation.prepend(Association)
     end
   end
 end