torque-postgresql 3.4.1 → 4.0.0

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

@@ -4,6 +4,23 @@ module Torque
   module PostgreSQL
     module Adapter
       module SchemaDumper
+        SEARCH_VECTOR_SCANNER = /
+          to_tsvector\(
+            ('[^']+'|[a-z][a-z0-9_]*)[^,]*,[^\(]*
+            \(?coalesce\(([a-z][a-z0-9_]*)[^\)]*\)\)?
+          (?:::[^\)]*\))?
+          (?:\s*,\s*'([A-D])')?
+        /ix
+
+        def initialize(*)
+          super
+
+          if with_versioned_commands?
+            @versioned_commands = VersionedCommands::SchemaTable.new(@connection.pool)
+            @ignore_tables << @versioned_commands.table_name
+          end
+        end
+
         def dump(stream) # :nodoc:
           @connection.dump_mode!
           super
@@ -12,17 +29,14 @@ module Torque
           stream
         end
 
-        def extensions(stream) # :nodoc:
-          super
-          user_defined_schemas(stream)
-        end
+        private
 
-        # Translate +:enum_set+ into +:enum+
-        def schema_type(column)
-          column.type == :enum_set ? :enum : super
-        end
+          def types(stream) # :nodoc:
+            super
 
-        private
+            versioned_commands(stream, :type)
+            versioned_commands(stream, :function)
+          end
 
           def tables(stream) # :nodoc:
             around_tables(stream) { dump_tables(stream) }
@@ -32,6 +46,7 @@ module Torque
             functions(stream) if fx_functions_position == :beginning
 
             yield
+            versioned_commands(stream, :view, true)
 
             functions(stream) if fx_functions_position == :end
             triggers(stream) if defined?(::Fx::SchemaDumper::Trigger)
@@ -39,41 +54,46 @@ module Torque
 
           def dump_tables(stream)
             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 - @connection.views).filter_map do |table_name|
+              name_parts = table_name.split(/(?:public)?\./).reverse.compact_blank
+              next if ignored?(table_name) || ignored?(name_parts.join('.'))
+
+              [table_name, name_parts]
+            end.sort_by(&:last).to_h
+
+            postponed = []
 
             stream.puts "  # These are the common tables"
-            (sorted_tables - inherited_tables.keys).each do |table_name|
-              table(table_name, stream) unless ignored?(table_name)
+            sorted_tables.each do |table, (table_name, _)|
+              next postponed << table if inherited_tables.key?(table_name)
+
+              table(table, stream)
+              stream.puts # Ideally we would not do this in the last one
             end
 
-            if inherited_tables.present?
+            if postponed.present?
               stream.puts "  # These are tables that have inheritance"
-              inherited_tables.each do |table_name, inherits|
-                next if ignored?(table_name)
-
+              postponed.each do |table|
                 sub_stream = StringIO.new
-                table(table_name, sub_stream)
-
-                # Add the inherits setting
-                sub_stream.rewind
-                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)
-
-                # Ensure bodyless definitions
-                table_dump.gsub!(/do \|t\|\n  end/, '')
-                stream.print table_dump
+                table(table, sub_stream)
+                stream.puts sub_stream.string.sub(/do \|t\|\n  end/, '')
+                stream.puts
               end
             end
 
-            # Dump foreign keys at the end to make sure all dependent tables exist.
+            # Fixes double new lines to single new lines
+            stream.pos -= 1
+
+            # 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)
+              foreign_keys_stream = StringIO.new
+              sorted_tables.each do |(tbl, *)|
+                foreign_keys(tbl, foreign_keys_stream)
               end
+
+              foreign_keys_string = foreign_keys_stream.string
+              stream.puts if foreign_keys_string.length > 0
+              stream.print foreign_keys_string
             end
           end
 
@@ -83,7 +103,8 @@ module Torque
           end
 
           # Dump user defined schemas
-          def user_defined_schemas(stream)
+          def schemas(stream)
+            return super if !PostgreSQL.config.schemas.enabled
             return if (list = (@connection.user_defined_schemas - ['public'])).empty?
 
             stream.puts "  # Custom schemas defined in this database."
@@ -91,6 +112,87 @@ module Torque
             stream.puts
           end
 
+          # Adjust the schema type for search vector
+          def schema_type_with_virtual(column)
+            column.virtual? && column.type == :tsvector ? :search_vector : super
+          end
+
+          # Adjust the schema type for search language
+          def schema_type(column)
+            column.sql_type == 'regconfig' ? :search_language : super
+          end
+
+          # Adjust table options to make the dump more readable
+          def prepare_column_options(column)
+            options = super
+            parse_search_vector_options(column, options) if column.type == :tsvector
+            options
+          end
+
+          # Parse the search vector operation into a readable format
+          def parse_search_vector_options(column, options)
+            settings = options[:as].scan(SEARCH_VECTOR_SCANNER)
+            return if settings.empty?
+
+            languages = settings.map(&:shift).uniq
+            return if languages.many?
+
+            language = languages.first
+            language = language[0] == "'" ? language[1..-2] : language.to_sym
+            columns = parse_search_vector_columns(settings)
+
+            options.except!(:as, :type)
+            options.merge!(language: language.inspect, columns: columns)
+          end
+
+          # Simplify the whole columns configuration to make it more manageable
+          def parse_search_vector_columns(settings)
+            return ":#{settings.first.first}" if settings.one?
+
+            settings = settings.sort_by(&:last)
+            weights = %w[A B C D]
+
+            columns = settings.each.with_index.reduce([]) do |acc, (setting, index)|
+              column, weight = setting
+              break if (weights[index] || 'D') != weight
+
+              acc << column
+              acc
+            end
+
+            return columns.map(&:to_sym).inspect if columns
+            settings.to_h.transform_values(&:inspect)
+          end
+
+          # Simply add all versioned commands to the stream
+          def versioned_commands(stream, type, add_newline = false)
+            return unless with_versioned_commands?
+
+            list = @versioned_commands.versions_of(type.to_s)
+            return if list.empty?
+
+            existing = list_existing_versioned_commands(type)
+
+            stream.puts if add_newline
+            stream.puts "  # These are #{type.to_s.pluralize} managed by versioned commands"
+            list.each do |(name, version)|
+              next if existing.exclude?(name)
+
+              stream.puts "  create_#{type} \"#{name}\", version: #{version}"
+            end
+            stream.puts unless add_newline
+          end
+
+          def list_existing_versioned_commands(type)
+            @connection.list_versioned_commands(type).each_with_object(Set.new) do |entry, set|
+              set << (entry.first == 'public' ? entry.last : entry.join('_'))
+            end
+          end
+
+          def with_versioned_commands?
+            PostgreSQL.config.versioned_commands.enabled
+          end
+
           def fx_functions_position
             return unless defined?(::Fx::SchemaDumper::Function)
             Fx.configuration.dump_functions_at_beginning_of_schema ? :beginning : :end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module SchemaOverrides
+        # This adds better support for handling the quotation of table names
+        def quote_table_name(name)
+          ActiveRecord::ConnectionAdapters::PostgreSQL::Quoting::QUOTED_TABLE_NAMES.then do |m|
+            m[name] ||= quote_identifier_name(name)
+          end
+        end
+
+        %i[
+          table_exists? indexes index_exists? columns column_exists? primary_key
+          create_table change_table add_column add_columns remove_columns remove_column
+          change_column change_column_default change_column_null rename_column
+          add_index remove_index rename_index index_name_exists? foreign_keys
+          add_timestamps remove_timestamps change_table_comment change_column_comment
+          bulk_change_table
+
+          rename_table add_foreign_key remove_foreign_key foreign_key_exists?
+        ].each do |method_name|
+          define_method(method_name) do |table_name, *args, **options, &block|
+            table_name = sanitize_name_with_schema(table_name, options)
+            super(table_name, *args, **options, &block)
+          end
+        end
+
+        def drop_table(*table_names, **options)
+          table_names = table_names.map { |name| sanitize_name_with_schema(name, options.dup) }
+          super(*table_names, **options)
+        end
+
+        private
+
+          def validate_table_length!(table_name)
+            super(table_name.to_s)
+          end
+      end
+
+      include SchemaOverrides
+    end
+  end
+end

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

@@ -4,42 +4,55 @@ module Torque
   module PostgreSQL
     module Adapter
       module SchemaStatements
-
-        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.
+        # Drops a type
         def drop_type(name, options = {})
           force = options.fetch(:force, '').upcase
           check = 'IF EXISTS' if options.fetch(:check, true)
-          execute <<-SQL.squish
+          name = sanitize_name_with_schema(name, options)
+
+          internal_exec_query(<<-SQL.squish).tap { reload_type_map }
             DROP TYPE #{check}
-            #{quote_type_name(name, options[:schema])} #{force}
+            #{quote_type_name(name)} #{force}
           SQL
         end
 
-        # Renames a type.
+        # Renames a type
         def rename_type(type_name, new_name, options = {})
-          execute <<-SQL.squish
-            ALTER TYPE #{quote_type_name(type_name, options[:schema])}
+          type_name = sanitize_name_with_schema(type_name, options)
+          internal_exec_query(<<-SQL.squish).tap { reload_type_map }
+            ALTER TYPE #{quote_type_name(type_name)}
             RENAME TO #{Quoting::Name.new(nil, new_name.to_s).quoted}
           SQL
         end
 
+        # Creates a column that stores the underlying language of the record so
+        # that a search vector can be created dynamically based on it. It uses
+        # a `regconfig` type, so string conversions are mandatory
+        def add_search_language(table, name, options = {})
+          add_column(table, name, :regconfig, options)
+        end
+
+        # Creates a column and setup a search vector as a virtual column. The
+        # options are dev-friendly and controls how the vector function will be
+        # defined
+        #
+        # === Options
+        # [:columns]
+        #   The list of columns that will be used to create the search vector.
+        #   It can be a single column, an array of columns, or a hash as a
+        #   combination of column name and weight (A, B, C, or D).
+        # [:language]
+        #   Specify the language config to be used for the search vector. If a
+        #   string is provided, then the value will be statically embedded. If a
+        #   symbol is provided, then it will reference another column.
+        # [:stored]
+        #   Specify if the value should be stored in the database. As of now,
+        #   PostgreSQL only supports `true`, which will create a stored column.
+        def add_search_vector(table, name, columns, options = {})
+          options = Builder.search_vector_options(columns: columns, **options)
+          add_column(table, name, options.delete(:type), options)
+        end
+
         # Changes the enumerator by adding new values
         #
         # Example:
@@ -48,6 +61,7 @@ module Torque
         #   add_enum_values 'status', ['baz'], after: 'foo'
         #   add_enum_values 'status', ['baz'], prepend: true
         def add_enum_values(name, values, options = {})
+          name   = sanitize_name_with_schema(name, options)
           before = options.fetch(:before, false)
           after  = options.fetch(:after,  false)
 
@@ -59,7 +73,7 @@ module Torque
             reference = "BEFORE #{before}" unless before == false
             reference = "AFTER  #{after}"  unless after == false
             execute <<-SQL.squish
-              ALTER TYPE #{quote_type_name(name, options[:schema])}
+              ALTER TYPE #{quote_type_name(name)}
               ADD VALUE #{value} #{reference}
             SQL
 
@@ -77,34 +91,26 @@ module Torque
           SQL
         end
 
-        # 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)
+          options = super
 
-        # 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
+          if PostgreSQL.config.schemas.enabled
+            table, schema = table_name.split('.').reverse
+            if table.present? && schema.present? && schema != current_schema
+              options[:schema] = schema
+            end
+          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
+          if options[:options]&.start_with?('INHERITS (')
+            options.delete(:options)
 
-        # 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'
+            tables = inherited_table_names(table_name)
+            options[:inherits] = tables.one? ? tables.first : tables
+          end
 
-          (super || {}).merge(schema: parts[1])
+          options
         end
 
         # When dumping the schema we need to add all schemas, not only those
@@ -112,7 +118,10 @@ module Torque
         def quoted_scope(name = nil, type: nil)
           return super unless name.nil?
 
-          super.merge(schema: "ANY ('{#{user_defined_schemas.join(',')}}')")
+          scope = super
+          global = scope[:schema].start_with?('ANY (')
+          scope[:schema] = "ANY ('{#{user_defined_schemas.join(',')}}')"
+          scope
         end
 
         # Fix the query to include the schema on tables names when dumping
@@ -128,6 +137,51 @@ module Torque
           super + [:schema, :inherits]
         end
 
+        # Add proper support for schema load when using versioned commands
+        def assume_migrated_upto_version(version)
+          return super unless PostgreSQL.config.versioned_commands.enabled
+          return super if (commands = pool.migration_context.migration_commands).empty?
+
+          version = version.to_i
+          migration_context = pool.migration_context
+          migrated = migration_context.get_all_versions
+          versions = migration_context.migrations.map(&:version)
+
+          inserting = (versions - migrated).select { |v| v < version }
+          inserting << version unless migrated.include?(version)
+          return if inserting.empty?
+
+          duplicated = inserting.tally.filter_map { |v, count| v if count > 1 }
+          raise <<~MSG.squish if duplicated.present?
+            Duplicate migration #{duplicated.first}.
+            Please renumber your migrations to resolve the conflict.
+          MSG
+
+          VersionedCommands::SchemaTable.new(pool).create_table
+          execute insert_versions_sql(inserting)
+        end
+
+        # Add proper support for schema load when using versioned commands
+        def insert_versions_sql(versions)
+          return super unless PostgreSQL.config.versioned_commands.enabled
+
+          commands = pool.migration_context.migration_commands.select do |migration|
+            versions.include?(migration.version)
+          end
+
+          return super if commands.empty?
+
+          table = quote_table_name(VersionedCommands::SchemaTable.new(pool).table_name)
+
+          sql = super(versions - commands.map(&:version))
+          sql << "\nINSERT INTO #{table} (version, type, object_name) VALUES\n"
+          sql << commands.map do |m|
+            +"(#{quote(m.version)}, #{quote(m.type)}, #{quote(m.object_name)})"
+          end.join(",\n")
+          sql << ";"
+          sql
+        end
+
         private
 
           # Remove the schema from the sequence name
@@ -135,6 +189,12 @@ module Torque
             super(table_name.split('.').last, column_name, suffix)
           end
 
+          # Helper for supporting schema name in several methods
+          def sanitize_name_with_schema(name, options)
+            return name if (schema = options&.delete(:schema)).blank?
+            Quoting::Name.new(schema.to_s, name.to_s)
+          end
+
           def quote_enum_values(name, values, options)
             prefix = options[:prefix]
             prefix = name if prefix === true

data/lib/torque/postgresql/arel/infix_operation.rb

@@ -3,39 +3,26 @@
 module Torque
   module PostgreSQL
     module Arel
-      nodes = ::Arel::Nodes
-      inflix = nodes::InfixOperation
-      visitors = ::Arel::Visitors::PostgreSQL
-      default_alias = :visit_Arel_Nodes_InfixOperation
-
       Math = Module.new
-      INFLIX_OPERATION = {
-        'Overlaps'          => :'&&',
-        'Contains'          => :'@>',
-        'ContainedBy'       => :'<@',
-        'HasKey'            => :'?',
-        'HasAllKeys'        => :'?&',
-        'HasAnyKeys'        => :'?|',
-        'StrictlyLeft'      => :'<<',
-        'StrictlyRight'     => :'>>',
-        'DoesntRightExtend' => :'&<',
-        'DoesntLeftExtend'  => :'&>',
-        'AdjacentTo'        => :'-|-',
-      }.freeze
 
-      INFLIX_OPERATION.each do |operator_name, operator|
-        next if nodes.const_defined?(operator_name)
+      def self.build_operations(operations)
+        default_alias = :visit_Arel_Nodes_InfixOperation
+
+        operations&.each do |name, operator|
+          klass_name = name.to_s.camelize
+          next if ::Arel::Nodes.const_defined?(klass_name)
 
-        klass = Class.new(inflix)
-        klass.send(:define_method, :initialize) { |*args| super(operator, *args) }
+          klass = Class.new(::Arel::Nodes::InfixOperation)
+          operator = (-operator).to_sym
+          klass.send(:define_method, :initialize) { |*args| super(operator, *args) }
 
-        nodes.const_set(operator_name, klass)
-        visitors.send(:alias_method, :"visit_Arel_Nodes_#{operator_name}", default_alias)
+          ::Arel::Nodes.const_set(klass_name, klass)
+          visitor = :"visit_Arel_Nodes_#{klass_name}"
+          ::Arel::Visitors::PostgreSQL.send(:alias_method, visitor, default_alias)
 
-        # Don't worry about quoting here, if the right side is something that
-        # doesn't need quoting, it will leave it as it is
-        Math.send(:define_method, operator_name.underscore) do |other|
-          klass.new(self, other)
+          # Don't worry about quoting here, if the right side is something that
+          # doesn't need quoting, it will leave it as it is
+          Math.send(:define_method, klass_name.underscore) { |other| klass.new(self, other) }
         end
       end
 

data/lib/torque/postgresql/arel/nodes.rb

@@ -13,18 +13,32 @@ module Torque
           include ::Arel::Math
 
           def initialize(left, right, array = false)
-            right = right.to_s
+            right = +right.to_s
             right << '[]' if array
             super left, right
           end
         end
 
+        class Ref < ::Arel::Nodes::Unary
+          attr_reader :reference
+          alias to_s expr
+
+          def initialize(expr, reference = nil)
+            @reference = reference
+            super expr
+          end
+
+          def as(other)
+            @reference&.as(other) || super
+          end
+        end
+
       end
 
       ::Arel.define_singleton_method(:array) do |*values, cast: nil|
         values = values.first if values.size.eql?(1) && values.first.is_a?(::Enumerable)
         result = ::Arel::Nodes.build_quoted(values)
-        result = result.cast(cast, true) if cast.present?
+        result = result.pg_cast(cast, true) if cast.present?
         result
       end
 

data/lib/torque/postgresql/arel/operations.rb

@@ -6,10 +6,16 @@ module Torque
       module Operations
 
         # Create a cast operation
-        def cast(type, array = false)
+        def pg_cast(type, array = false)
           Nodes::Cast.new(self, type, array)
         end
 
+        # Make sure to add proper support over AR's own +cast+ method while
+        # still allow attributes to be casted
+        def cast(type, array = false)
+          defined?(super) && !array ? super(type) : pg_cast(type, array)
+        end
+
       end
 
       ::Arel::Attributes::Attribute.include(Operations)

data/lib/torque/postgresql/arel/visitors.rb

@@ -4,13 +4,6 @@ module Torque
   module PostgreSQL
     module Arel
       module Visitors
-        # Enclose select manager with parenthesis
-        # :TODO: Remove when checking the new version of Arel
-        def visit_Arel_SelectManager(o, collector)
-          collector << '('
-          visit(o.ast, collector) << ')'
-        end
-
         # Add ONLY modifier to query
         def visit_Arel_Nodes_JoinSource(o, collector)
           collector << 'ONLY ' if o.only?
@@ -26,11 +19,16 @@ module Torque
         # Allow quoted arrays to get here
         def visit_Arel_Nodes_Casted(o, collector)
           value = o.value_for_database
-          return super unless value.is_a?(::Enumerable)
-          quote_array(value, collector)
+          klass = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array::Data
+          return super unless value.is_a?(klass)
+          quote_array(value.values, collector)
         end
 
         ## TORQUE VISITORS
+        def visit_Torque_PostgreSQL_Arel_Nodes_Ref(o, collector)
+          collector << quote_table_name(o.expr)
+        end
+
         # Allow casting any node
         def visit_Torque_PostgreSQL_Arel_Nodes_Cast(o, collector)
           visit(o.left, collector) << '::' << o.right