torque-postgresql 3.4.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c61aaf577483288d5c9a9af30704402529c86318cbdc312f567b643955c1443e
-  data.tar.gz: ccb9930f10cd48eb08448ecd99275fd7ca7ef54443fab81476c6b3a57c03e394
+  metadata.gz: d80bb198f5645c35915440f05a4ad083830221de27983c4c7b936c394e7bcbbb
+  data.tar.gz: a73a8de3a63b806e08f42109a3bb703e7ce19a20ae55a317c7fb763215612396
 SHA512:
-  metadata.gz: 34ed5cb4bb34b33de90020a7053378378b28ff0f45cc7a33e53084fa86c9069ab7694890fa0cac1ab19a85f5ee825cc317d3406cf8f98d4336ff416a2bae092b
-  data.tar.gz: 22771a0e4b1ce1486ae0ae6700c81cbbf84b227bb78b1a7163be2d2948b7161e822bb32dfdcc399c103348e2ab89f8cdda04112f988d303fd0735e178a605043
+  metadata.gz: 42a366f328d284ed37c601e0007a32f65b6615f69185b44fb82e0b943ab77a9e5b810189e00f2f200cf9e9b22e373bf33798c5496c76cfbfcd236bcc8bb923fe
+  data.tar.gz: 45385a880da9922eeb72c4d7e2adb29c26081865747c080973d409e61866a027cccd14a4276c8e0f95daf34d4d59c74a0a1c7cd7aecbb611763734cd12d3e064

data/lib/generators/torque/function_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'torque/postgresql/versioned_commands/generator'
+
+module Torque
+  module Generators
+    class FunctionGenerator < Rails::Generators::Base
+      include Torque::PostgreSQL::VersionedCommands::Generator
+
+      alias create_function_file create_migration_file
+    end
+  end
+end

data/lib/generators/torque/templates/function.sql.erb

@@ -0,0 +1,4 @@
+CREATE OR REPLACE FUNCTION <%= name %>()
+RETURNS void AS $$
+  -- Function body goes here
+$$ LANGUAGE sql;

data/lib/generators/torque/templates/type.sql.erb

@@ -0,0 +1,2 @@
+DROP TYPE IF EXISTS <%= name %>;
+CREATE TYPE <%= name %>;

data/lib/generators/torque/templates/view.sql.erb

@@ -0,0 +1,3 @@
+<%= "DROP MATERIALIZED VIEW IF EXISTS #{name};\n" if options[:materialized] %>CREATE <%= options[:materialized] ? 'MATERIALIZED' : 'OR REPLACE' %> VIEW <%= name %> AS (
+  -- View body goes here
+);

data/lib/generators/torque/type_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'torque/postgresql/versioned_commands/generator'
+
+module Torque
+  module Generators
+    class TypeGenerator < Rails::Generators::Base
+      include Torque::PostgreSQL::VersionedCommands::Generator
+
+      alias create_type_file create_migration_file
+    end
+  end
+end

data/lib/generators/torque/view_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'torque/postgresql/versioned_commands/generator'
+
+module Torque
+  module Generators
+    class ViewGenerator < Rails::Generators::Base
+      include Torque::PostgreSQL::VersionedCommands::Generator
+
+      class_option :materialized, type: :boolean, aliases: %i(--m), default: false,
+        desc: 'Use materialized view instead of regular view'
+
+      alias create_view_file create_migration_file
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module Torque
     module Adapter
       module DatabaseStatements
 
-        EXTENDED_DATABASE_TYPES = %i(enum enum_set interval)
+        EXTENDED_DATABASE_TYPES = %i[enum enum_set interval]
 
         # Switch between dump mode or not
         def dump_mode!
@@ -48,8 +48,8 @@ module Torque
         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}'
+          query_value(<<-SQL, "SCHEMA") == 1
+            SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = #{quote(name)}
           SQL
         end
 
@@ -59,96 +59,75 @@ module Torque
         end
         alias data_type_exists? type_exists?
 
-        # Configure the interval format
-        def configure_connection
-          super
-          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
-          m.register_type 'box',      OID::Box.new
-          m.register_type 'circle',   OID::Circle.new
-          m.register_type 'interval', OID::Interval.new
-          m.register_type 'line',     OID::Line.new
-          m.register_type 'segment',  OID::Segment.new
 
-          m.alias_type 'regclass', 'varchar'
+          if PostgreSQL.config.geometry.enabled
+            m.register_type 'box',      OID::Box.new
+            m.register_type 'circle',   OID::Circle.new
+            m.register_type 'line',     OID::Line.new
+            m.register_type 'segment',  OID::Segment.new
+          end
+
+          if PostgreSQL.config.interval.enabled
+            m.register_type 'interval', OID::Interval.new
+          end
         end
 
         # :nodoc:
         def load_additional_types(oids = nil)
+          type_map.alias_type 'regclass', 'varchar'
+          type_map.alias_type 'regconfig', 'varchar'
           super
           torque_load_additional_types(oids)
         end
 
         # 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
-
-          query = <<-SQL
-            SELECT      a.typelem AS oid, t.typname, t.typelem,
-                        t.typdelim, t.typbasetype, t.typtype,
-                        t.typarray
-            FROM        pg_type t
-            INNER JOIN  pg_type a ON (a.oid = t.typarray)
-            LEFT JOIN   pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-            WHERE       n.nspname NOT IN ('pg_catalog', 'information_schema')
-            AND     t.typtype IN ( 'e' )
-            #{filter}
-            AND     NOT EXISTS(
-                      SELECT 1 FROM pg_catalog.pg_type el
-                        WHERE el.oid = t.typelem AND el.typarray = t.oid
-                      )
-            AND     (t.typrelid = 0 OR (
-                      SELECT c.relkind = 'c' FROM pg_catalog.pg_class c
-                        WHERE c.oid = t.typrelid
-                      ))
+          return unless torque_load_additional_types?
+
+          # Types: (b)ase, (c)omposite, (d)omain, (e)num, (p)seudotype, (r)ange
+          # (m)ultirange
+
+          query = <<~SQL
+            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput,
+                   r.rngsubtype, t.typtype, t.typbasetype, t.typarray
+            FROM pg_type as t
+            LEFT JOIN pg_range as r ON oid = rngtypid
+            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+            WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
           SQL
 
-          execute_and_clear(query, 'SCHEMA', []) do |records|
-            records.each { |row| OID::Enum.create(row, type_map) }
+          if oids
+            query += " AND t.oid IN (%s)" % oids.join(", ")
+          else
+            query += " AND t.typtype IN ('e')"
+          end
+
+          options = { allow_retry: true, materialize_transactions: false }
+          internal_execute(query, 'SCHEMA', **options).each do |row|
+            if row['typtype'] == 'e' && PostgreSQL.config.enum.enabled
+              OID::Enum.create(row, type_map)
+            end
           end
         end
 
+        def torque_load_additional_types?
+          PostgreSQL.config.enum.enabled
+        end
+
         # Gets a list of user defined types.
         # You can even choose the +category+ filter
         def user_defined_types(*categories)
-          category_condition = categories.present? \
-            ? "AND t.typtype IN ('#{categories.join("', '")}')" \
-            : "AND t.typtype NOT IN ('b', 'd')"
-
-          select_all(<<-SQL, 'SCHEMA').rows.to_h
-            SELECT t.typname AS name,
-                   CASE t.typtype
-                     WHEN 'e' THEN 'enum'
-                     END     AS type
-            FROM pg_type t
-                   LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+          categories = categories.compact.presence || %w[c e p r m]
+
+          query(<<-SQL, 'SCHEMA').to_h
+            SELECT t.typname, t.typtype
+            FROM pg_type as t
+            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
             WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-              #{category_condition}
-              AND NOT EXISTS(
-                SELECT 1
-                FROM pg_catalog.pg_type el
-                WHERE el.oid = t.typelem
-                  AND el.typarray = t.oid
-              )
-              AND (t.typrelid = 0 OR (
-              SELECT c.relkind = 'c'
-              FROM pg_catalog.pg_class c
-              WHERE c.oid = t.typrelid
-            ))
-            ORDER BY t.typtype DESC
+            AND t.typtype IN ('#{categories.join("', '")}')
           SQL
         end
 
@@ -175,19 +154,10 @@ module Torque
 
         # Build the query for allowed schemas
         def user_defined_schemas_sql
-          conditions = []
-          conditions << <<-SQL.squish if schemas_blacklist.any?
-            nspname NOT LIKE ALL (ARRAY['#{schemas_blacklist.join("', '")}'])
-          SQL
-
-          conditions << <<-SQL.squish 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 ')}
+            WHERE 1=1 AND #{filter_by_schema.join(' AND ')}
             ORDER BY oid
           SQL
         end
@@ -195,21 +165,68 @@ module Torque
         # 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
-
-          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,
-                    #{supports_virtual_columns? ? 'attgenerated' : quote('')} as attgenerated
-              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
+          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,
+                     #{supports_identity_columns? ? 'attidentity' : quote('')} AS identity,
+                     #{supports_virtual_columns? ? 'attgenerated' : quote('')} as attgenerated
+                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
+                 #{'AND a.attislocal' if @_dump_mode}
+               ORDER BY a.attnum
+          SQL
+        end
+
+        # Get all possible schema entries that can be created via versioned
+        # commands of the provided type. Mostly for covering removals and not
+        # dump them
+        def list_versioned_commands(type)
+          query =
+            case type
+            when :function
+              <<-SQL.squish
+                SELECT n.nspname AS schema, p.proname AS name
+                FROM pg_catalog.pg_proc p
+                INNER JOIN pg_namespace n ON n.oid = p.pronamespace
+                WHERE 1=1 AND #{filter_by_schema.join(' AND ')};
+              SQL
+            when :type
+              <<-SQL.squish
+                SELECT n.nspname AS schema, t.typname AS name
+                FROM pg_type t
+                INNER JOIN pg_namespace n ON n.oid = t.typnamespace
+                WHERE 1=1 AND t.typtype NOT IN ('e')
+                  AND #{filter_by_schema.join(' AND ')};
+              SQL
+            when :view
+              <<-SQL.squish
+                SELECT n.nspname AS schema, c.relname AS name
+                FROM pg_class c
+                INNER JOIN pg_namespace n ON n.oid = c.relnamespace
+                WHERE 1=1 AND c.relkind IN ('v', 'm')
+                  AND #{filter_by_schema.join(' AND ')};
+              SQL
+            end
+
+          select_rows(query, 'SCHEMA')
+        end
+
+        # Build the condition for filtering by schema
+        def filter_by_schema
+          conditions = []
+          conditions << <<-SQL.squish if schemas_blacklist.any?
+            nspname NOT LIKE ALL (ARRAY['#{schemas_blacklist.join("', '")}'])
+          SQL
+
+          conditions << <<-SQL.squish if schemas_whitelist.any?
+            nspname LIKE ANY (ARRAY['#{schemas_whitelist.join("', '")}'])
           SQL
+          conditions
         end
 
       end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        module Array
+          def force_equality?(value)
+            PostgreSQL.config.predicate_builder.handle_array_attributes ? false : super
+          end
+        end
+
+        ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.prepend(Array)
+      end
+    end
+  end
+end

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

@@ -7,9 +7,7 @@ module Torque
       alias c= intercept=
 
       def a=(value)
-        self.slope = vertical? \
-          ? Float::INFINITY \
-          : Rational(value, b)
+        self.slope = vertical? ? Float::INFINITY : Rational(value, b)
       end
 
       def a
@@ -17,9 +15,7 @@ module Torque
       end
 
       def b=(value)
-        self.slope = value.zero? \
-          ? Float::INFINITY \
-          : Rational(a, value)
+        self.slope = value.zero? ? Float::INFINITY : Rational(a, value)
       end
 
       def b

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

@@ -7,7 +7,7 @@ module Torque
         class Range < ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Range
           HASH_PICK = %i[from start end to].freeze
 
-          module Comparasion
+          module Comparison
             def <=>(other)
               return super unless other.acts_like?(:date) || other.acts_like?(:time)
               other = other.to_time if other.acts_like?(:date)
@@ -17,9 +17,9 @@ module Torque
 
           def cast_value(value)
             case value
-            when Array
+            when ::Array
               cast_custom(value[0], value[1])
-            when Hash
+            when ::Hash
               pieces = value.with_indifferent_access.values_at(*HASH_PICK)
               cast_custom(pieces[0] || pieces[1], pieces[2] || pieces[3])
             else
@@ -54,7 +54,7 @@ module Torque
         ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID.send(:remove_const, :Range)
         ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID.const_set(:Range, Range)
 
-        ::Float.prepend(Range::Comparasion)
+        ::Float.prepend(Range::Comparison)
       end
     end
   end

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

@@ -1,24 +1,2 @@
-require_relative 'oid/box'
-require_relative 'oid/circle'
-require_relative 'oid/enum'
-require_relative 'oid/enum_set'
-require_relative 'oid/interval'
-require_relative 'oid/line'
+require_relative 'oid/array'
 require_relative 'oid/range'
-require_relative 'oid/segment'
-
-module Torque
-  module PostgreSQL
-    module Adapter
-      module OID
-      end
-
-      ActiveRecord::Type.register(:box,      OID::Box,      adapter: :postgresql)
-      ActiveRecord::Type.register(:circle,   OID::Circle,   adapter: :postgresql)
-      ActiveRecord::Type.register(:enum,     OID::Enum,     adapter: :postgresql)
-      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)
-    end
-  end
-end

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

@@ -4,21 +4,27 @@ module Torque
   module PostgreSQL
     module Adapter
       module Quoting
+        QUOTED_TYPE_NAMES = Concurrent::Map.new
 
         Name = ActiveRecord::ConnectionAdapters::PostgreSQL::Name
         Column = ActiveRecord::ConnectionAdapters::PostgreSQL::Column
         ColumnDefinition = ActiveRecord::ConnectionAdapters::ColumnDefinition
+        Utils = ActiveRecord::ConnectionAdapters::PostgreSQL::Utils
 
         # Quotes type names for use in SQL queries.
-        def quote_type_name(string, schema = nil)
-          name_schema, table = string.to_s.scan(/[^".\s]+|"[^"]*"/)
-          if table.nil?
-            table = name_schema
-            name_schema = nil
+        def quote_type_name(name, *args)
+          QUOTED_TYPE_NAMES[args] ||= begin
+            name = name.to_s
+            args << 'public' if args.empty? && !name.include?('.')
+            quote_identifier_name(name, *args)
           end
+        end
 
-          schema = schema || name_schema || 'public'
-          Name.new(schema, table).quoted
+        # Make sure to support all sorts of different compositions of names
+        def quote_identifier_name(name, schema = nil)
+          name = Utils.extract_schema_qualified_name(name.to_s) unless name.is_a?(Name)
+          name.instance_variable_set(:@schema, Utils.unquote_identifier(schema.to_s)) if schema
+          name.quoted.freeze
         end
 
         def quote_default_expression(value, column)

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

@@ -3,39 +3,18 @@ module Torque
     module Adapter
       module SchemaCreation
 
-        # Redefine original table creation command to ensure PostgreSQL standard
-        def visit_TableDefinition(o)
-          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 << accept(o.primary_keys) if o.primary_keys
-
-          if supports_indexes_in_create?
-            statements.concat(o.indexes.map { |c, o| index_in_create(o.name, c, o) })
-          end
-
-          if @conn.supports_foreign_keys?
-            statements.concat(o.foreign_keys.map { |fk| accept fk })
-          end
-
-          if respond_to?(:supports_check_constraints?) && supports_check_constraints?
-            statements.concat(o.check_constraints.map { |chk| accept chk })
-          end
-
-          create_sql << "(#{statements.join(', ')})" \
-            if statements.present? || o.inherits.present?
-
-          add_table_options!(create_sql, o)
-
+        # Inherits are now setup via table options, but keep the implementation
+        # supported by this gem
+        def add_table_options!(create_sql, o)
           if o.inherits.present?
+            # Make sure we always have parenthesis
+            create_sql << '()' unless create_sql[-1] == ')'
+
             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
+          super(create_sql, o)
         end
       end
 

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

@@ -3,7 +3,26 @@
 module Torque
   module PostgreSQL
     module Adapter
+      module ColumnMethods
+
+        # Adds a search language column to the table. See +add_search_language+
+        def search_language(*names, **options)
+          raise ArgumentError, "Missing column name(s) for search_language" if names.empty?
+          names.each { |name| column(name, :regconfig, **options) }
+        end
+
+        # Add a search vector column to the table. See +add_search_vector+
+        def search_vector(*names, columns:, **options)
+          raise ArgumentError, "Missing column name(s) for search_vector" if names.empty?
+          options = Attributes::Builder.search_vector_options(columns: columns, **options)
+          names.each { |name| column(name, :virtual, **options) }
+        end
+
+      end
+
       module TableDefinition
+        include ColumnMethods
+
         attr_reader :inherits
 
         def initialize(*args, **options)
@@ -12,8 +31,47 @@ module Torque
           @inherits = Array.wrap(options.delete(:inherits)).flatten.compact \
             if options.key?(:inherits)
         end
+
+        def set_primary_key(tn, id, primary_key, *, **)
+          super unless @inherits.present? && primary_key.blank? && id == :primary_key
+        end
+
+        private
+
+          def create_column_definition(name, type, options)
+            if type == :enum_set
+              type = :enum
+              options ||= {}
+              options[:array] = true
+            end
+
+            super(name, type, options)
+          end
+      end
+
+      # Add exclusive support for versioned commands when importing from schema
+      # dump. This ensures that such methods are not available in regular
+      # migrations.
+      module Definition
+
+        def create_function(name, version:, dir: pool.migrations_paths)
+          return super unless VersionedCommands.valid_type?(:function)
+          execute VersionedCommands.fetch_command(dir, :function, name, version)
+        end
+
+        def create_type(name, version:, dir: pool.migrations_paths)
+          return super unless VersionedCommands.valid_type?(:type)
+          execute VersionedCommands.fetch_command(dir, :type, name, version)
+        end
+
+        def create_view(name, version:, dir: pool.migrations_paths)
+          return super unless VersionedCommands.valid_type?(:view)
+          execute VersionedCommands.fetch_command(dir, :view, name, version)
+        end
+
       end
 
+      ActiveRecord::ConnectionAdapters::PostgreSQL::Table.include ColumnMethods
       ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.include TableDefinition
     end
   end