torque-postgresql 1.1.5 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91a42a9a04ba195e57f4b87af2931a6ecf82e9d58a4acec84b95350404ee4977
-  data.tar.gz: e4fce1b312a40bf6e98a1f8bee8351795a45a5afddf25ce0f7765cd6c01d89ec
+  metadata.gz: 9e426686cf04fcf990d84b945abe3b3435168237f1ff24c6f23ac3b4941bbc4e
+  data.tar.gz: 2f936f5676f80804e4766bc9bf64b81d70ddbd08e9409b373b0d59d7d20e8bf1
 SHA512:
-  metadata.gz: 56a370889f5ffbb09a2c414bd1a9c4311d4d415675fd8ac7f00a09ffb4b2aa4b70998b475f6ab494ad06f0e0b9783ddea599268f04d0c5d3184b9e1d0d644d44
-  data.tar.gz: 7341f28b3805af398868be6a4095c9dcf4b9e7d6be28a0ce4e2af0340004490e2e75b9eb6e7e63f9d6ac0bba1caf5fdb7154cd5b8d7928c6c093f748cda96d71
+  metadata.gz: 373d085090e02e76eb2523f7c2d5a32434c002f712cf892aa38f81bc9935a51f2426054c97bb5df534c47e23fd1800d84b670b9443266908e2f076f20928e7a2
+  data.tar.gz: f0441cc66de2ed015d0b8dbb13ae88dc4074a54c8477fc7a31fc1d51e2bfd7cb57ab0e3de529dcbd4feb3fa72dd1fc8894738868e8bfa36ad9490badc3d1c990

data/lib/torque/postgresql.rb

@@ -6,7 +6,6 @@ require 'active_support'
 
 require 'active_support/core_ext/date/acts_like'
 require 'active_support/core_ext/time/zones'
-require 'active_support/core_ext/hash/compact'
 require 'active_record/connection_adapters/postgresql_adapter'
 
 require 'torque/postgresql/config'
@@ -28,6 +27,5 @@ require 'torque/postgresql/migration'
 require 'torque/postgresql/relation'
 require 'torque/postgresql/reflection'
 require 'torque/postgresql/schema_cache'
-require 'torque/postgresql/schema_dumper'
 
 require 'torque/postgresql/railtie' if defined?(Rails)

data/lib/torque/postgresql/adapter.rb

@@ -10,7 +10,6 @@ module Torque
   module PostgreSQL
     module Adapter
       include Quoting
-      include ColumnDumper unless Torque::PostgreSQL::AR521
       include DatabaseStatements
       include SchemaStatements
 

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

@@ -43,16 +43,9 @@ module Torque
         end
 
         # :nodoc:
-        if Torque::PostgreSQL::AR521
-          def load_additional_types(oids = nil)
-            super
-            torque_load_additional_types(oids)
-          end
-        else
-          def load_additional_types(type_map, oids = nil)
-            super
-            torque_load_additional_types(oids)
-          end
+        def load_additional_types(oids = nil)
+          super
+          torque_load_additional_types(oids)
         end
 
         # Add the composite types to be loaded too.
@@ -80,11 +73,7 @@ module Torque
           SQL
 
           execute_and_clear(query, 'SCHEMA', []) do |records|
-            records.each do |row|
-              case row['typtype']
-              when 'e' then OID::Enum.create(row, type_map)
-              end
-            end
+            records.each { |row| OID::Enum.create(row, type_map) }
           end
         end
 

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

@@ -5,10 +5,11 @@ module Torque
 
         # Redefine original table creation command to ensure PostgreSQL standard
         def visit_TableDefinition(o)
-          create_sql = "CREATE#{' TEMPORARY' if o.temporary}"
-          create_sql << " TABLE #{quote_table_name(o.name)}"
+          create_sql = +"CREATE#{table_modifier_in_create(o)} TABLE "
+          create_sql << "IF NOT EXISTS " if o.if_not_exists
+          create_sql << "#{quote_table_name(o.name)} "
 
-          statements = o.columns.map{ |c| accept c }
+          statements = o.columns.map { |c| accept c }
           statements << accept(o.primary_keys) if o.primary_keys
 
           if supports_indexes_in_create?
@@ -17,36 +18,25 @@ module Torque
             end)
           end
 
-          if supports_foreign_keys_in_create?
+          if supports_foreign_keys?
             statements.concat(o.foreign_keys.map do |to_table, options|
               foreign_key_in_create(o.name, to_table, options)
             end)
           end
 
-          if o.as
-            create_sql << " AS #{@conn.to_sql(o.as)}"
-          else
-            create_sql << " (#{statements.join(', ')})"
-            add_table_options!(create_sql, table_options(o))
+          create_sql << "(#{statements.join(', ')})" \
+            if statements.present? || o.inherits.present?
 
-            if o.inherits.present?
-              tables = o.inherits.map(&method(:quote_table_name))
-              create_sql << " INHERITS ( #{tables.join(' , ')} )"
-            end
+          add_table_options!(create_sql, table_options(o))
+
+          if o.inherits.present?
+            tables = o.inherits.map(&method(:quote_table_name))
+            create_sql << " INHERITS ( #{tables.join(' , ')} )"
           end
 
+          create_sql << " AS #{to_sql(o.as)}" if o.as
           create_sql
         end
-
-        # Keep rails 5.0 and 5.1 compatibility
-        def supports_foreign_keys_in_create?
-          if defined?(super)
-            super
-          else
-            supports_foreign_keys?
-          end
-        end
-
       end
 
       ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaCreation.prepend SchemaCreation

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

@@ -7,17 +7,15 @@ module Torque
         # 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) }
+          args.each { |name| column(name, :interval, **options) }
         end
 
         # Creates a column with an enum type, needing to specify the subtype,
         # which is basically the name of the type defined prior creating the
         # column
         def enum(*args, **options)
-          args.each do |name|
-            type = options.fetch(:subtype, name)
-            column(name, type, options)
-          end
+          subtype = options.delete(:subtype)
+          args.each { |name| column(name, (subtype || name), **options) }
         end
 
         # Creates a column with an enum array type, needing to specify the
@@ -34,23 +32,11 @@ module Torque
 
         attr_reader :inherits
 
-        def initialize(name, *_, **options)
-          old_args = []
-          old_args << options.delete(:temporary) || false
-          old_args << options.delete(:options)
-          old_args << options.delete(:as)
-          comment = options.delete(:comment)
+        def initialize(*args, **options)
+          super
 
-          super(name, *old_args, comment: comment)
-
-          if options.key?(:inherits)
-            @inherits = Array[options.delete(:inherits)].flatten.compact
-            @inherited_id = !(options.key?(:primary_key) || options.key?(:id))
-          end
-        end
-
-        def inherited_id?
-          @inherited_id
+          @inherits = Array.wrap(options.delete(:inherits)).flatten.compact \
+            if options.key?(:inherits)
         end
       end
 

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

@@ -1,22 +1,23 @@
 module Torque
   module PostgreSQL
     module Adapter
-      module ColumnDumper
+      module SchemaDumper
+        def dump(stream) # :nodoc:
+          @connection.dump_mode!
+          super
 
-        # Adds +:subtype+ as a valid migration key
-        unless Torque::PostgreSQL::AR521
-          def migration_keys
-            super + [:subtype]
-          end
+          @connection.dump_mode!
+          stream
+        end
+
+        def extensions(stream) # :nodoc:
+          super
+          user_defined_types(stream)
         end
 
         # Translate +:enum_set+ into +:enum+
         def schema_type(column)
-          if column.type == :enum_set
-            :enum
-          else
-            super
-          end
+          column.type == :enum_set ? :enum : super
         end
 
         # Adds +:subtype+ option to the default set
@@ -36,7 +37,69 @@ module Torque
             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.data_sources.sort - @connection.views
+
+            stream.puts "  # These are the common tables managed"
+            (sorted_tables - inherited_tables.keys).each do |table_name|
+              table(table_name, stream) unless ignored?(table_name)
+            end
+
+            if inherited_tables.present?
+              stream.puts "  # These are tables that has inheritance"
+              inherited_tables.each do |table_name, inherits|
+                next if ignored?(table_name)
+
+                sub_stream = StringIO.new
+                table(table_name, sub_stream)
+
+                # Add the inherits setting
+                sub_stream.rewind
+                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)
+
+                # Ensure bodyless definitions
+                table_dump.gsub!(/do \|t\|\n  end/, '')
+                stream.print table_dump
+              end
+            end
+
+            # Dump foreign keys at the end to make sure all dependent tables exist.
+            if @connection.supports_foreign_keys?
+              sorted_tables.each do |tbl|
+                foreign_keys(tbl, stream) unless ignored?(tbl)
+              end
+            end
+
+            # Scenic integration
+            views(stream) if defined?(::Scenic)
+          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"
+            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
     end
   end
 end

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

@@ -73,24 +73,14 @@ module Torque
 
         # Rewrite the method that creates tables to easily accept extra options
         def create_table(table_name, **options, &block)
-          td = create_table_definition(table_name, **options)
-          options[:id] = false if td.inherited_id?
-          options[:temporary] = td
+          options[:id] = false if options[:inherits].present? &&
+            options[:primary_key].blank? && options[:id].blank?
 
           super table_name, **options, &block
         end
 
         private
 
-          # This waits for the second call to really return the table definition
-          def create_table_definition(*args, **options) # :nodoc:
-            if !args.second.kind_of?(TableDefinition)
-              TableDefinition.new(*args, **options)
-            else
-              args.second
-            end
-          end
-
           def quote_enum_values(name, values, options)
             prefix = options[:prefix]
             prefix = name if prefix === true

data/lib/torque/postgresql/associations.rb

@@ -3,6 +3,3 @@ require_relative 'associations/association_scope'
 require_relative 'associations/belongs_to_many_association'
 require_relative 'associations/builder'
 require_relative 'associations/preloader'
-
-require_relative 'associations/join_dependency/join_association' \
-  unless Torque::PostgreSQL::AR521

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

@@ -14,63 +14,40 @@ module Torque
           # When the relation is connected through an array, intercept the
           # condition builder and uses an overlap condition building it on
           # +build_id_constraint+
-          def last_chain_scope(scope, *args)
-            # 5.0 table, reflection, owner, association_klass
-            # 5.1 table, reflection, owner
-            # 5.2 reflection, owner
-
-            reflection = args.size.eql?(2) ? args[0] : args[1]
+          def last_chain_scope(scope, reflection, owner)
             return super unless reflection.connected_through_array?
 
-            table = args[0] if args.size > 2
-            keys = args.size.eql?(4) ? reflection.join_keys(args[3]) : reflection.join_keys
-            owner = args.size.eql?(2) ? args[1] : args[2]
-
+            keys = reflection.join_keys
             value = transform_value(owner[keys.foreign_key])
-            constraint, binds = build_id_constraint(reflection, keys, value, table, true)
+            constraint = build_id_constraint(reflection, keys, value, true)
 
-            if Torque::PostgreSQL::AR521
-              scope.where!(constraint)
-            else
-              klass = ::ActiveRecord::Relation::WhereClause
-              scope.where_clause += klass.new([constraint], binds)
-              scope
-            end
+            scope.where!(constraint)
           end
 
           # When the relation is connected through an array, intercept the
           # condition builder and uses an overlap condition building it on
           # +build_id_constraint+
-          def next_chain_scope(scope, *args)
-            # 5.0 table, reflection, association_klass, foreign_table, next_reflection
-            # 5.1 table, reflection, foreign_table, next_reflection
-            # 5.2 reflection, next_reflection
-
-            reflection = args.size.eql?(2) ? args[0] : args[1]
+          def next_chain_scope(scope, reflection, next_reflection)
             return super unless reflection.connected_through_array?
 
-            table = args[0] if args.size > 2
-            next_reflection = args[-1]
-
-            foreign_table = args[-2] if args.size.eql?(5)
-            foreign_table ||= next_reflection.aliased_table
-
-            keys = args.size.eql?(5) ? reflection.join_keys(args[2]) : reflection.join_keys
+            keys = reflection.join_keys
+            foreign_table = next_reflection.aliased_table
 
             value = foreign_table[keys.foreign_key]
-            constraint, *_ = build_id_constraint(reflection, keys, value, table)
+            constraint = build_id_constraint(reflection, keys, value)
 
             scope.joins!(join(foreign_table, constraint))
           end
 
           # Trigger the same method on the relation which will build the
           # constraint condition using array logics
-          def build_id_constraint(reflection, keys, value, table = nil, bind_param = false)
-            table ||= reflection.aliased_table
-            value, binds = build_binds_for_constraint(reflection, value, keys.foreign_key) \
-              if bind_param
+          def build_id_constraint(reflection, keys, value, bind_param = false)
+            table = reflection.aliased_table
+            value = Array.wrap(value).map do |value|
+              build_bind_param_for_constraint(reflection, value, keys.foreign_key)
+            end if bind_param
 
-            [reflection.build_id_constraint(table[keys.key], value), binds]
+            reflection.build_id_constraint(table[keys.key], value)
           end
 
           # For array-like values, it needs to call the method as many times as
@@ -83,30 +60,11 @@ module Torque
             end
           end
 
-          # When binds are necessary for a constraint, instantiate them
-          if Torque::PostgreSQL::AR521
-            def build_binds_for_constraint(reflection, values, foreign_key)
-              result = Array.wrap(values).map do |value|
-                ::Arel::Nodes::BindParam.new(::ActiveRecord::Relation::QueryAttribute.new(
-                  foreign_key, value, reflection.klass.attribute_types[foreign_key],
-                ))
-              end
-
-              [result, nil]
-            end
-          else
-            def build_binds_for_constraint(reflection, values, foreign_key)
-              type = reflection.klass.attribute_types[foreign_key]
-              parts = Array.wrap(values).map do |value|
-                bind = ::Arel::Nodes::BindParam.new
-                value = ::ActiveRecord::Relation::QueryAttribute.new(foreign_key, value, type)
-                [bind, value]
-              end.to_h
-
-              [parts.keys, parts.values]
-            end
+          def build_bind_param_for_constraint(reflection, value, foreign_key)
+            ::Arel::Nodes::BindParam.new(::ActiveRecord::Relation::QueryAttribute.new(
+              foreign_key, value, reflection.klass.attribute_types[foreign_key],
+            ))
           end
-
       end
 
       ::ActiveRecord::Associations::AssociationScope.singleton_class.prepend(AssociationScope::ClassMethods)

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

@@ -28,20 +28,21 @@ module Torque
         end
 
         def ids_reader
-          owner[reflection.active_record_primary_key]
+          owner[source_attr]
         end
 
         def ids_writer(new_ids)
-          column = reflection.active_record_primary_key
-          owner.update_column(column, owner[column] = new_ids.presence)
+          column = source_attr
+          command = owner.persisted? ? :update_column : :write_attribute
+          owner.public_send(command, column, new_ids.presence)
           @association_scope = nil
         end
 
         def insert_record(record, *)
           super
 
-          attribute = (ids_reader || owner[reflection.active_record_primary_key] = [])
-          attribute.push(record[klass_fk])
+          attribute = (ids_reader || owner[source_attr] = [])
+          attribute.push(record[klass_attr])
           record
         end
 
@@ -50,8 +51,8 @@ module Torque
         end
 
         def include?(record)
-          list = owner[reflection.active_record_primary_key]
-          ids_reader && ids_reader.include?(record[klass_fk])
+          list = owner[source_attr]
+          ids_reader && ids_reader.include?(record[klass_attr])
         end
 
         private
@@ -65,7 +66,7 @@ module Torque
           # When the idea is to nulligy the association, then just set the owner
           # +primary_key+ as empty
           def delete_count(method, scope, ids = nil)
-            ids ||= scope.pluck(klass_fk)
+            ids ||= scope.pluck(klass_attr)
             scope.delete_all if method == :delete_all
             remove_stash_records(ids)
           end
@@ -76,13 +77,13 @@ module Torque
 
           # Deletes the records according to the <tt>:dependent</tt> option.
           def delete_records(records, method)
-            ids = Array.wrap(records).each_with_object(klass_fk).map(&:[])
+            ids = Array.wrap(records).each_with_object(klass_attr).map(&:[])
 
             if method == :destroy
               records.each(&:destroy!)
               remove_stash_records(ids)
             else
-              scope = self.scope.where(klass_fk => records)
+              scope = self.scope.where(klass_attr => records)
               delete_count(method, scope, ids)
             end
           end
@@ -98,10 +99,14 @@ module Torque
             ids_writer(ids_reader - Array.wrap(ids))
           end
 
-          def klass_fk
+          def source_attr
             reflection.foreign_key
           end
 
+          def klass_attr
+            reflection.active_record_primary_key
+          end
+
           def difference(a, b)
             a - b
           end