epugh-sequel 0.0.0

data/lib/sequel/adapters/odbc.rb

@@ -0,0 +1,184 @@
+require 'odbc'
+
+module Sequel
+  module ODBC
+    class Database < Sequel::Database
+      set_adapter_scheme :odbc
+
+      GUARDED_DRV_NAME = /^\{.+\}$/.freeze
+      DRV_NAME_GUARDS = '{%s}'.freeze
+
+      def initialize(opts)
+        super(opts)
+        case opts[:db_type]
+        when 'mssql'
+          Sequel.require 'adapters/shared/mssql'
+          extend Sequel::MSSQL::DatabaseMethods
+        when 'progress'
+          Sequel.require 'adapters/shared/progress'
+          extend Sequel::Progress::DatabaseMethods
+        end
+      end
+
+      def connect(server)
+        opts = server_opts(server)
+        if opts.include? :driver
+          drv = ::ODBC::Driver.new
+          drv.name = 'Sequel ODBC Driver130'
+          opts.each do |param, value|
+            if :driver == param and not (value =~ GUARDED_DRV_NAME)
+              value = DRV_NAME_GUARDS % value
+            end
+            drv.attrs[param.to_s.capitalize] = value
+          end
+          db = ::ODBC::Database.new
+          conn = db.drvconnect(drv)
+        else
+          conn = ::ODBC::connect(opts[:database], opts[:user], opts[:password])
+        end
+        conn.autocommit = true
+        conn
+      end      
+
+      def dataset(opts = nil)
+        ODBC::Dataset.new(self, opts)
+      end
+    
+      # ODBC returns native statement objects, which must be dropped if
+      # you call execute manually, or you will get warnings.  See the
+      # fetch_rows method source code for an example of how to drop
+      # the statements.
+      def execute(sql, opts={})
+        log_info(sql)
+        synchronize(opts[:server]) do |conn|
+          r = conn.run(sql)
+          yield(r) if block_given?
+          r
+        end
+      end
+      
+      def execute_dui(sql, opts={})
+        log_info(sql)
+        synchronize(opts[:server]){|conn| conn.do(sql)}
+      end
+      alias_method :do, :execute_dui
+
+      # Support single level transactions on ODBC
+      def transaction(opts={})
+        unless opts.is_a?(Hash)
+          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
+          opts = {:server=>opts}
+        end
+        synchronize(opts[:server]) do |conn|
+          return yield(conn) if @transactions.include?(Thread.current)
+          log_info(begin_transaction_sql)
+          conn.do(begin_transaction_sql)
+          begin
+            @transactions << Thread.current
+            yield(conn)
+          rescue ::Exception => e
+            log_info(rollback_transaction_sql)
+            conn.do(rollback_transaction_sql)
+            transaction_error(e)
+          ensure
+            unless e
+              log_info(commit_transaction_sql)
+              conn.do(commit_transaction_sql)
+            end
+            @transactions.delete(Thread.current)
+          end
+        end
+      end
+
+      private
+
+      def disconnect_connection(c)
+        c.disconnect
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      BOOL_TRUE = '1'.freeze
+      BOOL_FALSE = '0'.freeze
+      ODBC_TIMESTAMP_FORMAT = "{ts '%Y-%m-%d %H:%M:%S'}".freeze
+      ODBC_TIMESTAMP_AFTER_SECONDS =
+        ODBC_TIMESTAMP_FORMAT.index( '%S' ).succ - ODBC_TIMESTAMP_FORMAT.length
+      ODBC_DATE_FORMAT = "{d '%Y-%m-%d'}".freeze
+      UNTITLED_COLUMN = 'untitled_%d'.freeze
+
+      def fetch_rows(sql, &block)
+        execute(sql) do |s|
+          begin
+            untitled_count = 0
+            @columns = s.columns(true).map do |c|
+              if (n = c.name).empty?
+                n = UNTITLED_COLUMN % (untitled_count += 1)
+              end
+              output_identifier(n)
+            end
+            rows = s.fetch_all
+            rows.each {|row| yield hash_row(row)} if rows
+          ensure
+            s.drop unless s.nil? rescue nil
+          end
+        end
+        self
+      end
+      
+      private
+
+      def convert_odbc_value(v)
+        # When fetching a result set, the Ruby ODBC driver converts all ODBC 
+        # SQL types to an equivalent Ruby type; with the exception of
+        # SQL_TYPE_DATE, SQL_TYPE_TIME and SQL_TYPE_TIMESTAMP.
+        #
+        # The conversions below are consistent with the mappings in
+        # ODBCColumn#mapSqlTypeToGenericType and Column#klass.
+        case v
+        when ::ODBC::TimeStamp
+          DateTime.new(v.year, v.month, v.day, v.hour, v.minute, v.second)
+        when ::ODBC::Time
+          now = DateTime.now
+          Time.gm(now.year, now.month, now.day, v.hour, v.minute, v.second)
+        when ::ODBC::Date
+          Date.new(v.year, v.month, v.day)
+        else
+          v
+        end
+      end
+      
+      def hash_row(row)
+        hash = {}
+        row.each_with_index do |v, idx|
+          hash[@columns[idx]] = convert_odbc_value(v)
+        end
+        hash
+      end
+      
+      def literal_date(v)
+        v.strftime(ODBC_DATE_FORMAT)
+      end
+      
+      def literal_datetime(v)
+        formatted = v.strftime(ODBC_TIMESTAMP_FORMAT)
+        usec = v.sec_fraction * 86400000000
+        formatted.insert(ODBC_TIMESTAMP_AFTER_SECONDS, ".#{(usec.to_f/1000).round}") if usec >= 1000
+        formatted
+      end
+      
+      def literal_false
+        BOOL_FALSE
+      end
+      
+      def literal_true
+        BOOL_TRUE
+      end
+
+      def literal_time(v)
+        formatted = v.strftime(ODBC_TIMESTAMP_FORMAT)
+        formatted.insert(ODBC_TIMESTAMP_AFTER_SECONDS, ".#{(v.usec.to_f/1000).round}") if usec >= 1000
+        formatted
+      end
+    end
+  end
+end

data/lib/sequel/adapters/openbase.rb

@@ -0,0 +1,57 @@
+require 'openbase'
+
+module Sequel
+  module OpenBase
+    class Database < Sequel::Database
+      set_adapter_scheme :openbase
+      
+      def connect(server)
+        opts = server_opts(server)
+        OpenBase.new(
+          opts[:database],
+          opts[:host] || 'localhost',
+          opts[:user],
+          opts[:password]
+        )
+      end
+      
+      def dataset(opts = nil)
+        OpenBase::Dataset.new(self, opts)
+      end
+    
+      def execute(sql, opts={})
+        log_info(sql)
+        synchronize(opts[:server]) do |conn|
+          r = conn.execute(sql)
+          yield(r) if block_given?
+          r
+        end
+      end
+      alias_method :do, :execute
+
+      private
+
+      def disconnect_connection(c)
+        c.disconnect
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      def fetch_rows(sql)
+        execute(sql) do |result|
+          begin
+            @columns = result.column_infos.map{|c| output_identifier(c.name)}
+            result.each do |r|
+              row = {}
+              r.each_with_index {|v, i| row[@columns[i]] = v}
+              yield row
+            end
+          ensure
+            # result.close
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/lib/sequel/adapters/oracle.rb

@@ -0,0 +1,140 @@
+require 'oci8'
+Sequel.require 'adapters/shared/oracle'
+
+module Sequel
+  module Oracle
+    class Database < Sequel::Database
+      include DatabaseMethods
+      set_adapter_scheme :oracle
+
+      # ORA-00028: your session has been killed
+      # ORA-01012: not logged on
+      # ORA-03113: end-of-file on communication channel
+      # ORA-03114: not connected to ORACLE
+      CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114 ]      
+      
+      def connect(server)
+        opts = server_opts(server)
+        if opts[:database]
+          dbname = opts[:host] ? \
+            "//#{opts[:host]}#{":#{opts[:port]}" if opts[:port]}/#{opts[:database]}" : opts[:database]
+        else
+          dbname = opts[:host]
+        end
+        conn = OCI8.new(opts[:user], opts[:password], dbname, opts[:privilege])
+        conn.autocommit = true
+        conn.non_blocking = true
+        conn
+      end
+      
+      def dataset(opts = nil)
+        Oracle::Dataset.new(self, opts)
+      end
+
+      def schema_parse_table(table, opts={})
+        ds = dataset
+        ds.identifier_output_method = :downcase
+        schema, table = schema_and_table(table)
+        table_schema = []
+        metadata = transaction(opts){|conn| conn.describe_table(table.to_s)}
+        metadata.columns.each do |column|
+          table_schema << [
+            column.name.downcase.to_sym,
+            {
+              :type => column.data_type,
+              :db_type => column.type_string.split(' ')[0],
+              :type_string => column.type_string,
+              :charset_form => column.charset_form,
+              :char_used => column.char_used?,
+              :char_size => column.char_size,
+              :data_size => column.data_size,
+              :precision => column.precision,
+              :scale => column.scale,
+              :fsprecision => column.fsprecision,
+              :lfprecision => column.lfprecision,
+              :allow_null => column.nullable?
+            }
+          ]
+        end
+        table_schema
+      end
+
+      def execute(sql, opts={})
+        log_info(sql)
+        synchronize(opts[:server]) do |conn|
+          begin
+            r = conn.exec(sql)
+            yield(r) if block_given?
+            r
+          rescue OCIException => e
+            if CONNECTION_ERROR_CODES.include?(e.code)  
+              raise(Sequel::DatabaseDisconnectError)              
+            else
+              raise
+            end
+          end
+        end
+      end
+      alias_method :do, :execute
+      
+      def transaction(opts={})
+        unless opts.is_a?(Hash)
+          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
+          opts = {:server=>opts}
+        end
+        synchronize(opts[:server]) do |conn|
+          return yield(conn) if @transactions.include?(Thread.current)
+          conn.autocommit = false
+          begin
+            @transactions << Thread.current
+            yield(conn)
+          rescue => e
+            conn.rollback
+            raise e unless Error::Rollback === e
+          ensure
+            conn.commit unless e
+            conn.autocommit = true
+            @transactions.delete(Thread.current)
+          end
+        end
+      end
+
+      private
+
+      def disconnect_connection(c)
+        c.logoff
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      include DatasetMethods
+
+      def fetch_rows(sql, &block)
+        execute(sql) do |cursor|
+          begin
+            @columns = cursor.get_col_names.map{|c| output_identifier(c)}
+            while r = cursor.fetch
+              row = {}
+              r.each_with_index {|v, i| row[@columns[i]] = v unless @columns[i] == :raw_rnum_}
+              yield row
+            end
+          ensure
+            cursor.close
+          end
+        end
+        self
+      end
+
+      private
+
+      def literal_other(v)
+        case v
+        when OraDate
+          literal_time(Time.local(*v.to_a))
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/adapters/postgres.rb

@@ -0,0 +1,453 @@
+Sequel.require 'adapters/shared/postgres'
+
+begin 
+  require 'pg' 
+  SEQUEL_POSTGRES_USES_PG = true
+rescue LoadError => e 
+  SEQUEL_POSTGRES_USES_PG = false
+  begin
+    require 'postgres'
+    # Attempt to get uniform behavior for the PGconn object no matter
+    # if pg, postgres, or postgres-pr is used.
+    class PGconn
+      unless method_defined?(:escape_string)
+        if self.respond_to?(:escape)
+          # If there is no escape_string instead method, but there is an
+          # escape class method, use that instead.
+          def escape_string(str)
+            Sequel::Postgres.force_standard_strings ? str.gsub("'", "''") : self.class.escape(str)
+          end
+        else
+          # Raise an error if no valid string escaping method can be found.
+          def escape_string(obj)
+            raise Sequel::Error, "string escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
+          end
+        end
+      end
+      unless method_defined?(:escape_bytea)
+        if self.respond_to?(:escape_bytea)
+          # If there is no escape_bytea instance method, but there is an
+          # escape_bytea class method, use that instead.
+          def escape_bytea(obj)
+            self.class.escape_bytea(obj)
+          end
+        else
+          begin
+            require 'postgres-pr/typeconv/conv'
+            require 'postgres-pr/typeconv/bytea'
+            extend Postgres::Conversion
+            # If we are using postgres-pr, use the encode_bytea method from
+            # that.
+            def escape_bytea(obj)
+              self.class.encode_bytea(obj)
+            end
+            instance_eval{alias unescape_bytea decode_bytea}
+          rescue
+            # If no valid bytea escaping method can be found, create one that
+            # raises an error
+            def escape_bytea(obj)
+              raise Sequel::Error, "bytea escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
+            end
+            # If no valid bytea unescaping method can be found, create one that
+            # raises an error
+            def self.unescape_bytea(obj)
+              raise Sequel::Error, "bytea unescaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
+            end
+          end
+        end
+      end
+      alias_method :finish, :close unless method_defined?(:finish)
+      alias_method :async_exec, :exec unless method_defined?(:async_exec)
+      unless method_defined?(:block)
+        def block(timeout=nil)
+        end
+      end
+      unless defined?(CONNECTION_OK)
+        CONNECTION_OK = -1
+      end
+    end
+    class PGresult 
+      alias_method :nfields, :num_fields unless method_defined?(:nfields) 
+      alias_method :ntuples, :num_tuples unless method_defined?(:ntuples) 
+      alias_method :ftype, :type unless method_defined?(:ftype) 
+      alias_method :fname, :fieldname unless method_defined?(:fname) 
+      alias_method :cmd_tuples, :cmdtuples unless method_defined?(:cmd_tuples) 
+    end 
+  rescue LoadError 
+    raise e 
+  end 
+end
+
+module Sequel
+  module Postgres
+    CONVERTED_EXCEPTIONS << PGError
+    
+    # Hash with integer keys and proc values for converting PostgreSQL types.
+    PG_TYPES = {}
+
+    # Use a single proc for each type to conserve memory
+    PG_TYPE_PROCS  = {
+      [16] =>  lambda{|s| s == 't'}, # boolean
+      [17] => lambda{|s| ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s))}, # bytea
+      [20, 21, 22, 23, 26] => lambda{|s| s.to_i}, # integer
+      [700, 701] => lambda{|s| s.to_f}, # float
+      [790, 1700] => lambda{|s| BigDecimal.new(s)}, # numeric
+      [1082] => lambda{|s| @use_iso_date_format ? Date.new(*s.split("-").map{|x| x.to_i}) : Sequel.string_to_date(s)}, # date
+      [1083, 1266] => lambda{|s| Sequel.string_to_time(s)}, # time
+      [1114, 1184] => lambda{|s| Sequel.string_to_datetime(s)}, # timestamp
+    }
+    PG_TYPE_PROCS.each do |k,v|
+      k.each{|n| PG_TYPES[n] = v}
+    end
+    
+    @use_iso_date_format = true
+
+    class << self
+      # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
+      # the date in a known format that Sequel can parse faster.  This can be turned off
+      # if you require a date style other than ISO.
+      attr_accessor :use_iso_date_format
+    end
+    
+    # PGconn subclass for connection specific methods used with the
+    # pg, postgres, or postgres-pr driver.
+    class Adapter < ::PGconn
+      include Sequel::Postgres::AdapterMethods
+      self.translate_results = false if respond_to?(:translate_results=)
+      
+      # Apply connection settings for this connection.  Current sets
+      # the date style to ISO in order make Date object creation in ruby faster,
+      # if Postgres.use_iso_date_format is true.
+      def apply_connection_settings
+        super
+        if Postgres.use_iso_date_format
+          sql = "SET DateStyle = 'ISO'"
+          @db.log_info(sql)
+          execute(sql)
+        end
+      end
+
+      # Execute the given SQL with this connection.  If a block is given,
+      # yield the results, otherwise, return the number of changed rows.
+      def execute(sql, args=nil)
+        q = nil
+        begin
+          q = args ? async_exec(sql, args) : async_exec(sql)
+        rescue PGError
+          begin
+            s = status
+          rescue PGError
+            raise(Sequel::DatabaseDisconnectError)
+          end
+          status_ok = (s == Adapter::CONNECTION_OK)
+          status_ok ? raise : raise(Sequel::DatabaseDisconnectError)
+        ensure
+          block if status_ok
+        end
+        begin
+          block_given? ? yield(q) : q.cmd_tuples
+        ensure
+          q.clear
+        end
+      end
+
+      # Reapply the connection settings if the connection is reset.
+      def reset(*args, &block)
+        super(*args, &block)
+        apply_connection_settings
+      end
+      
+      if SEQUEL_POSTGRES_USES_PG
+        # Hash of prepared statements for this connection.  Keys are
+        # string names of the server side prepared statement, and values
+        # are SQL strings.
+        def prepared_statements
+          @prepared_statements ||= {}
+        end
+      end
+      
+      private
+      
+      # Return the requested values for the given row.
+      def single_value(r)
+        r.getvalue(0, 0) unless r.nil? || (r.ntuples == 0)
+      end
+    end
+    
+    # Database class for PostgreSQL databases used with Sequel and the
+    # pg, postgres, or postgres-pr driver.
+    class Database < Sequel::Database
+      include Sequel::Postgres::DatabaseMethods
+      
+      set_adapter_scheme :postgres
+      
+      # Add the primary_keys and primary_key_sequences instance variables,
+      # so we can get the correct return values for inserted rows.
+      def initialize(*args)
+        super
+        @primary_keys = {}
+        @primary_key_sequences = {}
+      end
+
+      # Connects to the database.  In addition to the standard database
+      # options, using the :encoding or :charset option changes the
+      # client encoding for the connection.
+      def connect(server)
+        opts = server_opts(server)
+        conn = Adapter.connect(
+          (opts[:host] unless blank_object?(opts[:host])),
+          opts[:port] || 5432,
+          nil, '',
+          opts[:database],
+          opts[:user],
+          opts[:password]
+        )
+        if encoding = opts[:encoding] || opts[:charset]
+          if conn.respond_to?(:set_client_encoding)
+            conn.set_client_encoding(encoding)
+          else
+            conn.async_exec("set client_encoding to '#{encoding}'")
+          end
+        end
+        conn.db = self
+        conn.apply_connection_settings
+        conn
+      end
+      
+      # Return instance of Sequel::Postgres::Dataset with the given options.
+      def dataset(opts = nil)
+        Postgres::Dataset.new(self, opts)
+      end
+      
+      # Execute the given SQL with the given args on an available connection.
+      def execute(sql, opts={}, &block)
+        return execute_prepared_statement(sql, opts, &block) if Symbol === sql
+        begin
+          log_info(sql, opts[:arguments])
+          synchronize(opts[:server]){|conn| conn.execute(sql, opts[:arguments], &block)}
+        rescue => e
+          log_info(e.message)
+          raise_error(e, :classes=>CONVERTED_EXCEPTIONS)
+        end
+      end
+      
+      # Insert the values into the table and return the primary key (if
+      # automatically generated).
+      def execute_insert(sql, opts={})
+        return execute(sql, opts) if Symbol === sql
+        begin 
+          log_info(sql, opts[:arguments])
+          synchronize(opts[:server]) do |conn|
+            conn.execute(sql, opts[:arguments])
+            insert_result(conn, opts[:table], opts[:values])
+          end
+        rescue => e
+          log_info(e.message)
+          raise_error(e, :classes=>CONVERTED_EXCEPTIONS)
+        end
+      end
+      
+      private
+
+      # PostgreSQL doesn't need the connection pool to convert exceptions.
+      def connection_pool_default_options
+        super.merge(:pool_convert_exceptions=>false)
+      end
+      
+      # Disconnect given connection
+      def disconnect_connection(conn)
+        begin
+          conn.finish
+        rescue PGError
+        end
+      end
+      
+      # Execute the prepared statement with the given name on an available
+      # connection, using the given args.  If the connection has not prepared
+      # a statement with the given name yet, prepare it.  If the connection
+      # has prepared a statement with the same name and different SQL,
+      # deallocate that statement first and then prepare this statement.
+      # If a block is given, yield the result, otherwise, return the number
+      # of rows changed.  If the :insert option is passed, return the value
+      # of the primary key for the last inserted row.
+      def execute_prepared_statement(name, opts={})
+        ps = prepared_statements[name]
+        sql = ps.prepared_sql
+        ps_name = name.to_s
+        args = opts[:arguments]
+        synchronize(opts[:server]) do |conn|
+          unless conn.prepared_statements[ps_name] == sql
+            if conn.prepared_statements.include?(ps_name)
+              s = "DEALLOCATE #{ps_name}"
+              log_info(s)
+              conn.execute(s) unless conn.prepared_statements[ps_name] == sql
+            end
+            conn.prepared_statements[ps_name] = sql
+            log_info("PREPARE #{ps_name} AS #{sql}")
+            conn.prepare(ps_name, sql)
+          end
+          log_info("EXECUTE #{ps_name}", args)
+          q = conn.exec_prepared(ps_name, args)
+          if opts[:table] && opts[:values]
+            insert_result(conn, opts[:table], opts[:values])
+          else
+            begin
+              block_given? ? yield(q) : q.cmd_tuples
+            ensure
+              q.clear
+            end
+          end
+        end
+      end
+    end
+    
+    # Dataset class for PostgreSQL datasets that use the pg, postgres, or
+    # postgres-pr driver.
+    class Dataset < Sequel::Dataset
+      include Sequel::Postgres::DatasetMethods
+      
+      # Yield all rows returned by executing the given SQL and converting
+      # the types.
+      def fetch_rows(sql)
+        cols = []
+        execute(sql) do |res|
+          res.nfields.times do |fieldnum|
+            cols << [fieldnum, PG_TYPES[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
+          end
+          @columns = cols.map{|c| c.at(2)}
+          res.ntuples.times do |recnum|
+            converted_rec = {}
+            cols.each do |fieldnum, type_proc, fieldsym|
+              value = res.getvalue(recnum, fieldnum)
+              converted_rec[fieldsym] = (value && type_proc) ? type_proc.call(value) : value
+            end
+            yield converted_rec
+          end
+        end
+      end
+
+      if SEQUEL_POSTGRES_USES_PG
+        
+        PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
+        
+        # PostgreSQL specific argument mapper used for mapping the named
+        # argument hash to a array with numbered arguments.  Only used with
+        # the pg driver.
+        module ArgumentMapper
+          include Sequel::Dataset::ArgumentMapper
+          
+          protected
+          
+          # Return an array of strings for each of the hash values, inserting
+          # them to the correct position in the array.
+          def map_to_prepared_args(hash)
+            @prepared_args.map{|k| hash[k.to_sym].to_s}
+          end
+
+          private
+          
+          # PostgreSQL most of the time requires type information for each of
+          # arguments to a prepared statement.  Handle this by allowing the
+          # named argument to have a __* suffix, with the * being the type.
+          # In the generated SQL, cast the bound argument to that type to
+          # elminate ambiguity (and PostgreSQL from raising an exception).
+          def prepared_arg(k)
+            y, type = k.to_s.split("__")
+            if i = @prepared_args.index(y)
+              i += 1
+            else
+              @prepared_args << y
+              i = @prepared_args.length
+            end
+            LiteralString.new("#{prepared_arg_placeholder}#{i}#{"::#{type}" if type}")
+          end
+        end
+
+        # Allow use of bind arguments for PostgreSQL using the pg driver.
+        module BindArgumentMethods
+          include ArgumentMapper
+          
+          private
+          
+          # Execute the given SQL with the stored bind arguments.
+          def execute(sql, opts={}, &block)
+            super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+          end
+          
+          # Same as execute, explicit due to intricacies of alias and super.
+          def execute_dui(sql, opts={}, &block)
+            super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+          end
+          
+          # Same as execute, explicit due to intricacies of alias and super.
+          def execute_insert(sql, opts={}, &block)
+            super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+          end
+        end
+        
+        # Allow use of server side prepared statements for PostgreSQL using the
+        # pg driver.
+        module PreparedStatementMethods
+          include BindArgumentMethods
+          include ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods
+          
+          private
+          
+          # Execute the stored prepared statement name and the stored bind
+          # arguments instead of the SQL given.
+          def execute(sql, opts={}, &block)
+            super(prepared_statement_name, opts, &block)
+          end
+          
+          # Same as execute, explicit due to intricacies of alias and super.
+          def execute_dui(sql, opts={}, &block)
+            super(prepared_statement_name, opts, &block)
+          end
+          
+          # Same as execute, explicit due to intricacies of alias and super.
+          def execute_insert(sql, opts={}, &block)
+            super(prepared_statement_name, opts, &block)
+          end
+        end
+        
+        # Execute the given type of statement with the hash of values.
+        def call(type, hash, values=nil, &block)
+          ps = to_prepared_statement(type, values)
+          ps.extend(BindArgumentMethods)
+          ps.call(hash, &block)
+        end
+        
+        # Prepare the given type of statement with the given name, and store
+        # it in the database to be called later.
+        def prepare(type, name=nil, values=nil)
+          ps = to_prepared_statement(type, values)
+          ps.extend(PreparedStatementMethods)
+          if name
+            ps.prepared_statement_name = name
+            db.prepared_statements[name] = ps
+          end
+          ps
+        end
+        
+        private
+        
+        # PostgreSQL uses $N for placeholders instead of ?, so use a $
+        # as the placeholder.
+        def prepared_arg_placeholder
+          PREPARED_ARG_PLACEHOLDER
+        end
+      end
+      
+      private
+
+      def literal_blob(v)
+        db.synchronize{|c| "'#{c.escape_bytea(v)}'"}
+      end
+
+      def literal_string(v)
+        db.synchronize{|c| "'#{c.escape_string(v)}'"}
+      end
+
+    end
+  end
+end