asana2flowdock 1.0.0 → 1.1.0

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/adapters/shared/db2.rb

@@ -1,403 +0,0 @@
-Sequel.require 'adapters/utils/emulate_offset_with_row_number'
-
-module Sequel
-  module DB2
-    @use_clob_as_blob = false
-
-    class << self
-      # Whether to use clob as the generic File type, true by default.
-      attr_accessor :use_clob_as_blob
-    end
-
-    module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
-      AUTOINCREMENT = 'GENERATED ALWAYS AS IDENTITY'.freeze
-      NOT_NULL      = ' NOT NULL'.freeze
-      NULL          = ''.freeze
-
-      # DB2 always uses :db2 as it's database type
-      def database_type
-        :db2
-      end
-      
-      # Return the database version as a string.  Don't rely on this,
-      # it may return an integer in the future.
-      def db2_version
-        return @db2_version if @db2_version
-        @db2_version = metadata_dataset.with_sql("select service_level from sysibmadm.env_inst_info").first[:service_level]
-      end
-      alias_method :server_version, :db2_version
-
-      # Use SYSIBM.SYSCOLUMNS to get the information on the tables.
-      def schema_parse_table(table, opts = OPTS)
-        m = output_identifier_meth(opts[:dataset])
-        im = input_identifier_meth(opts[:dataset])
-        metadata_dataset.with_sql("SELECT * FROM SYSIBM.SYSCOLUMNS WHERE TBNAME = #{literal(im.call(table))} ORDER BY COLNO").
-          collect do |column| 
-            column[:db_type]     = column.delete(:typename)
-            if column[:db_type]  == "DECIMAL"
-              column[:db_type] << "(#{column[:longlength]},#{column[:scale]})"
-            end
-            column[:allow_null]  = column.delete(:nulls) == 'Y'
-            column[:primary_key] = column.delete(:identity) == 'Y' || !column[:keyseq].nil?
-            column[:type]        = schema_column_type(column[:db_type])
-            column[:max_length]  = column[:longlength] if column[:type] == :string
-            [ m.call(column.delete(:name)), column]
-          end
-      end
-
-      # Use SYSCAT.TABLES to get the tables for the database
-      def tables
-        metadata_dataset.
-          with_sql("SELECT TABNAME FROM SYSCAT.TABLES WHERE TYPE='T' AND OWNER = #{literal(input_identifier_meth.call(opts[:user]))}").
-          all.map{|h| output_identifier_meth.call(h[:tabname]) }
-      end
-
-      # Use SYSCAT.TABLES to get the views for the database
-      def views
-        metadata_dataset.
-          with_sql("SELECT TABNAME FROM SYSCAT.TABLES WHERE TYPE='V' AND OWNER = #{literal(input_identifier_meth.call(opts[:user]))}").
-          all.map{|h| output_identifier_meth.call(h[:tabname]) }
-      end
-
-      # Use SYSCAT.INDEXES to get the indexes for the table
-      def indexes(table, opts = OPTS)
-        m = output_identifier_meth
-        indexes = {}
-        metadata_dataset.
-         from(:syscat__indexes).
-         select(:indname, :uniquerule, :colnames).
-         where(:tabname=>input_identifier_meth.call(table), :system_required=>0).
-         each do |r|
-          indexes[m.call(r[:indname])] = {:unique=>(r[:uniquerule]=='U'), :columns=>r[:colnames][1..-1].split('+').map{|v| m.call(v)}}
-        end
-        indexes
-      end
-
-      # DB2 supports transaction isolation levels.
-      def supports_transaction_isolation_levels?
-        true
-      end
-
-      private
-
-      # Handle DB2 specific alter table operations.
-      def alter_table_sql(table, op)
-        case op[:op]
-        when :add_column
-          if op[:primary_key] && op[:auto_increment] && op[:type] == Integer
-            [
-            "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op.merge(:auto_increment=>false, :primary_key=>false, :default=>0, :null=>false))}",
-            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{literal(op[:name])} DROP DEFAULT",
-            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{literal(op[:name])} SET #{AUTOINCREMENT}"
-            ]
-          else
-            "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
-          end
-        when :drop_column
-          "ALTER TABLE #{quote_schema_table(table)} DROP #{column_definition_sql(op)}"
-        when :rename_column       # renaming is only possible after db2 v9.7
-          "ALTER TABLE #{quote_schema_table(table)} RENAME COLUMN #{quote_identifier(op[:name])} TO #{quote_identifier(op[:new_name])}"
-        when :set_column_type
-          "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} SET DATA TYPE #{type_literal(op)}"
-        when :set_column_default
-          "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} SET DEFAULT #{literal(op[:default])}"
-        when :add_constraint
-          if op[:type] == :unique
-            sqls = op[:columns].map{|c| ["ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(c)} SET NOT NULL", reorg_sql(table)]}
-            sqls << super
-            sqls.flatten
-          else
-            super
-          end
-        else
-          super
-        end
-      end
-
-      # DB2 uses an identity column for autoincrement.
-      def auto_increment_sql
-        AUTOINCREMENT
-      end
-
-      # Add null/not null SQL fragment to column creation SQL.
-      def column_definition_null_sql(sql, column)
-        null = column.fetch(:null, column[:allow_null]) 
-        null = false  if column[:primary_key]
-
-        sql << NOT_NULL if null == false
-        sql << NULL if null == true
-      end
-
-      # Supply columns with NOT NULL if they are part of a composite
-      # primary key or unique constraint
-      def column_list_sql(g)
-        ks = []
-        g.constraints.each{|c| ks = c[:columns] if [:primary_key, :unique].include?(c[:type])} 
-        g.columns.each{|c| c[:null] = false if ks.include?(c[:name]) }
-        super
-      end
-
-      # Insert data from the current table into the new table after
-      # creating the table, since it is not possible to do it in one step.
-      def create_table_as(name, sql, options)
-        super
-        from(name).insert(sql.is_a?(Dataset) ? sql : dataset.with_sql(sql))
-      end
-
-      # DB2 requires parens around the SELECT, and DEFINITION ONLY at the end.
-      def create_table_as_sql(name, sql, options)
-        "#{create_table_prefix_sql(name, options)} AS (#{sql}) DEFINITION ONLY"
-      end
-
-      # Here we use DGTT which has most backward compatibility, which uses
-      # DECLARE instead of CREATE. CGTT can only be used after version 9.7.
-      # http://www.ibm.com/developerworks/data/library/techarticle/dm-0912globaltemptable/
-      def create_table_prefix_sql(name, options)
-        if options[:temp]
-          "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)}"
-        else
-          super
-        end
-      end
-
-      DATABASE_ERROR_REGEXPS = {
-        /DB2 SQL Error: SQLCODE=-803, SQLSTATE=23505|One or more values in the INSERT statement, UPDATE statement, or foreign key update caused by a DELETE statement are not valid because the primary key, unique constraint or unique index/ => UniqueConstraintViolation,
-        /DB2 SQL Error: (SQLCODE=-530, SQLSTATE=23503|SQLCODE=-532, SQLSTATE=23504)|The insert or update value of the FOREIGN KEY .+ is not equal to any value of the parent key of the parent table|A parent row cannot be deleted because the relationship .+ restricts the deletion/ => ForeignKeyConstraintViolation,
-        /DB2 SQL Error: SQLCODE=-545, SQLSTATE=23513|The requested operation is not allowed because a row does not satisfy the check constraint/ => CheckConstraintViolation,
-        /DB2 SQL Error: SQLCODE=-407, SQLSTATE=23502|Assignment of a NULL value to a NOT NULL column/ => NotNullConstraintViolation,
-        /DB2 SQL Error: SQLCODE=-911, SQLSTATE=40001|The current transaction has been rolled back because of a deadlock or timeout/ => SerializationFailure,
-      }.freeze
-      def database_error_regexps
-        DATABASE_ERROR_REGEXPS
-      end
-
-      # DB2 has issues with quoted identifiers, so
-      # turn off database quoting by default.
-      def quote_identifiers_default
-        false
-      end
-
-      # DB2 uses RENAME TABLE to rename tables.
-      def rename_table_sql(name, new_name)
-        "RENAME TABLE #{quote_schema_table(name)} TO #{quote_schema_table(new_name)}"
-      end
-
-      # Run the REORG TABLE command for the table, necessary when
-      # the table has been altered.
-      def reorg(table)
-        synchronize(opts[:server]){|c| c.execute(reorg_sql(table))}
-      end
-
-      # The SQL to use for REORGing a table.
-      def reorg_sql(table)
-        "CALL ADMIN_CMD(#{literal("REORG TABLE #{table}")})"
-      end
-
-      # Treat clob as blob if use_clob_as_blob is true
-      def schema_column_type(db_type)
-        (::Sequel::DB2::use_clob_as_blob && db_type.downcase == 'clob') ? :blob : super
-      end
-
-      # SQL to set the transaction isolation level
-      def set_transaction_isolation_sql(level)
-        "SET CURRENT ISOLATION #{Database::TRANSACTION_ISOLATION_LEVELS[level]}"
-      end
-
-      # We uses the clob type by default for Files.
-      # Note: if user select to use blob, then insert statement should use 
-      # use this for blob value:
-      #     cast(X'fffefdfcfbfa' as blob(2G))
-      def type_literal_generic_file(column)
-        ::Sequel::DB2::use_clob_as_blob ? :clob : :blob
-      end
-
-      # DB2 uses smallint to store booleans.
-      def type_literal_generic_trueclass(column)
-        :smallint
-      end
-      alias type_literal_generic_falseclass type_literal_generic_trueclass
-
-      # DB2 uses clob for text types.
-      def uses_clob_for_text?
-        true
-      end
-
-      # DB2 supports views with check option.
-      def view_with_check_option_support
-        :local
-      end
-    end
-
-    module DatasetMethods
-      include EmulateOffsetWithRowNumber
-
-      PAREN_CLOSE = Dataset::PAREN_CLOSE
-      PAREN_OPEN = Dataset::PAREN_OPEN
-      BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR, :'B~'=>:BITNOT}
-      EMULATED_FUNCTION_MAP = {:char_length=>'length'.freeze}
-      BOOL_TRUE = '1'.freeze
-      BOOL_FALSE = '0'.freeze
-      CAST_STRING_OPEN = "RTRIM(CHAR(".freeze
-      CAST_STRING_CLOSE = "))".freeze
-      FETCH_FIRST_ROW_ONLY = " FETCH FIRST ROW ONLY".freeze
-      FETCH_FIRST = " FETCH FIRST ".freeze
-      ROWS_ONLY = " ROWS ONLY".freeze
-      EMPTY_FROM_TABLE = ' FROM "SYSIBM"."SYSDUMMY1"'.freeze
-      HSTAR = "H*".freeze
-      BLOB_OPEN = "BLOB(X'".freeze
-      BLOB_CLOSE = "')".freeze
-
-      # DB2 casts strings using RTRIM and CHAR instead of VARCHAR.
-      def cast_sql_append(sql, expr, type)
-        if(type == String)
-          sql << CAST_STRING_OPEN
-          literal_append(sql, expr)
-          sql << CAST_STRING_CLOSE
-        else
-          super
-        end
-      end
-
-      def complex_expression_sql_append(sql, op, args)
-        case op
-        when :&, :|, :^, :%, :<<, :>>
-          complex_expression_emulate_append(sql, op, args)
-        when :'B~'
-          literal_append(sql, SQL::Function.new(:BITNOT, *args))
-        when :extract
-          sql << args.at(0).to_s
-          sql << PAREN_OPEN
-          literal_append(sql, args.at(1))
-          sql << PAREN_CLOSE
-        else
-          super
-        end
-      end
-
-      def supports_cte?(type=:select)
-        type == :select
-      end
-
-      # DB2 supports GROUP BY CUBE
-      def supports_group_cube?
-        true
-      end
-
-      # DB2 supports GROUP BY ROLLUP
-      def supports_group_rollup?
-        true
-      end
-
-      # DB2 does not support IS TRUE.
-      def supports_is_true?
-        false
-      end
-
-      # DB2 supports lateral subqueries
-      def supports_lateral_subqueries?
-        true
-      end
-      
-      # DB2 does not support multiple columns in IN.
-      def supports_multiple_column_in?
-        false
-      end
-
-      # DB2 only allows * in SELECT if it is the only thing being selected.
-      def supports_select_all_and_column?
-        false
-      end
-
-      # DB2 does not support fractional seconds in timestamps.
-      def supports_timestamp_usecs?
-        false
-      end
-
-      # DB2 supports window functions
-      def supports_window_functions?
-        true
-      end
-
-      # DB2 does not support WHERE 1.
-      def supports_where_true?
-        false
-      end
-
-      private
-
-      def empty_from_sql
-        EMPTY_FROM_TABLE
-      end
-
-      # DB2 needs the standard workaround to insert all default values into
-      # a table with more than one column.
-      def insert_supports_empty_values?
-        false
-      end
-
-      # Use 0 for false on DB2
-      def literal_false
-        BOOL_FALSE
-      end
-
-      # Use 1 for true on DB2
-      def literal_true
-        BOOL_TRUE
-      end
-
-      # DB2 uses a literal hexidecimal number for blob strings
-      def literal_blob_append(sql, v)
-        if ::Sequel::DB2.use_clob_as_blob
-          super
-        else
-          sql << BLOB_OPEN << v.unpack(HSTAR).first << BLOB_CLOSE
-        end
-      end
-
-      # DB2 can insert multiple rows using a UNION
-      def multi_insert_sql_strategy
-        :union
-      end
-
-      # DB2 does not require that ROW_NUMBER be ordered.
-      def require_offset_order?
-        false
-      end
-
-      # Modify the sql to limit the number of rows returned
-      # Note: 
-      #
-      #     After db2 v9.7, MySQL flavored "LIMIT X OFFSET Y" can be enabled using
-      #
-      #     db2set DB2_COMPATIBILITY_VECTOR=MYSQL
-      #     db2stop
-      #     db2start
-      #
-      #     Support for this feature is not used in this adapter however.
-      def select_limit_sql(sql)
-        if l = @opts[:limit]
-          if l == 1
-            sql << FETCH_FIRST_ROW_ONLY
-          else
-            sql << FETCH_FIRST
-            literal_append(sql, l)
-            sql << ROWS_ONLY
-          end
-        end
-      end
-      
-      # DB2 supports quoted function names.
-      def supports_quoted_function_names?
-        true
-      end
-
-      def _truncate_sql(table)
-        # "TRUNCATE #{table} IMMEDIATE" is only for newer version of db2, so we
-        # use the following one
-        "ALTER TABLE #{quote_schema_table(table)} ACTIVATE NOT LOGGED INITIALLY WITH EMPTY TABLE"
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/adapters/shared/fdbsql.rb

@@ -1,550 +0,0 @@
-Sequel.require 'adapters/utils/pg_types'
-
-module Sequel
-
-  # Top level module for holding all FoundationDB SQL Layer related modules and
-  # classes for Sequel.
-  module Fdbsql
-
-    # Array of exceptions that need to be converted.  JDBC
-    # uses NativeExceptions, the native adapter uses PGError.
-    CONVERTED_EXCEPTIONS  = []
-
-    # Methods shared by Database instances that connect to
-    # the FoundationDB SQL Layer
-    module DatabaseMethods
-
-      # A hash of conversion procs, keyed by type integer (oid) and
-      # having callable values for the conversion proc for that type.
-      attr_reader :conversion_procs
-
-      # Convert given argument so that it can be used directly by pg.  Currently, pg doesn't
-      # handle fractional seconds in Time/DateTime or blobs with "\0", and it won't ever
-      # handle Sequel::SQLTime values correctly.  Only public for use by the adapter, shouldn't
-      # be used by external code.
-      def bound_variable_arg(arg, conn)
-        case arg
-        # TODO TDD it:
-        when Sequel::SQL::Blob
-          # the 1 means treat this as a binary blob
-          {:value => arg, :format => 1}
-        when Sequel::SQLTime
-          # the literal methods put quotes around things, but this is a bound variable, so we can't use those
-          arg.strftime(BOUND_VARIABLE_SQLTIME_FORMAT)
-        when DateTime, Time
-          # the literal methods put quotes around things, but this is a bound variable, so we can't use those
-          from_application_timestamp(arg).strftime(BOUND_VARIABLE_TIMESTAMP_FORMAT)
-        else
-           arg
-        end
-      end
-
-      # Fdbsql uses the :fdbsql database type.
-      def database_type
-        :fdbsql
-      end
-
-      # like PostgreSQL fdbsql uses SERIAL psuedo-type instead of AUTOINCREMENT for
-      # managing incrementing primary keys.
-      def serial_primary_key_options
-        {:primary_key => true, :serial => true, :type=>Integer}
-      end
-
-      # indexes are namespaced per table
-      def global_index_namespace?
-        false
-      end
-
-      # Return primary key for the given table.
-      def primary_key(table_name, opts=OPTS)
-        quoted_table = quote_schema_table(table_name)
-        Sequel.synchronize{return @primary_keys[quoted_table] if @primary_keys.has_key?(quoted_table)}
-        out_identifier, in_identifier = identifier_convertors(opts)
-        schema, table = schema_or_current_and_table(table_name, opts)
-        dataset = metadata_dataset.
-          select(:kc__column_name).
-          from(Sequel.as(:information_schema__key_column_usage, 'kc')).
-          join(Sequel.as(:information_schema__table_constraints, 'tc'),
-               [:table_name, :table_schema, :constraint_name]).
-          where(:kc__table_name => in_identifier.call(table),
-                :kc__table_schema => schema,
-                :tc__constraint_type => 'PRIMARY KEY')
-        value = dataset.map do |row|
-          out_identifier.call(row.delete(:column_name))
-        end
-        value = case value.size
-                  when 0 then nil
-                  when 1 then value.first
-                  else value
-                end
-        Sequel.synchronize{@primary_keys[quoted_table] = value}
-      end
-
-      # the sql layer supports CREATE TABLE IF NOT EXISTS syntax,
-      def supports_create_table_if_not_exists?
-        true
-      end
-
-      # Fdbsql supports deferrable fk constraints
-      def supports_deferrable_foreign_key_constraints?
-        true
-      end
-
-      # the sql layer supports DROP TABLE IF EXISTS
-      def supports_drop_table_if_exists?
-        true
-      end
-
-      # Array of symbols specifying table names in the current database.
-      # The dataset used is yielded to the block if one is provided,
-      # otherwise, an array of symbols of table names is returned.
-      #
-      # Options:
-      # :qualify :: Return the tables as Sequel::SQL::QualifiedIdentifier instances,
-      #             using the schema the table is located in as the qualifier.
-      # :schema :: The schema to search
-      # :server :: The server to use
-      def tables(opts=OPTS, &block)
-        tables_or_views('TABLE', opts, &block)
-      end
-
-      # Array of symbols specifying view names in the current database.
-      #
-      # Options:
-      # :qualify :: Return the views as Sequel::SQL::QualifiedIdentifier instances,
-      #             using the schema the view is located in as the qualifier.
-      # :schema :: The schema to search
-      # :server :: The server to use
-      def views(opts=OPTS, &block)
-        tables_or_views('VIEW', opts, &block)
-      end
-
-      # Return full foreign key information, including
-      # Postgres returns hash like:
-      # {"b_e_fkey"=> {:name=>:b_e_fkey, :columns=>[:e], :on_update=>:no_action, :on_delete=>:no_action, :deferrable=>false, :table=>:a, :key=>[:c]}}
-      def foreign_key_list(table, opts=OPTS)
-        out_identifier, in_identifier = identifier_convertors(opts)
-        schema, table = schema_or_current_and_table(table, opts)
-        sql_table = in_identifier.call(table)
-        columns_dataset = metadata_dataset.
-          select(:tc__table_name___table_name,
-                 :tc__table_schema___table_schema,
-                 :tc__is_deferrable___deferrable,
-                 :kc__column_name___column_name,
-                 :kc__constraint_schema___schema,
-                 :kc__constraint_name___name,
-                 :rc__update_rule___on_update,
-                 :rc__delete_rule___on_delete).
-          from(Sequel.as(:information_schema__table_constraints, 'tc')).
-          join(Sequel.as(:information_schema__key_column_usage, 'kc'),
-               [:constraint_schema, :constraint_name]).
-          join(Sequel.as(:information_schema__referential_constraints, 'rc'),
-               [:constraint_name, :constraint_schema]).
-          where(:tc__table_name => sql_table,
-                :tc__table_schema => schema,
-                :tc__constraint_type => 'FOREIGN KEY')
-
-        keys_dataset = metadata_dataset.
-          select(:rc__constraint_schema___schema,
-                 :rc__constraint_name___name,
-                 :kc__table_name___key_table,
-                 :kc__column_name___key_column).
-          from(Sequel.as(:information_schema__table_constraints, 'tc')).
-          join(Sequel.as(:information_schema__referential_constraints, 'rc'),
-               [:constraint_schema, :constraint_name]).
-          join(Sequel.as(:information_schema__key_column_usage, 'kc'),
-               :kc__constraint_schema => :rc__unique_constraint_schema,
-               :kc__constraint_name => :rc__unique_constraint_name).
-          where(:tc__table_name => sql_table,
-                :tc__table_schema => schema,
-                :tc__constraint_type => 'FOREIGN KEY')
-        foreign_keys = {}
-        columns_dataset.each do |row|
-          foreign_key = foreign_keys.fetch(row[:name]) do |key|
-            foreign_keys[row[:name]] = row
-            row[:name] = out_identifier.call(row[:name])
-            row[:columns] = []
-            row[:key] = []
-            row
-          end
-          foreign_key[:columns] << out_identifier.call(row[:column_name])
-        end
-        keys_dataset.each do |row|
-          foreign_key = foreign_keys[row[:name]]
-          foreign_key[:table] = out_identifier.call(row[:key_table])
-          foreign_key[:key] << out_identifier.call(row[:key_column])
-        end
-        foreign_keys.values
-      end
-
-      # Return indexes for the table
-      # postgres returns:
-      # {:blah_blah_index=>{:columns=>[:n], :unique=>true, :deferrable=>nil},
-      #  :items_n_a_index=>{:columns=>[:n, :a], :unique=>false, :deferrable=>nil}}
-      def indexes(table, opts=OPTS)
-        out_identifier, in_identifier = identifier_convertors(opts)
-        schema, table = schema_or_current_and_table(table, opts)
-        dataset = metadata_dataset.
-          select(:is__is_unique,
-                 Sequel.as({:is__is_unique => 'YES'}, 'unique'),
-                 :is__index_name,
-                 :ic__column_name).
-          from(Sequel.as(:information_schema__indexes, 'is')).
-          join(Sequel.as(:information_schema__index_columns, 'ic'),
-               :ic__index_table_schema => :is__table_schema,
-               :ic__index_table_name => :is__table_name,
-               :ic__index_name => :is__index_name).
-          where(:is__table_schema => schema,
-                :is__table_name => in_identifier.call(table)).
-          exclude(:is__index_type => 'PRIMARY')
-        indexes = {}
-        dataset.each do |row|
-          index = indexes.fetch(out_identifier.call(row[:index_name])) do |key|
-            h = { :unique => row[:unique], :columns => [] }
-            indexes[key] = h
-            h
-          end
-          index[:columns] << out_identifier.call(row[:column_name])
-        end
-        indexes
-      end
-
-      private
-
-      # the literal methods put quotes around things, but when we bind a variable there shouldn't be quotes around it
-      # it should just be the timestamp, so we need whole new formats here.
-      BOUND_VARIABLE_TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S".freeze
-      BOUND_VARIABLE_SQLTIME_FORMAT = "%H:%M:%S".freeze
-
-      def adapter_initialize
-        @primary_keys = {}
-        # Postgres supports named types in the db, if we want to support anything that's not built in, this
-        # will have to be changed to not be a constant
-        @conversion_procs = Sequel::Postgres::PG_TYPES.dup
-        @conversion_procs[16] = Proc.new {|s| s == 'true'}
-        @conversion_procs[1184] = @conversion_procs[1114] = method(:to_application_timestamp)
-        @conversion_procs.freeze
-      end
-
-      def alter_table_op_sql(table, op)
-        quoted_name = quote_identifier(op[:name]) if op[:name]
-        case op[:op]
-        when :set_column_type
-          "ALTER COLUMN #{quoted_name} SET DATA TYPE #{type_literal(op)}"
-        when :set_column_null
-          "ALTER COLUMN #{quoted_name} #{op[:null] ? '' : 'NOT'} NULL"
-        else
-          super
-        end
-      end
-
-      # Convert exceptions raised from the block into DatabaseErrors.
-      def check_database_errors
-        begin
-          yield
-        rescue => e
-          raise_error(e, :classes=>CONVERTED_EXCEPTIONS)
-        end
-      end
-
-      def column_schema_normalize_default(default, type)
-        # the default value returned by schema parsing is not escaped or quoted
-        # in any way, it's just the value of the string
-        # the base implementation assumes it would come back "'my ''default'' value'"
-        # fdbsql returns "my 'default' value" (Not including double quotes for either)
-        return default
-      end
-
-      # FDBSQL requires parens around the SELECT, and the WITH DATA syntax.
-      def create_table_as_sql(name, sql, options)
-        "#{create_table_prefix_sql(name, options)} AS (#{sql}) WITH DATA"
-      end
-
-      def database_error_classes
-        CONVERTED_EXCEPTIONS
-      end
-
-      STALE_STATEMENT_SQLSTATE = '0A50A'.freeze
-      NOT_NULL_CONSTRAINT_SQLSTATES = %w'23502'.freeze.each{|s| s.freeze}
-      FOREIGN_KEY_CONSTRAINT_SQLSTATES = %w'23503 23504'.freeze.each{|s| s.freeze}
-      UNIQUE_CONSTRAINT_SQLSTATES = %w'23501'.freeze.each{|s| s.freeze}
-
-      # Given the SQLState, return the appropriate DatabaseError subclass.
-      def database_specific_error_class_from_sqlstate(sqlstate)
-        # There is also a CheckConstraintViolation in Sequel, but the sql layer doesn't support check constraints
-        case sqlstate
-        when *NOT_NULL_CONSTRAINT_SQLSTATES
-          NotNullConstraintViolation
-        when *FOREIGN_KEY_CONSTRAINT_SQLSTATES
-          ForeignKeyConstraintViolation
-        when *UNIQUE_CONSTRAINT_SQLSTATES
-          UniqueConstraintViolation
-        end
-      end
-
-      # This is a fallback used by the base class if the sqlstate fails to figure out
-      # what error type it is.
-      DATABASE_ERROR_REGEXPS = [
-        # Add this check first, since otherwise it's possible for users to control
-        # which exception class is generated.
-        [/invalid input syntax/, DatabaseError],
-        # the rest of these are backups in case the sqlstate fails
-        [/[dD]uplicate key violates unique constraint/, UniqueConstraintViolation],
-        [/due (?:to|for) foreign key constraint/, ForeignKeyConstraintViolation],
-        [/NULL value not permitted/, NotNullConstraintViolation],
-      ].freeze
-
-      def database_error_regexps
-        DATABASE_ERROR_REGEXPS
-      end
-
-      def identifier_convertors(opts=OPTS)
-        [output_identifier_meth(opts[:dataset]), input_identifier_meth(opts[:dataset])]
-      end
-
-      # Like PostgreSQL fdbsql folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
-      def identifier_input_method_default
-        nil
-      end
-
-      # Like PostgreSQL fdbsql folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on output.
-      def identifier_output_method_default
-        nil
-      end
-
-      # If the given type is DECIMAL with scale 0, say that it's an integer
-      def normalize_decimal_to_integer(type, scale)
-        if (type == 'DECIMAL' and scale == 0)
-          'integer'
-        else
-          type
-        end
-      end
-
-      # Remove the cached entries for primary keys and sequences when a table is
-      # changed.
-      def remove_cached_schema(table)
-        tab = quote_schema_table(table)
-        Sequel.synchronize do
-          @primary_keys.delete(tab)
-        end
-        super
-      end
-
-      def schema_or_current_and_table(table, opts=OPTS)
-        schema, table = schema_and_table(table)
-        schema = opts.fetch(:schema, schema || Sequel.lit('CURRENT_SCHEMA'))
-        [schema, table]
-      end
-
-      # returns an array of column information with each column being of the form:
-      # [:column_name, {:db_type=>"integer", :default=>nil, :allow_null=>false, :primary_key=>true, :type=>:integer}]
-      def schema_parse_table(table, opts = {})
-        out_identifier, in_identifier = identifier_convertors(opts)
-        schema, table = schema_or_current_and_table(table, opts)
-        dataset = metadata_dataset.
-          select(:c__column_name,
-                 Sequel.as({:c__is_nullable => 'YES'}, 'allow_null'),
-                 :c__column_default___default,
-                 :c__data_type___db_type,
-                 :c__character_maximum_length___max_length,
-                 :c__numeric_scale,
-                 Sequel.as({:tc__constraint_type => 'PRIMARY KEY'}, 'primary_key')).
-          from(Sequel.as(:information_schema__key_column_usage, 'kc')).
-          join(Sequel.as(:information_schema__table_constraints, 'tc'),
-               :tc__constraint_type => 'PRIMARY KEY',
-               :tc__table_name => :kc__table_name,
-               :tc__table_schema => :kc__table_schema,
-               :tc__constraint_name => :kc__constraint_name).
-          right_outer_join(Sequel.as(:information_schema__columns, 'c'),
-                           [:table_name, :table_schema, :column_name]).
-          where(:c__table_name => in_identifier.call(table),
-                :c__table_schema => schema)
-        dataset.map do |row|
-          row[:default] = nil if blank_object?(row[:default])
-          row[:type] = schema_column_type(normalize_decimal_to_integer(row[:db_type], row[:numeric_scale]))
-          [out_identifier.call(row.delete(:column_name)), row]
-        end
-      end
-
-      def tables_or_views(type, opts, &block)
-        schema = opts[:schema] || Sequel.lit('CURRENT_SCHEMA')
-        m = output_identifier_meth
-        dataset = metadata_dataset.server(opts[:server]).select(:table_name).
-          from(Sequel.qualify('information_schema','tables')).
-          where(:table_schema => schema,
-                :table_type => type)
-        if block_given?
-          yield(dataset)
-        elsif opts[:qualify]
-          dataset.select_append(:table_schema).map{|r| Sequel.qualify(m.call(r[:table_schema]), m.call(r[:table_name])) }
-        else
-          dataset.map{|r| m.call(r[:table_name])}
-        end
-      end
-
-      # Handle bigserial type if :serial option is present
-      def type_literal_generic_bignum(column)
-        column[:serial] ? :bigserial : super
-      end
-
-      # Handle serial type if :serial option is present
-      def type_literal_generic_integer(column)
-        column[:serial] ? :serial : super
-      end
-
-    end
-
-    # Instance methods for datasets that connect to the FoundationDB SQL Layer.
-    module DatasetMethods
-
-      Dataset.def_sql_method(self, :delete, %w'with delete from using where returning')
-      Dataset.def_sql_method(self, :insert, %w'with insert into columns values returning')
-      Dataset.def_sql_method(self, :update, %w'with update table set from where returning')
-
-      # Shared methods for prepared statements used with the FoundationDB SQL Layer
-      module PreparedStatementMethods
-
-        def prepared_sql
-          return @prepared_sql if @prepared_sql
-          @opts[:returning] = insert_pk if @prepared_type == :insert
-          super
-          @prepared_sql
-        end
-
-        # Override insert action to use RETURNING if the server supports it.
-        def run
-          if @prepared_type == :insert
-            fetch_rows(prepared_sql){|r| return r.values.first}
-          else
-            super
-          end
-        end
-      end
-
-      # Emulate the bitwise operators.
-      def complex_expression_sql_append(sql, op, args)
-        case op
-        when :&, :|, :^, :<<, :>>, :'B~'
-          complex_expression_emulate_append(sql, op, args)
-        # REGEXP_OPERATORS = [:~, :'!~', :'~*', :'!~*']
-        when :'~'
-          function_sql_append(sql, SQL::Function.new(:REGEX, args.at(0), args.at(1)))
-        when :'!~'
-          sql << Sequel::Dataset::NOT_SPACE
-          function_sql_append(sql, SQL::Function.new(:REGEX, args.at(0), args.at(1)))
-        when :'~*'
-          function_sql_append(sql, SQL::Function.new(:IREGEX, args.at(0), args.at(1)))
-        when :'!~*'
-          sql << Sequel::Dataset::NOT_SPACE
-          function_sql_append(sql, SQL::Function.new(:IREGEX, args.at(0), args.at(1)))
-        else
-          super
-        end
-      end
-
-      # Insert given values into the database.
-      def insert(*values)
-        if @opts[:returning]
-          # Already know which columns to return, let the standard code handle it
-          super
-        elsif @opts[:sql] || @opts[:disable_insert_returning]
-          # Raw SQL used or RETURNING disabled, just use the default behavior
-          # and return nil since sequence is not known.
-          super
-          nil
-        else
-          # Force the use of RETURNING with the primary key value,
-          # unless it has been disabled.
-          returning(*insert_pk).insert(*values){|r| return r.values.first}
-        end
-      end
-
-      # Insert a record returning the record inserted.  Always returns nil without
-      # inserting a query if disable_insert_returning is used.
-      def insert_select(*values)
-        unless @opts[:disable_insert_returning]
-          ds = opts[:returning] ? self : returning
-          ds.insert(*values){|r| return r}
-        end
-      end
-
-      # The SQL to use for an insert_select, adds a RETURNING clause to the insert
-      # unless the RETURNING clause is already present.
-      def insert_select_sql(*values)
-        ds = opts[:returning] ? self : returning
-        ds.insert_sql(*values)
-      end
-
-      # FDBSQL has functions to support regular expression pattern matching.
-      def supports_regexp?
-        true
-      end
-
-      # Returning is always supported.
-      def supports_returning?(type)
-        true
-      end
-
-      # FDBSQL truncates all seconds
-      def supports_timestamp_usecs?
-        false
-      end
-
-      # FDBSQL supports quoted function names
-      def supports_quoted_function_names?
-        true
-      end
-
-      private
-
-      # Use USING to specify additional tables in a delete query
-      def delete_using_sql(sql)
-        join_from_sql(:USING, sql)
-      end
-
-      # Return the primary key to use for RETURNING in an INSERT statement
-      def insert_pk
-        if (f = opts[:from]) && !f.empty?
-          case t = f.first
-          when Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier
-            if pk = db.primary_key(t)
-              pk
-            end
-          end
-        end
-      end
-
-      # For multiple table support, PostgreSQL requires at least
-      # two from tables, with joins allowed.
-      def join_from_sql(type, sql)
-        if(from = @opts[:from][1..-1]).empty?
-          raise(Error, 'Need multiple FROM tables if updating/deleting a dataset with JOINs') if @opts[:join]
-        else
-          sql << SPACE << type.to_s << SPACE
-          source_list_append(sql, from)
-          select_join_sql(sql)
-        end
-      end
-
-      # FDBSQL uses a preceding x for hex escaping strings
-      def literal_blob_append(sql, v)
-        if v.empty?
-          sql << "''"
-        else
-          sql << "x'#{v.unpack('H*').first}'"
-        end
-      end
-
-      # fdbsql does not support FOR UPDATE, because it's unnecessary with the transaction model
-      def select_lock_sql(sql)
-        @opts[:lock] == :update ? sql : super
-      end
-
-      # Use FROM to specify additional tables in an update query
-      def update_from_sql(sql)
-        join_from_sql(:FROM, sql)
-      end
-    end
-  end
-end