asana2flowdock 1.0.0

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/mssql_emulate_lateral_with_apply.rb

@@ -0,0 +1,80 @@
+# 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
+# LATERAL via Dataset#lateral to run on Microsoft SQL Server
+# and Sybase SQLAnywhere.
+#
+# This is available as a separate extension instead of
+# integrated into the Microsoft SQL Server and Sybase
+# SQLAnywhere support because few people need it and there
+# is a performance hit to code that doesn't use it.
+#
+# It is possible there are cases where this emulation does
+# not work.  Users should probably verify that correct
+# results are returned when using this extension.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:mssql_emulate_lateral_with_apply)
+#
+# Or you can load it into all of a database's datasets:
+#
+#   DB.extension(:mssql_emulate_lateral_with_apply)
+
+#
+module Sequel
+  module MSSQL
+    module EmulateLateralWithApply
+      # If the table is a dataset that uses LATERAL,
+      # convert it to a CROSS APPLY if it is a INNER
+      # or CROSS JOIN, and an OUTER APPLY if it is a
+      # LEFT JOIN.
+      def join_table(type, table, expr=nil, *)
+        if table.is_a?(Dataset) && table.opts[:lateral]
+          table = table.clone(:lateral=>nil)
+          case type
+          when :inner
+            type = :cross_apply
+            table = table.where(expr)
+            expr = nil
+          when :cross
+            type = :cross_apply
+          when :left, :left_outer
+            type = :outer_apply
+            table = table.where(expr)
+            expr = nil
+          end
+        end
+        super
+      end
+
+      # When a FROM entry uses a LATERAL subquery,
+      # convert that entry into a CROSS APPLY.
+      def from(*source, &block)
+        virtual_row_columns(source, block)
+        lateral, source = source.partition{|t| t.is_a?(Sequel::Dataset) && t.opts[:lateral] || (t.is_a?(Sequel::SQL::AliasedExpression) && t.expression.is_a?(Sequel::Dataset) && t.expression.opts[:lateral])} unless source.empty?
+        return super(*source, &nil) if !lateral || lateral.empty?
+
+        ds = from(*source)
+        lateral.each do |l|
+          l = if l.is_a?(Sequel::SQL::AliasedExpression)
+            l.expression.clone(:lateral=>nil).as(l.alias)
+          else
+            l.clone(:lateral=>nil)
+          end
+          ds = ds.cross_apply(l)
+        end
+        ds
+      end
+      
+      # MSSQL can emulate lateral subqueries via CROSS/OUTER APPLY
+      # when using this extension.
+      def supports_lateral_subqueries?
+        true
+      end
+    end
+  end
+
+  Dataset.register_extension(:mssql_emulate_lateral_with_apply, MSSQL::EmulateLateralWithApply)
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/named_timezones.rb

@@ -0,0 +1,99 @@
+# 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.
+#
+# 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
+# services clients in Los Angeles, so you want to use New York
+# time in the database and Los Angeles time in the application.  This
+# is easily done via:
+#
+#   Sequel.database_timezone = 'America/New_York'
+#   Sequel.application_timezone = 'America/Los_Angeles'
+#
+# Then, before data is stored in the database, it is converted to New
+# York time.  When data is retrieved from the database, it is
+# converted to Los Angeles time.
+#
+# If you are using database specific timezones, you may want to load
+# this extension into the database in order to support similar API:
+#
+#   DB.extension :named_timezones
+#   DB.timezone = 'America/New_York'
+#
+# 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.
+
+require 'tzinfo'
+
+#
+module Sequel
+  self.datetime_class = DateTime
+  
+  module NamedTimezones
+    module DatabaseMethods
+      def timezone=(tz)
+        super(Sequel.send(:convert_timezone_setter_arg, tz))
+      end
+    end
+
+    # Handles TZInfo::AmbiguousTime exceptions automatically by providing a
+    # proc called with both the datetime value being converted as well as
+    # the array of TZInfo::TimezonePeriod results. Example:
+    #
+    #   Sequel.tzinfo_disambiguator = proc{|datetime, periods| periods.first}
+    attr_accessor :tzinfo_disambiguator
+
+    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)
+    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)
+    end
+    
+    # Returns TZInfo::Timezone instance if given a String.
+    def convert_timezone_setter_arg(tz)
+      tz.is_a?(String) ? TZInfo::Timezone.get(tz) : super
+    end
+
+    # Return a disambiguation proc that provides both the datetime value
+    # and the periods, in order to allow the choice of period to depend
+    # on the datetime value.
+    def tzinfo_disambiguator_for(v)
+      if pr = @tzinfo_disambiguator
+        proc{|periods| pr.call(v, periods)}
+      end
+    end
+  end
+  
+  extend NamedTimezones
+  Database.register_extension(:named_timezones, NamedTimezones::DatabaseMethods)
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/null_dataset.rb

@@ -0,0 +1,105 @@
+# 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.
+#
+# 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
+# WHERE condition that is always false, but that still results
+# in a query being sent to the database, and can be overridden
+# using #unfiltered, the OR operator, or a UNION.
+#
+# Usage:
+#
+#   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
+#
+# Note that there is one case where a null dataset will sent
+# a query to the database.  If you call #columns on a nulled
+# dataset and the dataset doesn't have an already cached
+# version of the columns, it will create a new dataset with
+# the same options to get the columns.
+#
+# This extension uses Object#extend at runtime, which can hurt performance.
+#
+# To add the nullify method to a single dataset:
+#
+#   ds = ds.extension(:null_dataset)
+#
+# To add the nullify method to all datasets on a single database:
+#
+#   DB.extension(:null_dataset)
+
+#
+module Sequel
+  class Dataset
+    module Nullifiable
+      # Return a cloned nullified dataset.
+      def nullify
+        clone.nullify!
+      end
+
+      # Nullify the current dataset
+      def nullify!
+        extend NullDataset
+      end
+    end
+
+    module NullDataset
+      # 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
+      end
+
+      # Return 0 without sending a database query.
+      def delete
+        0
+      end
+
+      # Return self without sending a database query, never yielding.
+      def each
+        self
+      end
+
+      # Return nil without sending a database query, never yielding.
+      def fetch_rows(sql)
+        nil
+      end
+
+      # Return nil without sending a database query.
+      def insert(*)
+        nil
+      end
+
+      # Return nil without sending a database query.
+      def truncate
+        nil
+      end
+
+      # Return 0 without sending a database query.
+      def update(v=OPTS)
+        0
+      end
+
+      protected
+
+      # Return nil without sending a database query.
+      def _import(columns, values, opts)
+        nil
+      end
+
+      private
+
+      # Just in case these are called directly by some internal code,
+      # make them noops.  There's nothing we can do if the db
+      # is accessed directly to make a change, though.
+      (%w'_ddl _dui _insert' << '').each do |m|
+        class_eval("private; def execute#{m}(sql, opts=OPTS) end", __FILE__, __LINE__)
+      end
+    end
+  end
+
+  Dataset.register_extension(:null_dataset, Dataset::Nullifiable)
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/pagination.rb

@@ -0,0 +1,121 @@
+# 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.
+#
+# This extension uses Object#extend at runtime, which can hurt performance.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:pagination)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:pagination)
+
+#
+module Sequel
+  module DatasetPagination
+    # Returns a paginated dataset. The returned dataset is limited to
+    # the page size at the correct offset, and extended with the Pagination
+    # module.  If a record count is not provided, does a count of total
+    # 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)
+    end
+      
+    # Yields a paginated dataset for each page and returns the receiver. Does
+    # a count to find the total number of records for this dataset. Returns
+    # an enumerator if no block is given.
+    def each_page(page_size)
+      raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
+      return to_enum(:each_page, page_size) unless block_given?
+      record_count = count
+      total_pages = (record_count / page_size.to_f).ceil
+      (1..total_pages).each{|page_no| yield paginate(page_no, page_size, record_count)}
+      self
+    end
+  end
+
+  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).
+    module Pagination
+      # The number of records per page (the final page may have fewer than
+      # this number of records).
+      attr_accessor :page_size
+
+      # 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
+
+      # The current page of the dataset, starting at 1 and not 0.
+      attr_accessor :current_page
+
+      # The total number of records in the dataset before pagination.
+      attr_accessor :pagination_record_count
+
+      # Returns the record range for the current page
+      def current_page_record_range
+        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..b
+      end
+
+      # Returns the number of records in the current page
+      def current_page_record_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
+        b - a + 1
+      end
+
+      # Returns true if the current page is the first page
+      def first_page?
+        @current_page == 1
+      end
+
+      # Returns true if the current page is the last page
+      def last_page?
+        @current_page == @page_count
+      end
+
+      # Returns the next page number or nil if the current page is the last page
+      def next_page
+        current_page < page_count ? (current_page + 1) : nil
+      end
+      
+      # Returns the page range
+      def page_range
+        1..page_count
+      end
+      
+      # Returns the previous page number or nil if the current page is the first
+      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
+
+  Dataset.register_extension(:pagination, DatasetPagination)
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/pg_array.rb

@@ -0,0 +1,606 @@
+# The pg_array extension adds support for Sequel to handle
+# PostgreSQL's array types.
+#
+# This extension integrates with Sequel's native postgres adapter and
+# the jdbc/postgresql adapter, so that when array fields are retrieved,
+# they are parsed and returned 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
+# treat a PGArray like an Array by default, which would cause issues.
+#
+# In addition to the parsers, this extension comes with literalizers
+# for PGArray using the standard Sequel literalization callbacks, so
+# they work with on all adapters.
+#
+# To turn an existing Array into a PGArray:
+#
+#   Sequel.pg_array(array)
+#
+# If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
+# or you have loaded the core_refinements extension
+# and have activated refinements for the file, you can also use Array#pg_array:
+#
+#   array.pg_array
+#
+# You can also provide a type, though in many cases it isn't necessary:
+#
+#   Sequel.pg_array(array, :varchar) # or :integer, :"double precision", etc.
+#   array.pg_array(:varchar) # or :integer, :"double precision", etc.
+#
+# So if you want to insert an array into an integer[] database column:
+#
+#   DB[:table].insert(:column=>Sequel.pg_array([1, 2, 3]))
+#
+# To use this extension, first load it into your Sequel::Database instance:
+#
+#   DB.extension :pg_array
+#
+# 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
+# types, you can do this via:
+#
+#   DB.conversion_procs[scalar_type_oid] = lambda{|string| }
+#
+# Then you can call
+# Sequel::Postgres::PGArray::DatabaseMethods#register_array_type
+# to automatically set up a handler for the array type.  So if you
+# want to support the foo[] type (assuming the foo type is already
+# supported):
+#
+#   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.
+#
+# 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.
+
+require 'delegate'
+require 'strscan'
+require 'json'
+Sequel.require 'adapters/utils/pg_types'
+
+module Sequel
+  module Postgres
+    # Represents a PostgreSQL array column value.
+    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
+            @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])
+            [: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
+
+        # Handle arrays in bound variables
+        def bound_variable_arg(arg, conn)
+          case arg
+          when PGArray
+            bound_variable_array(arg.to_a)
+          when Array
+            bound_variable_array(arg)
+          else
+            super
+          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.
+        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)
+            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)
+          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)
+        end
+
+        private
+
+        # Format arrays used in bound variables.
+        def bound_variable_array(a)
+          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
+            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]
+        end
+
+        # Make the column type detection handle registered array types.
+        def schema_column_type(db_type)
+          if (db_type =~ /\A([^(]+)(?:\([^(]+\))?\[\]\z/io) && (type = pg_array_schema_type($1))
+            type
+          else
+            super
+          end
+        end
+
+        # Given a value to typecast and the type of PGArray 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.
+        def typecast_value_pg_array(value, creator, scalar_typecast_method=nil)
+          case value
+          when PGArray
+            if value.array_type != creator.type
+              PGArray.new(value.to_a, creator.type)
+            else
+              value
+            end
+          when Array
+            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)
+          else
+            raise Sequel::InvalidValue, "invalid value for array type: #{value.inspect}"
+          end
+        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
+
+        # 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 = ""
+          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
+                else
+                  @recorded << char
+                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
+              end
+            else
+              # Add the character to the recorded character buffer.
+              @recorded << char
+            end
+          end
+
+          raise Sequel::Error, "array parsing finished with array unclosed"
+        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
+
+        # 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)
+        # :nocov:
+          # 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
+        # :nocov:
+        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
+
+      # 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
+      # itself, so for an int4[] database type, it should be :int4 or 'int4'
+      attr_accessor :array_type
+
+      # Set the array to delegate to, and a database type.
+      def initialize(array, type=nil)
+        super(array)
+        @array_type = type
+      end
+
+      # Append the array SQL to the given sql string. 
+      # If the receiver has a type, add a cast to the
+      # database array type.
+      def sql_literal_append(ds, sql)
+        at = array_type
+        if empty? && at
+          sql << EMPTY_ARRAY
+        else
+          sql << ARRAY
+          _literal_append(sql, ds, to_a)
+        end
+        if at
+          sql << DOUBLE_COLON << at.to_s << EMPTY_BRACKET
+        end
+      end
+
+      private
+
+      # Recursive method that handles multi-dimensional
+      # arrays, surrounding each with [] and interspersing
+      # entries with ,.
+      def _literal_append(sql, ds, array)
+        sql << OPEN_BRACKET
+        comma = false
+        commas = COMMA
+        array.each do |i|
+          sql << commas if comma
+          if i.is_a?(Array)
+            _literal_append(sql, ds, i)
+          else
+            ds.literal_append(sql, i)
+          end
+          comma = true
+        end
+        sql << CLOSE_BRACKET
+      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
+
+  module SQL::Builders
+    # Return a Postgres::PGArray proxy for the given array and database array type.
+    def pg_array(v, array_type=nil)
+      case v
+      when Postgres::PGArray
+        if array_type.nil? || v.array_type == array_type
+          v
+        else
+          Postgres::PGArray.new(v.to_a, array_type)
+        end
+      when Array
+        Postgres::PGArray.new(v, array_type)
+      else
+        # May not be defined unless the pg_array_ops extension is used
+        pg_array_op(v)
+      end
+    end
+  end
+
+  Database.register_extension(:pg_array, Postgres::PGArray::DatabaseMethods)
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Array
+    # Return a PGArray proxy to the receiver, using a
+    # specific database type if given.  This is mostly useful
+    # as a short cut for creating PGArray objects that didn't
+    # come from the database.
+    def pg_array(type=nil)
+      Sequel::Postgres::PGArray.new(self, type)
+    end
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Array do
+      def pg_array(type=nil)
+        Sequel::Postgres::PGArray.new(self, type)
+      end
+    end
+  end
+end
+# :nocov: