torque-postgresql 1.1.1 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b95a55ebfe82e5b96582da09307f1d45d62ba922
-  data.tar.gz: 38a068ec3fa7cc5aab2425a31e8ed37a49b15132
+SHA256:
+  metadata.gz: 4164165e64b027d11997dde286684b27bd77c33634e3eb84c6f1c757b5d814a0
+  data.tar.gz: 8bf196d92b261661631ceb02f2ab7600a8a6cec5cacc43fa69b0c300afb65582
 SHA512:
-  metadata.gz: b708c73cfcac1798474e35099570e4def16a6a51b2448ef34ce2ec5e97dd4c8d57f48fa51f18182f0405afa7eed1884b81846cb3b2e132b638c8711ee80dd72c
-  data.tar.gz: 7bab6bd30e0b3898826b20cce99ff629192ea62d772864e10a3fc141e86e5f3f27a0f9e459addc29a8a27bcbb7df17920831d0f7e7b01ac823d65f600b699530
+  metadata.gz: 7e44fd4215ba1ef9d2aebf8d6a5c285266f0bb64544a2a74d36773aaaa8e57c5776c3260183352accf76f81e94edcba27ffa898145e4d0bb467f5097ce7e7467
+  data.tar.gz: 9c8acb15a0e78f33e8da372dcffc0e1a3e238631d01932056e5e48392801ec3706c3168a138944e5ebe7b80222f2f962e32af043a91c29235b6e824e02b70bbc

data/Rakefile

@@ -14,13 +14,16 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-desc 'Prints a schema dump of the test database'
-task :dump do |t|
+desc 'Initialize the local environment'
+task :environment do |t|
   lib  = File.expand_path('../lib', __FILE__)
   spec = File.expand_path('../spec', __FILE__)
   $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
   $LOAD_PATH.unshift(spec) unless $LOAD_PATH.include?(spec)
+end
 
+desc 'Prints a schema dump of the test database'
+task dump: :environment do |t|
   require 'byebug'
   require 'spec_helper'
   ActiveRecord::SchemaDumper.dump

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,66 @@ 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
+          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,64 +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]
-            puts reflection.connected_through_array?.inspect
+          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
@@ -84,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)