activerecord 4.2.0

data/lib/active_record/connection_adapters/postgresql/oid/range.rb

@@ -0,0 +1,79 @@
+require 'active_support/core_ext/string/filters'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Range < Type::Value # :nodoc:
+          attr_reader :subtype, :type
+
+          def initialize(subtype, type)
+            @subtype = subtype
+            @type = type
+          end
+
+          def type_cast_for_schema(value)
+            value.inspect.gsub('Infinity', '::Float::INFINITY')
+          end
+
+          def cast_value(value)
+            return if value == 'empty'
+            return value if value.is_a?(::Range)
+
+            extracted = extract_bounds(value)
+            from = type_cast_single extracted[:from]
+            to = type_cast_single extracted[:to]
+
+            if !infinity?(from) && extracted[:exclude_start]
+              if from.respond_to?(:succ)
+                from = from.succ
+                ActiveSupport::Deprecation.warn(<<-MSG.squish)
+                  Excluding the beginning of a Range is only partialy supported
+                  through `#succ`. This is not reliable and will be removed in
+                  the future.
+                MSG
+              else
+                raise ArgumentError, "The Ruby Range object does not support excluding the beginning of a Range. (unsupported value: '#{value}')"
+              end
+            end
+            ::Range.new(from, to, extracted[:exclude_end])
+          end
+
+          def type_cast_for_database(value)
+            if value.is_a?(::Range)
+              from = type_cast_single_for_database(value.begin)
+              to = type_cast_single_for_database(value.end)
+              "[#{from},#{to}#{value.exclude_end? ? ')' : ']'}"
+            else
+              super
+            end
+          end
+
+          private
+
+          def type_cast_single(value)
+            infinity?(value) ? value : @subtype.type_cast_from_database(value)
+          end
+
+          def type_cast_single_for_database(value)
+            infinity?(value) ? '' : @subtype.type_cast_for_database(value)
+          end
+
+          def extract_bounds(value)
+            from, to = value[1..-2].split(',')
+            {
+              from:          (value[1] == ',' || from == '-infinity') ? @subtype.infinity(negative: true) : from,
+              to:            (value[-2] == ',' || to == 'infinity') ? @subtype.infinity : to,
+              exclude_start: (value[0] == '('),
+              exclude_end:   (value[-1] == ')')
+            }
+          end
+
+          def infinity?(value)
+            value.respond_to?(:infinite?) && value.infinite?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/oid/specialized_string.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class SpecializedString < Type::String # :nodoc:
+          attr_reader :type
+
+          def initialize(type)
+            @type = type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/oid/time.rb

@@ -0,0 +1,11 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Time < Type::Time # :nodoc:
+          include Infinity
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb

@@ -0,0 +1,97 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        # This class uses the data from PostgreSQL pg_type table to build
+        # the OID -> Type mapping.
+        #   - OID is an integer representing the type.
+        #   - Type is an OID::Type object.
+        # This class has side effects on the +store+ passed during initialization.
+        class TypeMapInitializer # :nodoc:
+          def initialize(store)
+            @store = store
+          end
+
+          def run(records)
+            nodes = records.reject { |row| @store.key? row['oid'].to_i }
+            mapped, nodes = nodes.partition { |row| @store.key? row['typname'] }
+            ranges, nodes = nodes.partition { |row| row['typtype'] == 'r' }
+            enums, nodes = nodes.partition { |row| row['typtype'] == 'e' }
+            domains, nodes = nodes.partition { |row| row['typtype'] == 'd' }
+            arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in' }
+            composites, nodes = nodes.partition { |row| row['typelem'] != '0' }
+
+            mapped.each     { |row| register_mapped_type(row)    }
+            enums.each      { |row| register_enum_type(row)      }
+            domains.each    { |row| register_domain_type(row)    }
+            arrays.each     { |row| register_array_type(row)     }
+            ranges.each     { |row| register_range_type(row)     }
+            composites.each { |row| register_composite_type(row) }
+          end
+
+          private
+          def register_mapped_type(row)
+            alias_type row['oid'], row['typname']
+          end
+
+          def register_enum_type(row)
+            register row['oid'], OID::Enum.new
+          end
+
+          def register_array_type(row)
+            register_with_subtype(row['oid'], row['typelem'].to_i) do |subtype|
+              OID::Array.new(subtype, row['typdelim'])
+            end
+          end
+
+          def register_range_type(row)
+            register_with_subtype(row['oid'], row['rngsubtype'].to_i) do |subtype|
+              OID::Range.new(subtype, row['typname'].to_sym)
+            end
+          end
+
+          def register_domain_type(row)
+            if base_type = @store.lookup(row["typbasetype"].to_i)
+              register row['oid'], base_type
+            else
+              warn "unknown base type (OID: #{row["typbasetype"]}) for domain #{row["typname"]}."
+            end
+          end
+
+          def register_composite_type(row)
+            if subtype = @store.lookup(row['typelem'].to_i)
+              register row['oid'], OID::Vector.new(row['typdelim'], subtype)
+            end
+          end
+
+          def register(oid, oid_type = nil, &block)
+            oid = assert_valid_registration(oid, oid_type || block)
+            if block_given?
+              @store.register_type(oid, &block)
+            else
+              @store.register_type(oid, oid_type)
+            end
+          end
+
+          def alias_type(oid, target)
+            oid = assert_valid_registration(oid, target)
+            @store.alias_type(oid, target)
+          end
+
+          def register_with_subtype(oid, target_oid)
+            if @store.key?(target_oid)
+              register(oid) do |_, *args|
+                yield @store.lookup(target_oid, *args)
+              end
+            end
+          end
+
+          def assert_valid_registration(oid, oid_type)
+            raise ArgumentError, "can't register nil type for OID #{oid}" if oid_type.nil?
+            oid.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/oid/uuid.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Uuid < Type::Value # :nodoc:
+          ACCEPTABLE_UUID = %r{\A\{?([a-fA-F0-9]{4}-?){8}\}?\z}x
+
+          alias_method :type_cast_for_database, :type_cast_from_database
+
+          def type
+            :uuid
+          end
+
+          def type_cast(value)
+            value.to_s[ACCEPTABLE_UUID, 0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/oid/vector.rb

@@ -0,0 +1,26 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Vector < Type::Value # :nodoc:
+          attr_reader :delim, :subtype
+
+          # +delim+ corresponds to the `typdelim` column in the pg_types
+          # table.  +subtype+ is derived from the `typelem` column in the
+          # pg_types table.
+          def initialize(delim, subtype)
+            @delim   = delim
+            @subtype = subtype
+          end
+
+          # FIXME: this should probably split on +delim+ and use +subtype+
+          # to cast the values.  Unfortunately, the current Rails behavior
+          # is to just return the string.
+          def type_cast(value)
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/oid/xml.rb

@@ -0,0 +1,28 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Xml < Type::String # :nodoc:
+          def type
+            :xml
+          end
+
+          def type_cast_for_database(value)
+            return unless value
+            Data.new(super)
+          end
+
+          class Data # :nodoc:
+            def initialize(value)
+              @value = value
+            end
+
+            def to_s
+              @value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/quoting.rb

@@ -0,0 +1,108 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module Quoting
+        # Escapes binary strings for bytea input to the database.
+        def escape_bytea(value)
+          @connection.escape_bytea(value) if value
+        end
+
+        # Unescapes bytea output from a database to the binary string it represents.
+        # NOTE: This is NOT an inverse of escape_bytea! This is only to be used
+        # on escaped binary output from database drive.
+        def unescape_bytea(value)
+          @connection.unescape_bytea(value) if value
+        end
+
+        # Quotes strings for use in SQL input.
+        def quote_string(s) #:nodoc:
+          @connection.escape(s)
+        end
+
+        # Checks the following cases:
+        #
+        # - table_name
+        # - "table.name"
+        # - schema_name.table_name
+        # - schema_name."table.name"
+        # - "schema.name".table_name
+        # - "schema.name"."table.name"
+        def quote_table_name(name)
+          Utils.extract_schema_qualified_name(name.to_s).quoted
+        end
+
+        def quote_table_name_for_assignment(table, attr)
+          quote_column_name(attr)
+        end
+
+        # Quotes column names for use in SQL queries.
+        def quote_column_name(name) #:nodoc:
+          PGconn.quote_ident(name.to_s)
+        end
+
+        # Quote date/time values for use in SQL input. Includes microseconds
+        # if the value is a Time responding to usec.
+        def quoted_date(value) #:nodoc:
+          result = super
+          if value.acts_like?(:time) && value.respond_to?(:usec)
+            result = "#{result}.#{sprintf("%06d", value.usec)}"
+          end
+
+          if value.year <= 0
+            bce_year = format("%04d", -value.year + 1)
+            result = result.sub(/^-?\d+/, bce_year) + " BC"
+          end
+          result
+        end
+
+        # Does not quote function default values for UUID columns
+        def quote_default_value(value, column) #:nodoc:
+          if column.type == :uuid && value =~ /\(\)/
+            value
+          else
+            quote(value, column)
+          end
+        end
+
+        private
+
+        def _quote(value)
+          case value
+          when Type::Binary::Data
+            "'#{escape_bytea(value.to_s)}'"
+          when OID::Xml::Data
+            "xml '#{quote_string(value.to_s)}'"
+          when OID::Bit::Data
+            if value.binary?
+              "B'#{value}'"
+            elsif value.hex?
+              "X'#{value}'"
+            end
+          when Float
+            if value.infinite? || value.nan?
+              "'#{value}'"
+            else
+              super
+            end
+          else
+            super
+          end
+        end
+
+        def _type_cast(value)
+          case value
+          when Type::Binary::Data
+            # Return a bind param hash with format as binary.
+            # See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc
+            # for more information
+            { value: value.to_s, format: 1 }
+          when OID::Xml::Data, OID::Bit::Data
+            value.to_s
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/referential_integrity.rb

@@ -0,0 +1,30 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module ReferentialIntegrity # :nodoc:
+        def supports_disable_referential_integrity? # :nodoc:
+          true
+        end
+
+        def disable_referential_integrity # :nodoc:
+          if supports_disable_referential_integrity?
+            begin
+              execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))
+            rescue
+              execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER USER" }.join(";"))
+            end
+          end
+          yield
+        ensure
+          if supports_disable_referential_integrity?
+            begin
+              execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER ALL" }.join(";"))
+            rescue
+              execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER USER" }.join(";"))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/schema_definitions.rb

@@ -0,0 +1,152 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module ColumnMethods
+        def xml(*args)
+          options = args.extract_options!
+          column(args[0], :xml, options)
+        end
+
+        def tsvector(*args)
+          options = args.extract_options!
+          column(args[0], :tsvector, options)
+        end
+
+        def int4range(name, options = {})
+          column(name, :int4range, options)
+        end
+
+        def int8range(name, options = {})
+          column(name, :int8range, options)
+        end
+
+        def tsrange(name, options = {})
+          column(name, :tsrange, options)
+        end
+
+        def tstzrange(name, options = {})
+          column(name, :tstzrange, options)
+        end
+
+        def numrange(name, options = {})
+          column(name, :numrange, options)
+        end
+
+        def daterange(name, options = {})
+          column(name, :daterange, options)
+        end
+
+        def hstore(name, options = {})
+          column(name, :hstore, options)
+        end
+
+        def ltree(name, options = {})
+          column(name, :ltree, options)
+        end
+
+        def inet(name, options = {})
+          column(name, :inet, options)
+        end
+
+        def cidr(name, options = {})
+          column(name, :cidr, options)
+        end
+
+        def macaddr(name, options = {})
+          column(name, :macaddr, options)
+        end
+
+        def uuid(name, options = {})
+          column(name, :uuid, options)
+        end
+
+        def json(name, options = {})
+          column(name, :json, options)
+        end
+
+        def jsonb(name, options = {})
+          column(name, :jsonb, options)
+        end
+
+        def citext(name, options = {})
+          column(name, :citext, options)
+        end
+
+        def point(name, options = {})
+          column(name, :point, options)
+        end
+
+        def bit(name, options)
+          column(name, :bit, options)
+        end
+
+        def bit_varying(name, options)
+          column(name, :bit_varying, options)
+        end
+
+        def money(name, options)
+          column(name, :money, options)
+        end
+      end
+
+      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
+        attr_accessor :array
+      end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ColumnMethods
+
+        # Defines the primary key field.
+        # Use of the native PostgreSQL UUID type is supported, and can be used
+        # by defining your tables as such:
+        #
+        #   create_table :stuffs, id: :uuid do |t|
+        #     t.string :content
+        #     t.timestamps
+        #   end
+        #
+        # By default, this will use the +uuid_generate_v4()+ function from the
+        # +uuid-ossp+ extension, which MUST be enabled on your database. To enable
+        # the +uuid-ossp+ extension, you can use the +enable_extension+ method in your
+        # migrations. To use a UUID primary key without +uuid-ossp+ enabled, you can
+        # set the +:default+ option to +nil+:
+        #
+        #   create_table :stuffs, id: false do |t|
+        #     t.primary_key :id, :uuid, default: nil
+        #     t.uuid :foo_id
+        #     t.timestamps
+        #   end
+        #
+        # You may also pass a different UUID generation function from +uuid-ossp+
+        # or another library.
+        #
+        # Note that setting the UUID primary key default value to +nil+ will
+        # require you to assure that you always provide a UUID value before saving
+        # a record (as primary keys cannot be +nil+). This might be done via the
+        # +SecureRandom.uuid+ method and a +before_save+ callback, for instance.
+        def primary_key(name, type = :primary_key, options = {})
+          return super unless type == :uuid
+          options[:default] = options.fetch(:default, 'uuid_generate_v4()')
+          options[:primary_key] = true
+          column name, type, options
+        end
+
+        def new_column_definition(name, type, options) # :nodoc:
+          column = super
+          column.array = options[:array]
+          column
+        end
+
+        private
+
+          def create_column_definition(name, type)
+            PostgreSQL::ColumnDefinition.new name, type
+          end
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include ColumnMethods
+      end
+    end
+  end
+end