sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/mssql_emulate_lateral_with_apply.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The mssql_emulate_lateral_with_apply extension converts
 # queries that use LATERAL into queries that use CROSS/OUTER
 # APPLY, allowing code that works on databases that support
@@ -21,6 +23,8 @@
 # Or you can load it into all of a database's datasets:
 #
 #   DB.extension(:mssql_emulate_lateral_with_apply)
+#
+# Related module: Sequel::MSSQL::EmulateLateralWithApply
 
 #
 module Sequel

data/lib/sequel/extensions/named_timezones.rb

@@ -1,17 +1,22 @@
+# frozen-string-literal: true
+#
 # Allows the use of named timezones via TZInfo (requires tzinfo).
 # Forces the use of DateTime as Sequel's datetime_class, since
-# ruby's Time class doesn't support timezones other than local
-# and UTC.
+# historically, Ruby's Time class doesn't support timezones other
+# than local and UTC. To continue using Ruby's Time class when using
+# the named_timezones extension:
+#
+#   # Load the extension
+#   Sequel.extension :named_timezones
+#
+#   # Set Sequel.datetime_class back to Time
+#   Sequel.datetime_class = Time
 #
 # This allows you to either pass strings or TZInfo::Timezone
 # instance to Sequel.database_timezone=, application_timezone=, and
 # 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
@@ -35,7 +40,10 @@
 # Note that typecasting from the database timezone to the application
 # timezone when fetching rows is dependent on the database adapter,
 # and only works on adapters where Sequel itself does the conversion.
-# It should work on mysql, postgres, sqlite, ibmdb, and jdbc.
+# It should work with the mysql, postgres, sqlite, ibmdb, and jdbc
+# adapters.
+#
+# Related module: Sequel::NamedTimezones
 
 require 'tzinfo'
 
@@ -59,24 +67,81 @@ module Sequel
 
     private 
     
-    # Assume the given DateTime has a correct time but a wrong timezone.  It is
-    # currently in UTC timezone, but it should be converted to the input_timezone.
-    # Keep the time the same but convert the timezone to the input_timezone.
-    # Expects the input_timezone to be a TZInfo::Timezone instance.
-    def convert_input_datetime_other(v, input_timezone)
-      local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
-      (v - local_offset).new_offset(local_offset)
+    if RUBY_VERSION >= '2.6'
+      # Convert the given input Time (which must be in UTC) to the given input timezone,
+      # which should be a TZInfo::Timezone instance.
+      def convert_input_time_other(v, input_timezone)
+        Time.new(v.year, v.mon, v.day, v.hour, v.min, (v.sec + Rational(v.nsec, 1000000000)), input_timezone)
+      rescue TZInfo::AmbiguousTime
+        raise unless disamb = tzinfo_disambiguator_for(v)
+        period = input_timezone.period_for_local(v, &disamb)
+        offset = period.utc_total_offset
+        Time.at(v.to_i - offset, :in => input_timezone)
+      end
+
+      # Convert the given input Time to the given output timezone,
+      # which should be a TZInfo::Timezone instance.
+      def convert_output_time_other(v, output_timezone)
+        Time.at(v.to_i, :in => output_timezone)
+      end
+    else
+      # :nodoc:
+      # :nocov:
+      def convert_input_time_other(v, input_timezone)
+        local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+        Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
+      end
+
+      if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
+        def convert_output_time_other(v, output_timezone)
+          v = output_timezone.utc_to_local(v.getutc)
+          local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + local_offset
+        end
+      else
+        def convert_output_time_other(v, output_timezone)
+          v = output_timezone.utc_to_local(v.getutc)
+          local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
+        end
+      end
     end
 
-    # Convert the given DateTime to use the given output_timezone.
-    # Expects the output_timezone to be a TZInfo::Timezone instance.
-    def convert_output_datetime_other(v, output_timezone)
-      # TZInfo converts times, but expects the given DateTime to have an offset
-      # of 0 and always leaves the timezone offset as 0
-      v = output_timezone.utc_to_local(v.new_offset(0))
-      local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
-      # Convert timezone offset from UTC to the offset for the output_timezone
-      (v - local_offset).new_offset(local_offset)
+    # Handle both TZInfo 1 and TZInfo 2
+    if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
+      def convert_input_datetime_other(v, input_timezone)
+        local_offset = Rational(input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset, 86400)
+        (v - local_offset).new_offset(local_offset)
+      end
+
+      def convert_output_datetime_other(v, output_timezone)
+        v = output_timezone.utc_to_local(v.new_offset(0))
+
+        # Force DateTime output instead of TZInfo::DateTimeWithOffset
+        DateTime.jd(v.jd, v.hour, v.minute, v.second + v.sec_fraction, v.offset, v.start)
+      end
+      # :nodoc:
+      # :nocov:
+    else
+      # Assume the given DateTime has a correct time but a wrong timezone.  It is
+      # currently in UTC timezone, but it should be converted to the input_timezone.
+      # Keep the time the same but convert the timezone to the input_timezone.
+      # Expects the input_timezone to be a TZInfo::Timezone instance.
+      def convert_input_datetime_other(v, input_timezone)
+        local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
+        (v - local_offset).new_offset(local_offset)
+      end
+
+      # Convert the given DateTime to use the given output_timezone.
+      # Expects the output_timezone to be a TZInfo::Timezone instance.
+      def convert_output_datetime_other(v, output_timezone)
+        # TZInfo 1 converts times, but expects the given DateTime to have an offset
+        # of 0 and always leaves the timezone offset as 0
+        v = output_timezone.utc_to_local(v.new_offset(0))
+        local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
+        # Convert timezone offset from UTC to the offset for the output_timezone
+        (v - local_offset).new_offset(local_offset)
+      end
     end
     
     # Returns TZInfo::Timezone instance if given a String.

data/lib/sequel/extensions/no_auto_literal_strings.rb

@@ -0,0 +1,4 @@
+# frozen-string-literal: true
+
+Sequel::Database.register_extension(:no_auto_literal_strings){}
+Sequel::Dataset.register_extension(:no_auto_literal_strings){}

data/lib/sequel/extensions/null_dataset.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The null_dataset extension adds the Dataset#nullify method, which
 # returns a cloned dataset that will never issue a query to the
 # database.  It implements the null object pattern for datasets.
@@ -11,7 +13,7 @@
 #
 # Usage:
 #
-#   ds = DB[:items].nullify.where(:a=>:b).select(:c)
+#   ds = DB[:items].nullify.where(a: :b).select(:c)
 #   ds.sql # => "SELECT c FROM items WHERE (a = b)"
 #   ds.all # => [] # no query sent to the database
 #
@@ -30,6 +32,8 @@
 # To add the nullify method to all datasets on a single database:
 #
 #   DB.extension(:null_dataset)
+#
+# Related modules: Sequel::Dataset::Nullifiable, Sequel::Dataset::NullDataset
 
 #
 module Sequel
@@ -37,12 +41,9 @@ module Sequel
     module Nullifiable
       # Return a cloned nullified dataset.
       def nullify
-        clone.nullify!
-      end
-
-      # Nullify the current dataset
-      def nullify!
-        extend NullDataset
+        cached_dataset(:_nullify_ds) do
+          with_extend(NullDataset)
+        end
       end
     end
 
@@ -50,7 +51,10 @@ module Sequel
       # Create a new dataset from the dataset (which won't
       # be nulled) to get the columns if they aren't already cached.
       def columns
-        @columns ||= db.dataset.clone(@opts).columns
+        if cols = _columns
+          return cols
+        end
+        self.columns = db.dataset.clone(@opts).columns
       end
 
       # Return 0 without sending a database query.

data/lib/sequel/extensions/pagination.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pagination extension adds the Sequel::Dataset#paginate and #each_page methods,
 # which return paginated (limited and offset) datasets with the following methods
 # added that make creating a paginated display easier:
@@ -25,6 +27,8 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:pagination)
+#
+# Related modules: Sequel::DatasetPagination, Sequel::Dataset::Pagination
 
 #
 module Sequel
@@ -35,9 +39,14 @@ module Sequel
     # number of records for this dataset.
     def paginate(page_no, page_size, record_count=nil)
       raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
-      paginated = limit(page_size, (page_no - 1) * page_size)
-      paginated.extend(Dataset::Pagination)
-      paginated.set_pagination_info(page_no, page_size, record_count || count)
+
+      record_count ||= count
+      page_count = (record_count / page_size.to_f).ceil
+      page_count = 1 if page_count == 0
+
+      limit(page_size, (page_no - 1) * page_size).
+        with_extend(Dataset::Pagination).
+        clone(:page_size=>page_size, :current_page=>page_no, :pagination_record_count=>record_count, :page_count=>page_count)
     end
       
     # Yields a paginated dataset for each page and returns the receiver. Does
@@ -55,51 +64,59 @@ module Sequel
 
   class Dataset
     # Holds methods that only relate to paginated datasets. Paginated dataset
-    # have pages starting at 1 (page 1 is offset 0, page 1 is offset page_size).
+    # have pages starting at 1 (page 1 is offset 0, page 2 is offset 1 * page_size).
     module Pagination
       # The number of records per page (the final page may have fewer than
       # this number of records).
-      attr_accessor :page_size
+      def page_size
+        @opts[:page_size]
+      end
 
       # The number of pages in the dataset before pagination, of which
       # this paginated dataset is one.  Empty datasets are considered
       # to have a single page.
-      attr_accessor :page_count
+      def page_count
+        @opts[:page_count]
+      end
 
       # The current page of the dataset, starting at 1 and not 0.
-      attr_accessor :current_page
+      def current_page
+        @opts[:current_page]
+      end
 
       # The total number of records in the dataset before pagination.
-      attr_accessor :pagination_record_count
+      def pagination_record_count
+        @opts[:pagination_record_count]
+      end
 
       # Returns the record range for the current page
       def current_page_record_range
-        return (0..0) if @current_page > @page_count
+        return (0..0) if current_page > page_count
         
-        a = 1 + (@current_page - 1) * @page_size
-        b = a + @page_size - 1
-        b = @pagination_record_count if b > @pagination_record_count
+        a = 1 + (current_page - 1) * page_size
+        b = a + page_size - 1
+        b = pagination_record_count if b > pagination_record_count
         a..b
       end
 
       # Returns the number of records in the current page
       def current_page_record_count
-        return 0 if @current_page > @page_count
+        return 0 if current_page > page_count
         
-        a = 1 + (@current_page - 1) * @page_size
-        b = a + @page_size - 1
-        b = @pagination_record_count if b > @pagination_record_count
+        a = 1 + (current_page - 1) * page_size
+        b = a + page_size - 1
+        b = pagination_record_count if b > pagination_record_count
         b - a + 1
       end
 
       # Returns true if the current page is the first page
       def first_page?
-        @current_page == 1
+        current_page == 1
       end
 
       # Returns true if the current page is the last page
       def last_page?
-        @current_page == @page_count
+        current_page == page_count
       end
 
       # Returns the next page number or nil if the current page is the last page
@@ -116,16 +133,6 @@ module Sequel
       def prev_page
         current_page > 1 ? (current_page - 1) : nil
       end
-
-      # Sets the pagination info for this paginated dataset, and returns self.
-      def set_pagination_info(page_no, page_size, record_count)
-        @current_page = page_no
-        @page_size = page_size
-        @pagination_record_count = record_count
-        @page_count = (record_count / page_size.to_f).ceil
-        @page_count = 1 if @page_count == 0
-        self
-      end
     end
   end
 

data/lib/sequel/extensions/pg_array.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_array extension adds support for Sequel to handle
 # PostgreSQL's array types.
 #
@@ -30,7 +32,7 @@
 #
 # So if you want to insert an array into an integer[] database column:
 #
-#   DB[:table].insert(:column=>Sequel.pg_array([1, 2, 3]))
+#   DB[:table].insert(column: Sequel.pg_array([1, 2, 3]))
 #
 # To use this extension, first load it into your Sequel::Database instance:
 #
@@ -39,20 +41,14 @@
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using postgres array columns in CREATE/ALTER TABLE statements.
 #
-# If you are not using the native postgres or jdbc/postgresql adapter and are using array
-# types as model column values you probably should use the the pg_typecast_on_load plugin
-# if the column values are returned as a string.
-#
 # 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 or the Database instance's
-# conversion_procs usingthe appropriate type OID.  For user defined
+# handled and has the appropriate converter installed. For user defined
 # types, you can do this via:
 #
-#   DB.conversion_procs[scalar_type_oid] = lambda{|string| }
+#   DB.add_conversion_proc(scalar_type_oid){|string| }
 #
 # Then you can call
 # Sequel::Postgres::PGArray::DatabaseMethods#register_array_type
@@ -62,27 +58,19 @@
 #
 #   DB.register_array_type('foo')
 #
-# You can also register array types on a global basis using
-# Sequel::Postgres::PGArray.register.  In this case, you'll have
-# to specify the type oids:
-#
-#   Sequel::Postgres::PG_TYPES[1234] = lambda{|string| }
-#   Sequel::Postgres::PGArray.register('foo', :oid=>4321, :scalar_oid=>1234)
-#
-# Both Sequel::Postgres::PGArray::DatabaseMethods#register_array_type
-# and Sequel::Postgres::PGArray.register support many options to
-# customize the array type handling.  See the Sequel::Postgres::PGArray.register
-# method documentation.
+# While this extension can parse PostgreSQL arrays with explicit bounds, it
+# currently ignores explicit bounds, so such values do not round
+# trip.
 #
 # If you want an easy way to call PostgreSQL array functions and
 # operators, look into the pg_array_ops extension.
 #
-# This extension requires the json, strscan, and delegate libraries.
+# This extension requires the delegate library, and the strscan library
+# sequel_pg has not been loaded.
+#
+# Related module: Sequel::Postgres::PGArray
 
 require 'delegate'
-require 'strscan'
-require 'json'
-Sequel.require 'adapters/utils/pg_types'
 
 module Sequel
   module Postgres
@@ -90,126 +78,64 @@ module Sequel
     class PGArray < DelegateClass(Array)
       include Sequel::SQL::AliasMethods
 
-      ARRAY = "ARRAY".freeze
-      DOUBLE_COLON = '::'.freeze
-      EMPTY_ARRAY = "'{}'".freeze
-      EMPTY_BRACKET = '[]'.freeze
-      OPEN_BRACKET = '['.freeze
-      CLOSE_BRACKET = ']'.freeze
-      COMMA = ','.freeze
-      BACKSLASH = '\\'.freeze
-      EMPTY_STRING = ''.freeze
-      OPEN_BRACE = '{'.freeze
-      CLOSE_BRACE = '}'.freeze
-      NULL = 'NULL'.freeze
-      QUOTE = '"'.freeze
-
-      # Global hash of database array type name strings to symbols (e.g. 'double precision' => :float),
-      # used by the schema parsing for array types registered globally.
-      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_procs :: A hash mapping oids to conversion procs, used for looking up the :scalar_oid and
-      #                value and setting the :oid value.  Defaults to the global Sequel::Postgres::PG_TYPES.
-      # :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_map :: The map in which to place the database type string to type symbol mapping.
-      #                         Defaults to ARRAY_TYPES.
-      # :typecast_methods_module :: If given, a module object to add the typecasting method to.  Defaults
-      #                             to DatabaseMethods.
-      #
-      # If a block is given, it is treated as the :converter option.
-      def self.register(db_type, opts=OPTS, &block)
-        db_type = db_type.to_s
-        type = (opts[:type_symbol] || db_type).to_sym
-        type_procs = opts[:type_procs] || PG_TYPES
-        mod = opts[:typecast_methods_module] || DatabaseMethods
-        typecast_method_map = opts[:typecast_method_map] || ARRAY_TYPES
-
-        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 
-          converter = type_procs[soid]
-        end
-
-        array_type = (opts[:array_type] || db_type).to_s.dup.freeze
-        creator = (opts[:parser] == :json ? JSONCreator : Creator).new(array_type, converter)
-
-        typecast_method_map[db_type] = :"#{type}_array"
-
-        define_array_typecast_method(mod, type, creator, opts.fetch(:scalar_typecast, type))
-
-        if oid = opts[:oid]
-          type_procs[oid] = creator
-        end
-
-        nil
-      end
-
-      # Define a private array typecasting method in the given module for the given type that uses
-      # the creator argument to do the type conversion.
-      def self.define_array_typecast_method(mod, type, creator, scalar_typecast)
-        mod.class_eval do
-          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
-      end
-      private_class_method :define_array_typecast_method
-
       module DatabaseMethods
-        APOS = "'".freeze
-        DOUBLE_APOS = "''".freeze
-        ESCAPE_RE = /("|\\)/.freeze
-        ESCAPE_REPLACEMENT = '\\\\\1'.freeze
         BLOB_RANGE = 1...-1
 
         # Create the local hash of database type strings to schema type symbols,
         # used for array types local to this database.
         def self.extended(db)
-          db.instance_eval do
+          db.instance_exec do
             @pg_array_schema_types ||= {}
-            procs = conversion_procs
-            procs[1115] = Creator.new("timestamp without time zone", procs[1114])
-            procs[1185] = Creator.new("timestamp with time zone", procs[1184])
-            copy_conversion_procs([143, 791, 1000, 1001, 1003, 1005, 1006, 1007, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1021, 1022, 1028, 1182, 1183, 1231, 1270, 1561, 1563, 2951])
+            register_array_type('timestamp without time zone', :oid=>1115, :scalar_oid=>1114, :type_symbol=>:datetime)
+            register_array_type('timestamp with time zone', :oid=>1185, :scalar_oid=>1184, :type_symbol=>:datetime_timezone, :scalar_typecast=>:datetime)
+
+            register_array_type('text', :oid=>1009, :scalar_oid=>25, :type_symbol=>:string)
+            register_array_type('integer', :oid=>1007, :scalar_oid=>23)
+            register_array_type('bigint', :oid=>1016, :scalar_oid=>20, :scalar_typecast=>:integer)
+            register_array_type('numeric', :oid=>1231, :scalar_oid=>1700, :type_symbol=>:decimal)
+            register_array_type('double precision', :oid=>1022, :scalar_oid=>701, :type_symbol=>:float)
+
+            register_array_type('boolean', :oid=>1000, :scalar_oid=>16)
+            register_array_type('bytea', :oid=>1001, :scalar_oid=>17, :type_symbol=>:blob)
+            register_array_type('date', :oid=>1182, :scalar_oid=>1082)
+            register_array_type('time without time zone', :oid=>1183, :scalar_oid=>1083, :type_symbol=>:time)
+            register_array_type('time with time zone', :oid=>1270, :scalar_oid=>1266, :type_symbol=>:time_timezone, :scalar_typecast=>:time)
+
+            register_array_type('smallint', :oid=>1005, :scalar_oid=>21, :scalar_typecast=>:integer)
+            register_array_type('oid', :oid=>1028, :scalar_oid=>26, :scalar_typecast=>:integer)
+            register_array_type('real', :oid=>1021, :scalar_oid=>700, :scalar_typecast=>:float)
+            register_array_type('character', :oid=>1014, :converter=>nil, :array_type=>:text, :scalar_typecast=>:string)
+            register_array_type('character varying', :oid=>1015, :converter=>nil, :scalar_typecast=>:string, :type_symbol=>:varchar)
+
+            register_array_type('xml', :oid=>143, :scalar_oid=>142)
+            register_array_type('money', :oid=>791, :scalar_oid=>790)
+            register_array_type('bit', :oid=>1561, :scalar_oid=>1560)
+            register_array_type('bit varying', :oid=>1563, :scalar_oid=>1562, :type_symbol=>:varbit)
+            register_array_type('uuid', :oid=>2951, :scalar_oid=>2950)
+
+            register_array_type('xid', :oid=>1011, :scalar_oid=>28)
+            register_array_type('cid', :oid=>1012, :scalar_oid=>29)
+
+            register_array_type('name', :oid=>1003, :scalar_oid=>19)
+            register_array_type('tid', :oid=>1010, :scalar_oid=>27)
+            register_array_type('int2vector', :oid=>1006, :scalar_oid=>22)
+            register_array_type('oidvector', :oid=>1013, :scalar_oid=>30)
+
             [:string_array, :integer_array, :decimal_array, :float_array, :boolean_array, :blob_array, :date_array, :time_array, :datetime_array].each do |v|
               @schema_type_classes[v] = PGArray
             end
           end
         end
 
+        def add_named_conversion_proc(name, &block)
+          ret = super
+          name = name.to_s if name.is_a?(Symbol)
+          from(:pg_type).where(:typname=>name).select_map([:oid, :typarray]).each do |scalar_oid, array_oid|
+            register_array_type(name, :oid=>array_oid.to_i, :scalar_oid=>scalar_oid.to_i)
+          end
+          ret
+        end
+
         # Handle arrays in bound variables
         def bound_variable_arg(arg, conn)
           case arg
@@ -222,25 +148,75 @@ module Sequel
           end
         end
 
-        # Register a database specific array type.  This can be used to support
-        # different array types per Database.  Use of this method does not
-        # affect global state, unlike PGArray.register.  See PGArray.register for
-        # possible options.
+        # Freeze the pg array schema types to prevent adding new ones.
+        def freeze
+          @pg_array_schema_types.freeze
+          super
+        end
+
+        # Register a database specific array type.  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.
+        # :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.
+        #
+        # If a block is given, it is treated as the :converter option.
         def register_array_type(db_type, opts=OPTS, &block)
-          opts = {:type_procs=>conversion_procs, :typecast_method_map=>@pg_array_schema_types, :typecast_methods_module=>(class << self; self; end)}.merge!(opts)
-          unless (opts.has_key?(:scalar_oid) || block) && opts.has_key?(:oid)
+          oid = opts[:oid]
+          soid = opts[:scalar_oid]
+
+          if has_converter = opts.has_key?(:converter)
+            raise Error, "can't provide both a block and :converter option to register_array_type" if block
+            converter = opts[:converter]
+          else
+            has_converter = true if block
+            converter = block
+          end
+
+          unless (soid || has_converter) && oid
             array_oid, scalar_oid = from(:pg_type).where(:typname=>db_type.to_s).get([:typarray, :oid])
-            opts[:scalar_oid] = scalar_oid unless opts.has_key?(:scalar_oid) || block
-            opts[:oid] = array_oid unless opts.has_key?(:oid)
+            soid ||= scalar_oid unless has_converter
+            oid ||= array_oid
           end
-          PGArray.register(db_type, opts, &block)
-          @schema_type_classes[:"#{opts[:type_symbol] || db_type}_array"] = PGArray
-          conversion_procs_updated
-        end
 
-        # Return PGArray if this type matches any supported array type.
-        def schema_type_class(type)
-          super || (ARRAY_TYPES.each_value{|v| return PGArray if type == v}; nil)
+          db_type = db_type.to_s
+          type = (opts[:type_symbol] || db_type).to_sym
+          typecast_method_map = @pg_array_schema_types
+
+          if soid
+            raise Error, "can't provide both a converter and :scalar_oid option to register" if has_converter 
+            converter = conversion_procs[soid]
+          end
+
+          array_type = (opts[:array_type] || db_type).to_s.dup.freeze
+          creator = Creator.new(array_type, converter)
+          add_conversion_proc(oid, creator)
+
+          typecast_method_map[db_type] = :"#{type}_array"
+
+          singleton_class.class_eval do
+            meth = :"typecast_value_#{type}_array"
+            scalar_typecast_method = :"typecast_value_#{opts.fetch(:scalar_typecast, type)}"
+            define_method(meth){|v| typecast_value_pg_array(v, creator, scalar_typecast_method)}
+            private meth
+          end
+
+          @schema_type_classes[:"#{type}_array"] = PGArray
+          nil
         end
 
         private
@@ -249,46 +225,23 @@ module Sequel
         def bound_variable_array(a)
           case a
           when Array
-            "{#{a.map{|i| bound_variable_array(i)}.join(COMMA)}}"
+            "{#{a.map{|i| bound_variable_array(i)}.join(',')}}"
           when Sequel::SQL::Blob
-            "\"#{literal(a)[BLOB_RANGE].gsub(DOUBLE_APOS, APOS).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)}\""
+            "\"#{literal(a)[BLOB_RANGE].gsub("''", "'").gsub(/("|\\)/, '\\\\\1')}\""
           when Sequel::LiteralString
             a
           when String
-            "\"#{a.gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)}\""
+            "\"#{a.gsub(/("|\\)/, '\\\\\1')}\""
           else
             literal(a)
           end
         end
 
-        # Automatically handle array types for the given named types. 
-        def convert_named_procs_to_procs(named_procs)
-          h = super
-          unless h.empty?
-            from(:pg_type).where(:oid=>h.keys).select_map([:typname, :oid, :typarray]).each do |name, scalar_oid, array_oid|
-              register_array_type(name, :type_procs=>h, :oid=>array_oid.to_i, :scalar_oid=>scalar_oid.to_i)
-            end
-          end
-          h
-        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
-          procs = super
-
-          procs[1115] = Creator.new("timestamp without time zone", procs[1114])
-          procs[1185] = Creator.new("timestamp with time zone", procs[1184])
-
-          procs
-        end
-
         # Look into both the current database's array schema types and the global
         # array schema types to get the type symbol for the given database type
         # string.
         def pg_array_schema_type(type)
-          @pg_array_schema_types[type] || ARRAY_TYPES[type]
+          @pg_array_schema_types[type]
         end
 
         # Make the column type detection handle registered array types.
@@ -300,6 +253,17 @@ module Sequel
           end
         end
 
+        # Set the :callable_default value if the default value is recognized as an empty array.
+        def schema_post_process(_)
+          super.each do |a|
+            h = a[1]
+            if h[:default] =~ /\A(?:'\{\}'|ARRAY\[\])::([\w ]+)\[\]\z/
+              type = $1.freeze
+              h[:callable_default] = lambda{Sequel.pg_array([], type)}
+            end
+          end
+        end
+
         # Convert ruby arrays to PostgreSQL arrays when used as default values.
         def column_definition_default_sql(sql, column)
           if (d = column[:default]) && d.is_a?(Array) && !Sequel.condition_specifier?(d)
@@ -336,97 +300,101 @@ module Sequel
         end
       end
 
-      # PostgreSQL array parser that handles PostgreSQL array output format.
-      # Note that does not handle all forms out input that PostgreSQL will
-      # accept, and it will not raise an error for all forms of invalid input.
-      class Parser < StringScanner
-        UNQUOTED_RE = /[{}",]|[^{}",]+/
-        QUOTED_RE = /["\\]|[^"\\]+/
-        NULL_RE = /NULL",/
-        OPEN_RE = /\{/
-
-        # Set the source for the input, and any converter callable
-        # to call with objects to be created.  For nested parsers
-        # the source may contain text after the end current parse,
-        # which will be ignored.
-        def initialize(source, converter=nil)
-          super(source)
-          @converter = converter 
-          @stack = [[]]
-          @recorded = ""
-        end
+      unless Sequel::Postgres.respond_to?(:parse_pg_array)
+        require 'strscan'
+
+        # PostgreSQL array parser that handles PostgreSQL array output format.
+        # Note that does not handle all forms out input that PostgreSQL will
+        # accept, and it will not raise an error for all forms of invalid input.
+        class Parser < StringScanner
+          # Set the source for the input, and any converter callable
+          # to call with objects to be created.  For nested parsers
+          # the source may contain text after the end current parse,
+          # which will be ignored.
+          def initialize(source, converter=nil)
+            super(source)
+            @converter = converter 
+            @stack = [[]]
+            @encoding = string.encoding
+            @recorded = String.new.force_encoding(@encoding)
+          end
 
-        # Take the buffer of recorded characters and add it to the array
-        # of entries, and use a new buffer for recorded characters.
-        def new_entry(include_empty=false)
-          if !@recorded.empty? || include_empty
-            entry = @recorded
-            if entry == NULL && !include_empty
-              entry = nil
-            elsif @converter
-              entry = @converter.call(entry)
+          # Take the buffer of recorded characters and add it to the array
+          # of entries, and use a new buffer for recorded characters.
+          def new_entry(include_empty=false)
+            if !@recorded.empty? || include_empty
+              entry = @recorded
+              if entry == 'NULL' && !include_empty
+                entry = nil
+              elsif @converter
+                entry = @converter.call(entry)
+              end
+              @stack.last.push(entry)
+              @recorded = String.new.force_encoding(@encoding)
             end
-            @stack.last.push(entry)
-            @recorded = ""
           end
-        end
 
-        # Parse the input character by character, returning an array
-        # of parsed (and potentially converted) objects.
-        def parse
-          raise Sequel::Error, "invalid array, empty string" if eos?
-          raise Sequel::Error, "invalid array, doesn't start with {" unless scan(OPEN_RE)
-
-          while !eos?
-            char = scan(UNQUOTED_RE)
-            if char == COMMA
-              # Comma outside quoted string indicates end of current entry
-              new_entry
-            elsif char == QUOTE
-              raise Sequel::Error, "invalid array, opening quote with existing recorded data" unless @recorded.empty?
-              while true
-                char = scan(QUOTED_RE)
-                if char == BACKSLASH
-                  @recorded << getch
-                elsif char == QUOTE
-                  n = peek(1)
-                  raise Sequel::Error, "invalid array, closing quote not followed by comma or closing brace" unless n == COMMA || n == CLOSE_BRACE
-                  break
+          # Parse the input character by character, returning an array
+          # of parsed (and potentially converted) objects.
+          def parse
+            raise Sequel::Error, "invalid array, empty string" if eos?
+            raise Sequel::Error, "invalid array, doesn't start with {" unless scan(/((\[\d+:\d+\])+=)?\{/)
+
+            # :nocov:
+            while !eos?
+            # :nocov:
+              char = scan(/[{}",]|[^{}",]+/)
+              if char == ','
+                # Comma outside quoted string indicates end of current entry
+                new_entry
+              elsif char == '"'
+                raise Sequel::Error, "invalid array, opening quote with existing recorded data" unless @recorded.empty?
+                # :nocov:
+                while true
+                # :nocov:
+                  char = scan(/["\\]|[^"\\]+/)
+                  if char == '\\'
+                    @recorded << getch
+                  elsif char == '"'
+                    n = peek(1)
+                    raise Sequel::Error, "invalid array, closing quote not followed by comma or closing brace" unless n == ',' || n == '}'
+                    break
+                  else
+                    @recorded << char
+                  end
+                end
+                new_entry(true)
+              elsif char == '{'
+                raise Sequel::Error, "invalid array, opening brace with existing recorded data" unless @recorded.empty?
+
+                # Start of new array, add it to the stack
+                new = []
+                @stack.last << new
+                @stack << new
+              elsif char == '}'
+                # End of current array, add current entry to the current array
+                new_entry
+
+                if @stack.length == 1
+                  raise Sequel::Error, "array parsing finished without parsing entire string" unless eos?
+
+                  # Top level of array, parsing should be over.
+                  # Pop current array off stack and return it as result
+                  return @stack.pop
                 else
-                  @recorded << char
+                  # Nested array, pop current array off stack
+                  @stack.pop
                 end
-              end
-              new_entry(true)
-            elsif char == OPEN_BRACE
-              raise Sequel::Error, "invalid array, opening brace with existing recorded data" unless @recorded.empty?
-
-              # Start of new array, add it to the stack
-              new = []
-              @stack.last << new
-              @stack << new
-            elsif char == CLOSE_BRACE
-              # End of current array, add current entry to the current array
-              new_entry
-
-              if @stack.length == 1
-                raise Sequel::Error, "array parsing finished without parsing entire string" unless eos?
-
-                # Top level of array, parsing should be over.
-                # Pop current array off stack and return it as result
-                return @stack.pop
               else
-                # Nested array, pop current array off stack
-                @stack.pop
+                # Add the character to the recorded character buffer.
+                @recorded << char
               end
-            else
-              # Add the character to the recorded character buffer.
-              @recorded << char
             end
-          end
 
-          raise Sequel::Error, "array parsing finished with array unclosed"
+            raise Sequel::Error, "array parsing finished with array unclosed"
+          end
         end
-      end unless Sequel::Postgres.respond_to?(:parse_pg_array)
+      end
 
       # Callable object that takes the input string and parses it using Parser.
       class Creator
@@ -460,27 +428,6 @@ module Sequel
         end
       end
 
-      # 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 = Sequel.parse_json(string.gsub(SUBST_RE){|m| SUBST[m]})
-          array = Sequel.recursive_map(array, @converter) if @converter
-          PGArray.new(array, @type)
-        end
-      end
-
       # 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
       # literalizing.  This type is the underlying type, not the array type
@@ -499,13 +446,13 @@ module Sequel
       def sql_literal_append(ds, sql)
         at = array_type
         if empty? && at
-          sql << EMPTY_ARRAY
+          sql << "'{}'"
         else
-          sql << ARRAY
+          sql << "ARRAY"
           _literal_append(sql, ds, to_a)
         end
         if at
-          sql << DOUBLE_COLON << at.to_s << EMPTY_BRACKET
+          sql << '::' << at.to_s << '[]'
         end
       end
 
@@ -515,9 +462,9 @@ module Sequel
       # arrays, surrounding each with [] and interspersing
       # entries with ,.
       def _literal_append(sql, ds, array)
-        sql << OPEN_BRACKET
+        sql << '['
         comma = false
-        commas = COMMA
+        commas = ','
         array.each do |i|
           sql << commas if comma
           if i.is_a?(Array)
@@ -527,44 +474,8 @@ module Sequel
           end
           comma = true
         end
-        sql << CLOSE_BRACKET
+        sql << ']'
       end
-
-      # 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, :scalar_typecast=>:integer)
-      register('oid', :oid=>1028, :parser=>:json, :scalar_typecast=>:integer)
-      register('real', :oid=>1021, :scalar_oid=>700, :scalar_typecast=>:float)
-      register('character', :oid=>1014, :array_type=>:text, :scalar_typecast=>:string)
-      register('character varying', :oid=>1015, :scalar_typecast=>:string, :type_symbol=>:varchar)
-
-      register('xml', :oid=>143, :scalar_oid=>142)
-      register('money', :oid=>791, :scalar_oid=>790)
-      register('bit', :oid=>1561, :scalar_oid=>1560)
-      register('bit varying', :oid=>1563, :scalar_oid=>1562, :type_symbol=>:varbit)
-      register('uuid', :oid=>2951, :scalar_oid=>2950)
-
-      register('xid', :oid=>1011, :scalar_oid=>28)
-      register('cid', :oid=>1012, :scalar_oid=>29)
-
-      register('name', :oid=>1003, :scalar_oid=>19)
-      register('tid', :oid=>1010, :scalar_oid=>27)
-      register('int2vector', :oid=>1006, :scalar_oid=>22)
-      register('oidvector', :oid=>1013, :scalar_oid=>30)
     end
   end