sequel 3.36.1 → 3.37.0

data/lib/sequel/extensions/core_extensions.rb

@@ -2,6 +2,12 @@
 # They make using Sequel's DSL easier by adding methods to Array,
 # Hash, String, and Symbol to add methods that return Sequel
 # expression objects.
+#
+# This extension is currently loaded by default, but that will no
+# longer be true in a future version.  In a future version, you will
+# need to load it manually via:
+#
+#   Sequel.extension :core_extensions
 
 # This extension loads the core extensions.
 def Sequel.core_extensions?

data/lib/sequel/extensions/eval_inspect.rb

@@ -0,0 +1,158 @@
+# The eval_inspect extension changes #inspect for Sequel::SQL::Expression
+# subclasses to return a string suitable for ruby's eval, such that
+#
+#   eval(obj.inspect) == obj
+#
+# is true.  The above code is true for most of ruby's simple classes such
+# as String, Integer, Float, and Symbol, but it's not true for classes such
+# as Time, Date, and BigDecimal.  Sequel attempts to handle situations where
+# instances of these classes are a component of a Sequel expression.
+#
+# To load the extension:
+#
+#   Sequel.extension :eval_inspect
+
+module Sequel
+  module EvalInspect
+    # Special case objects where inspect does not generally produce input
+    # suitable for eval.  Used by Sequel::SQL::Expression#inspect so that
+    # it can produce a string suitable for eval even if components of the
+    # expression have inspect methods that do not produce strings suitable
+    # for eval.
+    def eval_inspect(obj)
+      case obj
+      when Sequel::SQL::Blob, Sequel::LiteralString, Sequel::SQL::ValueList
+        "#{obj.class}.new(#{obj.inspect})"
+      when Array
+        "[#{obj.map{|o| eval_inspect(o)}.join(', ')}]"
+      when Hash
+        "{#{obj.map{|k, v| "#{eval_inspect(k)} => #{eval_inspect(v)}"}.join(', ')}}"
+      when Time
+        if RUBY_VERSION < '1.9'
+          # Time on 1.8 doesn't handle %N (or %z on Windows), manually set the usec value in the string
+          hours, mins = obj.utc_offset.divmod(3600)
+          mins /= 60
+          "#{obj.class}.parse(#{obj.strftime("%Y-%m-%dT%H:%M:%S.#{sprintf('%06i%+03i%02i', obj.usec, hours, mins)}").inspect})#{'.utc' if obj.utc?}"
+        else
+          "#{obj.class}.parse(#{obj.strftime('%FT%T.%N%z').inspect})#{'.utc' if obj.utc?}"
+        end
+      when DateTime
+        # Ignore date of calendar reform
+        "DateTime.parse(#{obj.strftime('%FT%T.%N%z').inspect})"
+      when Date
+        # Ignore offset and date of calendar reform
+        "Date.new(#{obj.year}, #{obj.month}, #{obj.day})"
+      when BigDecimal
+        "BigDecimal.new(#{obj.to_s.inspect})"
+      else
+        obj.inspect
+      end
+    end
+  end
+
+  extend EvalInspect
+
+  module SQL
+    class Expression
+      # Attempt to produce a string suitable for eval, such that:
+      #
+      #   eval(obj.inspect) == obj
+      def inspect
+        # Assume by default that the object can be recreated by calling
+        # self.class.new with any attr_reader values defined on the class,
+        # in the order they were defined.
+        klass = self.class
+        args = inspect_args.map do |arg|
+          if arg.is_a?(String) && arg =~ /\A\*/
+            # Special case string arguments starting with *, indicating that
+            # they should return an array to be splatted as the remaining arguments
+            send(arg.sub('*', '')).map{|a| Sequel.eval_inspect(a)}.join(', ')
+          else
+            Sequel.eval_inspect(send(arg))
+          end
+        end
+        "#{klass}.new(#{args.join(', ')})"
+      end
+
+      private
+
+      # Which attribute values to use in the inspect string.
+      def inspect_args
+        self.class.comparison_attrs
+      end
+    end
+
+    class ComplexExpression
+      private
+
+      # ComplexExpression's initializer uses a splat for the operator arguments.
+      def inspect_args
+        [:op, "*args"]
+      end
+    end
+
+    class CaseExpression
+      private
+
+      # CaseExpression's initializer checks whether an argument was
+      # provided, to differentiate CASE WHEN from CASE NULL WHEN, so
+      # check if an expression was provided, and only include the
+      # expression in the inspect output if so.
+      def inspect_args
+        if expression?
+          [:conditions, :default, :expression]
+        else
+          [:conditions, :default]
+        end
+      end
+    end
+
+    class Function
+      private
+
+      # Function's initializer uses a splat for the function arguments.
+      def inspect_args
+        [:f, "*args"]
+      end
+    end
+
+    class JoinOnClause
+      private
+
+      # JoinOnClause's initializer takes the on argument as the first argument
+      # instead of the last.
+      def inspect_args
+        [:on, :join_type, :table, :table_alias] 
+      end
+    end
+
+    class JoinUsingClause
+      private
+
+      # JoinOnClause's initializer takes the using argument as the first argument
+      # instead of the last.
+      def inspect_args
+        [:using, :join_type, :table, :table_alias] 
+      end
+    end
+
+    class OrderedExpression
+      private
+
+      # OrderedExpression's initializer takes the :nulls information inside a hash,
+      # so if a NULL order was given, include a hash with that information.
+      def inspect_args
+        if nulls
+          [:expression, :descending, :opts_hash]
+        else
+          [:expression, :descending]
+        end
+      end
+
+      # A hash of null information suitable for passing to the initializer.
+      def opts_hash
+        {:nulls=>nulls} 
+      end
+    end
+  end
+end

data/lib/sequel/extensions/inflector.rb

@@ -2,6 +2,10 @@
 # words from singular to plural, class names to table names, modularized class
 # names to ones without, and class names to foreign keys.  It exists for 
 # backwards compatibility to legacy Sequel code.
+#
+# To load the extension:
+#
+#   Sequel.extension :inflector
 
 class String
   # This module acts as a singleton returned/yielded by String.inflections,

data/lib/sequel/extensions/looser_typecasting.rb

@@ -1,10 +1,8 @@
 # The LooserTypecasting extension changes the float and integer typecasting to
 # use the looser .to_f and .to_i instead of the more strict Kernel.Float and
-# Kernel.Integer.  To use it, you should extend the database with the
-# Sequel::LooserTypecasting module after loading the extension:
+# Kernel.Integer.  To load the extension into the database:
 #
-#   Sequel.extension :looser_typecasting
-#   DB.extend(Sequel::LooserTypecasting)
+#   DB.extension :looser_typecasting
 
 module Sequel
   module LooserTypecasting
@@ -18,4 +16,7 @@ module Sequel
       value.to_i
     end
   end
+
+  Database.register_extension(:looser_typecasting, LooserTypecasting)
 end
+

data/lib/sequel/extensions/migration.rb

@@ -1,8 +1,11 @@
 # Adds the Sequel::Migration and Sequel::Migrator classes, which allow
 # the user to easily group schema changes and migrate the database
 # to a newer version or revert to a previous version.
-
 #
+# To load the extension:
+#
+#   Sequel.extension :migration
+
 module Sequel
   # Sequel's older migration class, available for backward compatibility.
   # Uses subclasses with up and down instance methods for each migration:

data/lib/sequel/extensions/named_timezones.rb

@@ -8,6 +8,10 @@
 # typecast_timezone=.  If a string is passed, it is converted to a
 # TZInfo::Timezone using TZInfo::Timezone.get.
 #
+# To load the extension:
+#
+#   Sequel.extension :named_timezones
+#
 # Let's say you have the database server in New York and the
 # application server in Los Angeles.  For historical reasons, data
 # is stored in local New York time, but the application server only

data/lib/sequel/extensions/null_dataset.rb

@@ -2,6 +2,10 @@
 # returns a cloned dataset that will never issue a query to the
 # database.  It implements the null object pattern for datasets.
 #
+# To load the extension:
+#
+#   Sequel.extension :null_dataset
+#
 # The most common usage is probably in a method that must return
 # a dataset, where the method knows the dataset shouldn't return
 # anything.  With standard Sequel, you'd probably just add a

data/lib/sequel/extensions/pagination.rb

@@ -1,6 +1,10 @@
 # The pagination extension adds the Sequel::Dataset#paginate and #each_page methods,
 # which return paginated (limited and offset) datasets with some helpful methods
 # that make creating a paginated display easier.
+#
+# To load the extension:
+#
+#   Sequel.extension :pagination
 
 module Sequel
   class Dataset

data/lib/sequel/extensions/pg_array.rb

@@ -1,14 +1,9 @@
 # The pg_array extension adds support for Sequel to handle
-# PostgreSQL's string and numeric array types.  It supports both
-# single and multi-dimensional arrays.  For integer and
-# float arrays, it uses a JSON-based parser which is usually written in C
-# and should be fairly fast.  For string and decimal arrays, it uses
-# a hand coded parser written in ruby that is unoptimized and probably
-# slow.
+# PostgreSQL's array types.
 #
 # This extension integrates with Sequel's native postgres adapter, so
 # that when array fields are retrieved, they are parsed and returned
-# as instances of Sequel::Postgres::PGArray subclasses.  PGArray is
+# as instances of Sequel::Postgres::PGArray.  PGArray is
 # a DelegateClass of Array, so it mostly acts like an array, but not
 # completely (is_a?(Array) is false).  If you want the actual array,
 # you can call PGArray#to_a.  This is done so that Sequel does not
@@ -24,9 +19,9 @@
 #
 # You can also provide a type, though it many cases it isn't necessary:
 #
-#   array.pg_array(:varchar) # or :int4, :"double precision", etc.
+#   array.pg_array(:varchar) # or :integer, :"double precision", etc.
 #
-# So if you want to insert an array into an int4[] database column:
+# So if you want to insert an array into an integer[] database column:
 #
 #   DB[:table].insert(:column=>[1, 2, 3].pg_array)
 #
@@ -34,12 +29,31 @@
 # probably want to modify the schema parsing/typecasting so that it
 # recognizes and correctly handles the arrays, which you can do by:
 #
-#   DB.extend Sequel::Postgres::PGArray::DatabaseMethods
+#   DB.extension :pg_array
 #
 # If you are not using the native postgres adapter, you probably
 # also want to use the typecast_on_load plugin in the model, and
 # set it to typecast the array column(s) on load.
 #
+# This extension by default includes handlers for array types for
+# all scalar types that the native postgres adapter handles. It
+# also makes it easy to add support for other array types.  In
+# general, you just need to make sure that the scalar type is
+# handled and has the appropriate converter installed in
+# Sequel::Postgres::PG_TYPES under the appropriate type OID.
+# Then you can call Sequel::Postgres::PGArray.register with
+# the appropriate arguments to automatically set up a handler
+# for the array type.
+#
+# For example, if you add support for a scalar custom type named
+# foo which uses OID 1234, and you want to add support for the
+# foo[] type, which uses type OID 4321, you need to do:
+#
+#   Sequel::Postgres::PGArray.register('foo', :oid=>4321, :scalar_oid=>1234)
+#
+# Sequel::Postgres::PGArray.register has many additional options
+# and should be able to handle most PostgreSQL array types.
+#
 # If you want an easy way to call PostgreSQL array functions and
 # operators, look into the pg_array_ops extension.
 #
@@ -73,12 +87,11 @@
 
 require 'delegate'
 require 'json'
+Sequel.require 'adapters/utils/pg_types'
 
 module Sequel
   module Postgres
-    # Base class for the PostgreSQL array types.  Subclasses generally
-    # just deal with parsing, so instances manually created from arrays
-    # can use this class correctly.
+    # Represents a PostgreSQL array column value.
     class PGArray < DelegateClass(Array)
       ARRAY = "ARRAY".freeze
       DOUBLE_COLON = '::'.freeze
@@ -93,9 +106,80 @@ module Sequel
       NULL = 'NULL'.freeze
       QUOTE = '"'.freeze
 
+      # Hash of database array type name strings to symbols (e.g. 'double precision' => :float),
+      # used by the schema parsing.
+      ARRAY_TYPES = {}
+
+      # Registers an array type that the extension should handle.  Makes a Database instance that
+      # has been extended with DatabaseMethods recognize the array type given and set up the
+      # appropriate typecasting.  Also sets up automatic typecasting for the native postgres
+      # adapter, so that on retrieval, the values are automatically converted to PGArray instances.
+      # The db_type argument should be the exact database type used (as returned by the PostgreSQL
+      # format_type database function).  Accepts the following options:
+      #
+      # :array_type :: The type to automatically cast the array to when literalizing the array.
+      #                Usually the same as db_type.
+      # :converter :: A callable object (e.g. Proc), that is called with each element of the array
+      #               (usually a string), and should return the appropriate typecasted object.
+      # :oid :: The PostgreSQL OID for the array type.  This is used by the Sequel postgres adapter
+      #         to set up automatic type conversion on retrieval from the database.
+      # :parser :: Can be set to :json to use the faster JSON-based parser.  Note that the JSON-based
+      #            parser can only correctly handle integers values correctly.  It doesn't handle
+      #            full precision for numeric types, and doesn't handle NaN/Infinity values for
+      #            floating point types.
+      # :scalar_oid :: Should be the PostgreSQL OID for the scalar version of this array type. If given,
+      #                automatically sets the :converter option by looking for scalar conversion
+      #                proc.
+      # :scalar_typecast :: Should be a symbol indicating the typecast method that should be called on
+      #                     each element of the array, when a plain array is passed into a database
+      #                     typecast method.  For example, for an array of integers, this could be set to
+      #                     :integer, so that the typecast_value_integer method is called on all of the
+      #                     array elements.  Defaults to :type_symbol option.
+      # :type_symbol :: The base of the schema type symbol for this type.  For example, if you provide
+      #                 :integer, Sequel will recognize this type as :integer_array during schema parsing.
+      #                 Defaults to the db_type argument.
+      # :typecast_method :: If given, specifies the :type_symbol option, but additionally causes no
+      #                     typecasting method to be created in the database.  This should only be used
+      #                     to alias existing array types.  For example, if there is an array type that can be
+      #                     treated just like an integer array, you can do :typecast_method=>:integer.
+      #
+      # If a block is given, it is treated as the :converter option.
+      def self.register(db_type, opts={}, &block)
+        db_type = db_type.to_s
+        typecast_method = opts[:typecast_method]
+        type = (typecast_method || opts[:type_symbol] || db_type).to_sym
+
+        if converter = opts[:converter]
+          raise Error, "can't provide both a block and :converter option to register" if block
+        else
+          converter = block
+        end
+
+        if soid = opts[:scalar_oid]
+          raise Error, "can't provide both a converter and :scalar_oid option to register" if converter 
+          raise Error, "no conversion proc for :scalar_oid=>#{soid.inspect} in PG_TYPES" unless converter = PG_TYPES[soid]
+        end
+
+        array_type = (opts[:array_type] || db_type).to_s.dup.freeze
+        creator = (opts[:parser] == :json ? JSONCreator : Creator).new(array_type, converter)
+
+        ARRAY_TYPES[db_type] = :"#{type}_array"
+
+        DatabaseMethods.define_array_typecast_method(type, creator, opts.fetch(:scalar_typecast, type)) unless typecast_method
+
+        if oid = opts[:oid]
+          Sequel::Postgres::PG_TYPES[oid] = creator
+        end
+
+        nil
+      end
+
       module DatabaseMethods
+        APOS = "'".freeze
+        DOUBLE_APOS = "''".freeze
         ESCAPE_RE = /("|\\)/.freeze
         ESCAPE_REPLACEMENT = '\\\\\1'.freeze
+        BLOB_RANGE = 1...-1
 
         # Reset the conversion procs when extending the Database object, so
         # it will pick up the array convertors.  This is only done for the native
@@ -104,6 +188,15 @@ module Sequel
           db.reset_conversion_procs if db.respond_to?(:reset_conversion_procs)
         end
 
+        # Define a private array typecasting method for the given type that uses
+        # the creator argument to do the type conversion.
+        def self.define_array_typecast_method(type, creator, scalar_typecast)
+          meth = :"typecast_value_#{type}_array"
+          scalar_typecast_method = :"typecast_value_#{scalar_typecast}"
+          define_method(meth){|v| typecast_value_pg_array(v, creator, scalar_typecast_method)}
+          private meth
+        end
+
         # Handle arrays in bound variables
         def bound_variable_arg(arg, conn)
           case arg
@@ -116,17 +209,10 @@ module Sequel
           end
         end
 
-        # Make the column type detection deal with string and numeric array types.
+        # Make the column type detection handle registered array types.
         def schema_column_type(db_type)
-          case db_type
-          when /\A(character( varying)?|text).*\[\]\z/io
-            :string_array
-          when /\A(integer|bigint|smallint)\[\]\z/io
-            :integer_array
-          when /\A(real|double precision)\[\]\z/io
-            :float_array
-          when /\Anumeric.*\[\]\z/io
-            :decimal_array
+          if (db_type =~ /\A([^(]+)(?:\([^(]+\))?\[\]\z/io) && (type = ARRAY_TYPES[$1])
+            type
           else
             super
           end
@@ -139,6 +225,10 @@ module Sequel
           case a
           when Array
             "{#{a.map{|i| bound_variable_array(i)}.join(COMMA)}}"
+          when Sequel::SQL::Blob
+            "\"#{literal(a)[BLOB_RANGE].gsub(DOUBLE_APOS, APOS).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)}\""
+          when Sequel::LiteralString
+            a
           when String
             "\"#{a.gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)}\""
           else
@@ -146,38 +236,55 @@ module Sequel
           end
         end
 
+        # Manually override the typecasting for timestamp array types so that
+        # they use the database's timezone instead of the global Sequel
+        # timezone.
+        def get_conversion_procs(conn)
+          procs = super
+
+          converter = method(:to_application_timestamp)
+          procs[1115] = Creator.new("timestamp without time zone", converter)
+          procs[1185] = Creator.new("timestamp with time zone", converter)
+
+          procs
+        end
+
         # Given a value to typecast and the type of PGArray subclass:
-        # * If given a PGArray, just return the value (even if different subclass)
-        # * If given an Array, create a new instance of the subclass
+        # * If given a PGArray with a matching array_type, use it directly.
+        # * If given a PGArray with a different array_type, return a PGArray
+        #   with the creator's type.
+        # * If given an Array, create a new PGArray instance for it.  This does not
+        #   typecast all members of the array in ruby for performance reasons, but
+        #   it will cast the array the appropriate database type when the array is
+        #   literalized.
         # * If given a String, call the parser for the subclass with it.
-        def typecast_value_pg_array(value, klass)
+        def typecast_value_pg_array(value, creator, scalar_typecast_method=nil)
           case value
           when PGArray
-            value
+            if value.array_type != creator.type
+              PGArray.new(value.to_a, creator.type)
+            else
+              value
+            end
           when Array
-            klass.new(value)
+            if scalar_typecast_method && respond_to?(scalar_typecast_method, true)
+              value = Sequel.recursive_map(value, method(scalar_typecast_method))
+            end
+            PGArray.new(value, creator.type)
           when String
-            klass.parse(value)
+            creator.call(value)
           else
-            raise Sequel::InvalidValue, "invalid value for #{klass}: #{value.inspect}"
+            raise Sequel::InvalidValue, "invalid value for array type: #{value.inspect}"
           end
         end
-
-        # Create typecast methods for the supported array types that
-        # delegate to typecast_value_pg_array with the related class.
-        %w'string integer float decimal'.each do |t|
-          class_eval("def typecast_value_#{t}_array(v) typecast_value_pg_array(v, PG#{t.capitalize}Array) end", __FILE__, __LINE__)
-        end
       end
 
-      # PostgreSQL array parser that handles both text and numeric
-      # input.  Because PostgreSQL arrays can contain objects that
-      # can be literalized in any number of ways, it is not possible
-      # to make a fully generic parser.
+      # PostgreSQL array parser that handles all types of input.
       #
       # This parser is very simple and unoptimized, but should still
       # be O(n) where n is the length of the input string.
       class Parser
+        # Current position in the input string.
         attr_reader :pos
 
         # Set the source for the input, and any converter callable
@@ -269,19 +376,58 @@ module Sequel
           raise Sequel::Error, "array dimensions not balanced" unless @dimension == 0
           @entries
         end
-      end
+      end unless Sequel::Postgres.respond_to?(:parse_pg_array)
+
+      # Callable object that takes the input string and parses it using Parser.
+      class Creator
+        # The converter callable that is called on each member of the array
+        # to convert it to the correct type.
+        attr_reader :converter
 
-      # Parse the string using the generalized parser, setting the type
-      # if given.
-      def self.parse(string, type=nil)
-        new(Parser.new(string, method(:convert_item)).parse, type)
+        # The database type to set on the PGArray instances returned.
+        attr_reader :type
+
+        # Set the type and optional converter callable that will be used.
+        def initialize(type, converter=nil)
+          @type = type
+          @converter = converter
+        end
+
+        if Sequel::Postgres.respond_to?(:parse_pg_array)
+          # Use sequel_pg's C-based parser if it has already been defined.
+          def call(string)
+            PGArray.new(Sequel::Postgres.parse_pg_array(string, @converter), @type)
+          end
+        else
+          # Parse the string using Parser with the appropriate
+          # converter, and return a PGArray with the appropriate database
+          # type.
+          def call(string)
+            PGArray.new(Parser.new(string, @converter).parse, @type)
+          end
+        end
       end
 
-      # Return the item as-is by default, making conversion a no-op.
-      def self.convert_item(s)
-        s
+      # Callable object that takes the input string and parses it using.
+      # a JSON parser.  This should be faster than the standard Creator,
+      # but only handles integer types correctly.
+      class JSONCreator < Creator
+        # Character conversion map mapping input strings to JSON replacements
+        SUBST = {'{'.freeze=>'['.freeze, '}'.freeze=>']'.freeze, 'NULL'.freeze=>'null'.freeze}
+
+        # Regular expression matching input strings to convert
+        SUBST_RE = %r[\{|\}|NULL].freeze
+
+        # Parse the input string by using a gsub to convert non-JSON characters to
+        # JSON, running it through a regular JSON parser. If a converter is used, a
+        # recursive map of the output is done to make sure that the entires in the
+        # correct type.
+        def call(string)
+          array = JSON.parse(string.gsub(SUBST_RE){|m| SUBST[m]})
+          array = Sequel.recursive_map(array, @converter) if @converter
+          PGArray.new(array, @type)
+        end
       end
-      private_class_method :convert_item
 
       # The type of this array.  May be nil if no type was given. If a type
       # is provided, the array is automatically casted to this type when
@@ -292,12 +438,9 @@ module Sequel
       # Set the array to delegate to, and a database type.
       def initialize(array, type=nil)
         super(array)
-        self.array_type = type
+        @array_type = type
       end
 
-      # The delegated object is always an array.
-      alias to_a __getobj__
-
       # Append the array SQL to the given sql string. 
       # If the receiver has a type, add a cast to the
       # database array type.
@@ -329,124 +472,32 @@ module Sequel
         end
         sql << CLOSE_BRACKET
       end
-    end
-
-    # PGArray subclass handling integer and float types, using a fast JSON
-    # parser.  Does not handle numeric/decimal types, since JSON does deal
-    # with arbitrary precision (see PGDecimalArray for that).
-    class PGNumericArray < PGArray
-      # Character conversion map mapping input strings to JSON replacements
-      SUBST = {'{'.freeze=>'['.freeze, '}'.freeze=>']'.freeze, 'NULL'.freeze=>'null'.freeze}
-
-      # Regular expression matching input strings to convert
-      SUBST_RE = %r[\{|\}|NULL].freeze
-
-      # Parse the input string by using a gsub to convert non-JSON characters to
-      # JSON, running it through a regular JSON parser, and the doing a recursive
-      # map over the output to make sure the entries are in the correct type (mostly,
-      # to make sure real/double precision database types are returned as float and
-      # not integer).
-      def self.parse(string, type=nil)
-        new(recursive_map(JSON.parse(string.gsub(SUBST_RE){|m| SUBST[m]})), type)
-      end
-
-      # Convert each item in the array to the correct type, handling multi-dimensional
-      # arrays.
-      def self.recursive_map(array)
-        array.map do |i|
-          if i.is_a?(Array)
-            recursive_map(i)
-          elsif i
-            convert_item(i)
-          end
-        end
-      end
-      private_class_method :recursive_map
-    end
-
-    # PGArray subclass for decimal/numeric types.  Uses the general
-    # parser as the JSON parser cannot handle arbitrary precision numbers.
-    class PGDecimalArray < PGArray
-      # Convert the item to a BigDecimal.
-      def self.convert_item(s)
-        BigDecimal.new(s.to_s)
-      end
-      private_class_method :convert_item
-
-      ARRAY_TYPE = 'decimal'.freeze
-
-      # Use the decimal type by default.
-      def array_type
-        super || ARRAY_TYPE
-      end
-    end
-
-    # PGArray subclass for handling real/double precision arrays.
-    class PGFloatArray < PGNumericArray
-      # Convert the item to a float.
-      def self.convert_item(s)
-        s.to_f
-      end
-      private_class_method :convert_item
-
-      ARRAY_TYPE = 'double precision'.freeze
-
-      # Use the double precision type by default.
-      def array_type
-        super || ARRAY_TYPE
-      end
-    end
-
-    # PGArray subclass for handling int2/int4/int8 arrays.
-    class PGIntegerArray < PGNumericArray
-      ARRAY_TYPE = 'int4'.freeze
-
-      # Use the int4 type by default.
-      def array_type
-        super || ARRAY_TYPE
-      end
-    end
 
-    # PGArray subclass for handling char/varchar/text arrays.
-    class PGStringArray < PGArray
-      CHAR = 'char'.freeze
-      VARCHAR = 'varchar'.freeze
-      TEXT = 'text'.freeze
-
-      # By default, use a text array.  If char is given without
-      # a size, use varchar instead, as otherwise Postgres assumes
-      # length of 1, which is likely to cause data loss.
-      def array_type
-        case (c = super)
-        when nil 
-          TEXT
-        when CHAR, :char
-          VARCHAR
-        else
-          c
-        end
-      end
-    end
-
-    PG_TYPES = {} unless defined?(PG_TYPES)
-
-    # Automatically convert the built-in numeric and text array
-    # types. to PGArray instances on retrieval if the native
-    # postgres adapter is used.
-    [ [1005, PGIntegerArray, 'int2'.freeze],
-      [1007, PGIntegerArray, 'int4'.freeze],
-      [1016, PGIntegerArray, 'int8'.freeze],
-      [1021, PGFloatArray, 'real'.freeze],
-      [1022, PGFloatArray, 'double precision'.freeze],
-      [1231, PGDecimalArray, 'numeric'.freeze],
-      [1009, PGStringArray, 'text'.freeze],
-      [1014, PGStringArray, 'char'.freeze],
-      [1015, PGStringArray, 'varchar'.freeze]
-    ].each do |ftype, klass, type|
-      meth = klass.method(:parse)
-      PG_TYPES[ftype] = lambda{|s| meth.call(s, type)}
+      # Register all array types that this extension handles by default.
+
+      register('text', :oid=>1009, :type_symbol=>:string)
+      register('integer', :oid=>1007, :parser=>:json)
+      register('bigint', :oid=>1016, :parser=>:json, :scalar_typecast=>:integer)
+      register('numeric', :oid=>1231, :scalar_oid=>1700, :type_symbol=>:decimal)
+      register('double precision', :oid=>1022, :scalar_oid=>701, :type_symbol=>:float)
+
+      register('boolean', :oid=>1000, :scalar_oid=>16)
+      register('bytea', :oid=>1001, :scalar_oid=>17, :type_symbol=>:blob)
+      register('date', :oid=>1182, :scalar_oid=>1082)
+      register('time without time zone', :oid=>1183, :scalar_oid=>1083, :type_symbol=>:time)
+      register('timestamp without time zone', :oid=>1115, :scalar_oid=>1114, :type_symbol=>:datetime)
+      register('time with time zone', :oid=>1270, :scalar_oid=>1083, :type_symbol=>:time_timezone, :scalar_typecast=>:time)
+      register('timestamp with time zone', :oid=>1185, :scalar_oid=>1184, :type_symbol=>:datetime_timezone, :scalar_typecast=>:datetime)
+
+      register('smallint', :oid=>1005, :parser=>:json, :typecast_method=>:integer)
+      register('oid', :oid=>1028, :parser=>:json, :typecast_method=>:integer)
+      register('real', :oid=>1021, :scalar_oid=>701, :typecast_method=>:float)
+      register('character', :oid=>1014, :array_type=>:text, :typecast_method=>:string)
+      register('character varying', :oid=>1015, :typecast_method=>:string)
     end
   end
+
+  Database.register_extension(:pg_array, Postgres::PGArray::DatabaseMethods)
 end
 
 class Array