sequel 3.28.0 → 3.29.0

data/lib/sequel/adapters/mysql.rb

@@ -14,9 +14,6 @@ module Sequel
       def boolean(s) s.to_i != 0 end
       def integer(s) s.to_i end
       def float(s) s.to_f end
-      def date(s) ::Sequel::MySQL.convert_date_time(:string_to_date, s) end
-      def time(s) ::Sequel::MySQL.convert_date_time(:string_to_time, s) end
-      def timestamp(s) ::Sequel::MySQL.convert_date_time(:database_to_application_timestamp, s) end
     end.new
 
     # Hash with integer keys and callable values for converting MySQL types.
@@ -30,52 +27,12 @@ module Sequel
       k.each{|n| MYSQL_TYPES[n] = v}
     end
 
-    # Modify the type translator used for the tinyint type based
-    # on the value given.
-    def self.convert_tinyint_to_bool=(v)
-      MYSQL_TYPES[1] = TYPE_TRANSLATOR.method(v ? :boolean : :integer)
-      @convert_tinyint_to_bool = v
-    end
-    self.convert_tinyint_to_bool = convert_tinyint_to_bool
-
     class << self
-      # By default, Sequel raises an exception if in invalid date or time is used.
-      # However, if this is set to nil or :nil, the adapter treats dates
-      # like 0000-00-00 and times like 838:00:00 as nil values.  If set to :string,
-      # it returns the strings as is.  
-      attr_reader :convert_invalid_date_time
-    end
-
-    # Modify the type translators for the date, time, and timestamp types
-    # depending on the value given.
-    def self.convert_invalid_date_time=(v)
-      MYSQL_TYPES[11] = (v != false) ?  TYPE_TRANSLATOR.method(:time) : ::Sequel.method(:string_to_time)
-      m = (v != false) ? TYPE_TRANSLATOR.method(:date) : ::Sequel.method(:string_to_date)
-      [10, 14].each{|i| MYSQL_TYPES[i] = m}
-      m = (v != false) ? TYPE_TRANSLATOR.method(:timestamp) : ::Sequel.method(:database_to_application_timestamp)
-      [7, 12].each{|i| MYSQL_TYPES[i] = m}
-      @convert_invalid_date_time = v
+      # Whether to convert invalid date time values by default.
+      attr_accessor :convert_invalid_date_time
     end
     self.convert_invalid_date_time = false
 
-    # If convert_invalid_date_time is nil, :nil, or :string and
-    # the conversion raises an InvalidValue exception, return v
-    # if :string and nil otherwise.
-    def self.convert_date_time(meth, v)
-      begin
-        Sequel.send(meth, v)
-      rescue InvalidValue
-        case @convert_invalid_date_time
-        when nil, :nil
-          nil
-        when :string
-          v
-        else 
-          raise
-        end
-      end
-    end
-  
     # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
@@ -85,7 +42,26 @@ module Sequel
       MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away|Lost connection to MySQL server during query)/
       
       set_adapter_scheme :mysql
+
+      # Hash of conversion procs for the current database
+      attr_reader :conversion_procs
+      #
+      # Whether to convert tinyint columns to bool for the current database
+      attr_reader :convert_tinyint_to_bool
+
+      # By default, Sequel raises an exception if in invalid date or time is used.
+      # However, if this is set to nil or :nil, the adapter treats dates
+      # like 0000-00-00 and times like 838:00:00 as nil values.  If set to :string,
+      # it returns the strings as is.
+      attr_reader :convert_invalid_date_time
       
+      def initialize(opts={})
+        super
+        @conversion_procs = MYSQL_TYPES.dup
+        self.convert_tinyint_to_bool = Sequel::MySQL.convert_tinyint_to_bool
+        self.convert_invalid_date_time = Sequel::MySQL.convert_invalid_date_time
+      end
+
       # Connect to the database.  In addition to the usual database options,
       # the following options have effect:
       #
@@ -155,11 +131,27 @@ module Sequel
         conn
       end
       
-      # Returns instance of Sequel::MySQL::Dataset with the given options.
-      def dataset(opts = nil)
-        MySQL::Dataset.new(self, opts)
+      # Modify the type translators for the date, time, and timestamp types
+      # depending on the value given.
+      def convert_invalid_date_time=(v)
+        m0 = ::Sequel.method(:string_to_time)
+        @conversion_procs[11] = (v != false) ?  lambda{|v| convert_date_time(v, &m0)} : m0
+        m1 = ::Sequel.method(:string_to_date) 
+        m = (v != false) ? lambda{|v| convert_date_time(v, &m1)} : m1
+        [10, 14].each{|i| @conversion_procs[i] = m}
+        m2 = method(:to_application_timestamp)
+        m = (v != false) ? lambda{|v| convert_date_time(v, &m2)} : m2
+        [7, 12].each{|i| @conversion_procs[i] = m}
+        @convert_invalid_date_time = v
       end
-      
+
+      # Modify the type translator used for the tinyint type based
+      # on the value given.
+      def convert_tinyint_to_bool=(v)
+        @conversion_procs[1] = TYPE_TRANSLATOR.method(v ? :boolean : :integer)
+        @convert_tinyint_to_bool = v
+      end
+
       # Return the version of the MySQL server two which we are connecting.
       def server_version(server=nil)
         @server_version ||= (synchronize(server){|conn| conn.server_version if conn.respond_to?(:server_version)} || super)
@@ -219,6 +211,24 @@ module Sequel
         :query
       end
       
+      # If convert_invalid_date_time is nil, :nil, or :string and
+      # the conversion raises an InvalidValue exception, return v
+      # if :string and nil otherwise.
+      def convert_date_time(v)
+        begin
+          yield v
+        rescue InvalidValue
+          case @convert_invalid_date_time
+          when nil, :nil
+            nil
+          when :string
+            v
+          else 
+            raise
+          end
+        end
+      end
+    
       # The MySQL adapter main error class is Mysql::Error
       def database_error_classes
         [Mysql::Error]
@@ -245,7 +255,7 @@ module Sequel
       
       # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
       def schema_column_type(db_type)
-        Sequel::MySQL.convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
+        convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
       end
     end
     
@@ -253,6 +263,8 @@ module Sequel
     class Dataset < Sequel::Dataset
       include Sequel::MySQL::DatasetMethods
       include Sequel::MySQL::PreparedStatements::DatasetMethods
+
+      Database::DatasetClass = self
       
       # Delete rows matching this dataset
       def delete
@@ -265,11 +277,12 @@ module Sequel
       def fetch_rows(sql, &block)
         execute(sql) do |r|
           i = -1
+          cps = db.conversion_procs
           cols = r.fetch_fields.map do |f| 
             # Pretend tinyint is another integer type if its length is not 1, to
             # avoid casting to boolean if Sequel::MySQL.convert_tinyint_to_bool
             # is set.
-            type_proc = f.type == 1 && f.length != 1 ? MYSQL_TYPES[2] : MYSQL_TYPES[f.type]
+            type_proc = f.type == 1 && f.length != 1 ? cps[2] : cps[f.type]
             [output_identifier(f.name), type_proc, i+=1]
           end
           @columns = cols.map{|c| c.first}

data/lib/sequel/adapters/mysql2.rb

@@ -10,9 +10,18 @@ module Sequel
       include Sequel::MySQL::PreparedStatements::DatabaseMethods
 
       # Mysql::Error messages that indicate the current connection should be disconnected
-      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away)/
+      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away|This connection is still waiting for a result, try again once you have the result)/
 
       set_adapter_scheme :mysql2
+      
+      # Whether to convert tinyint columns to bool for this database
+      attr_accessor :convert_tinyint_to_bool
+
+      # Set the convert_tinyint_to_bool setting based on the default value.
+      def initialize(opts={})
+        super
+        self.convert_tinyint_to_bool = Sequel::MySQL.convert_tinyint_to_bool
+      end
 
       # Connect to the database.  In addition to the usual database options,
       # the following options have effect:
@@ -60,11 +69,6 @@ module Sequel
         conn
       end
 
-      # Returns instance of Sequel::MySQL::Dataset with the given options.
-      def dataset(opts = nil)
-        Mysql2::Dataset.new(self, opts)
-      end
-
       # Return the version of the MySQL server two which we are connecting.
       def server_version(server=nil)
         @server_version ||= (synchronize(server){|conn| conn.server_info[:id]} || super)
@@ -77,7 +81,7 @@ module Sequel
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
         begin
-          r = log_yield(sql){conn.query(sql, :symbolize_keys => true, :database_timezone => Sequel.database_timezone, :application_timezone => Sequel.application_timezone)}
+          r = log_yield(sql){conn.query(sql, :symbolize_keys => true, :database_timezone => timezone, :application_timezone => Sequel.application_timezone)}
           if opts[:type] == :select
             yield r if r
           elsif block_given?
@@ -115,7 +119,7 @@ module Sequel
 
       # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
       def schema_column_type(db_type)
-        Sequel::MySQL.convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
+        convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
       end
     end
 
@@ -124,6 +128,8 @@ module Sequel
       include Sequel::MySQL::DatasetMethods
       include Sequel::MySQL::PreparedStatements::DatasetMethods
 
+      Database::DatasetClass = self
+
       # Delete rows matching this dataset
       def delete
         execute_dui(delete_sql){|c| return c.affected_rows}
@@ -133,7 +139,7 @@ module Sequel
       def fetch_rows(sql, &block)
         execute(sql) do |r|
           @columns = r.fields
-          r.each(:cast_booleans => Sequel::MySQL.convert_tinyint_to_bool, &block)
+          r.each(:cast_booleans => db.convert_tinyint_to_bool, &block)
         end
         self
       end

data/lib/sequel/adapters/odbc.rb

@@ -15,13 +15,16 @@ module Sequel
         when 'mssql'
           Sequel.ts_require 'adapters/odbc/mssql'
           extend Sequel::ODBC::MSSQL::DatabaseMethods
+          @dataset_class = Sequel::ODBC::MSSQL::Dataset
           set_mssql_unicode_strings
         when 'progress'
           Sequel.ts_require 'adapters/shared/progress'
           extend Sequel::Progress::DatabaseMethods
+          extend_datasets(Sequel::Progress::DatasetMethods)
         when 'db2'
           Sequel.ts_require 'adapters/odbc/db2'
           extend Sequel::ODBC::DB2::DatabaseMethods
+          @dataset_class = Sequel::ODBC::DB2::Dataset
         end
       end
 
@@ -45,10 +48,6 @@ module Sequel
         conn
       end      
 
-      def dataset(opts = nil)
-        ODBC::Dataset.new(self, opts)
-      end
-    
       def execute(sql, opts={})
         synchronize(opts[:server]) do |conn|
           begin
@@ -99,15 +98,23 @@ module Sequel
       ODBC_DATE_FORMAT = "{d '%Y-%m-%d'}".freeze
       TIMESTAMP_FORMAT="{ts '%Y-%m-%d %H:%M:%S'}".freeze
 
+      Database::DatasetClass = self
+
       def fetch_rows(sql)
         execute(sql) do |s|
           i = -1
           cols = s.columns(true).map{|c| [output_identifier(c.name), i+=1]}
-          @columns = cols.map{|c| c.at(0)}
+          columns = cols.map{|c| c.at(0)}
+          if opts[:offset] && offset_returns_row_number_column?
+            rn = row_number_column
+            columns.delete(rn)
+          end
+          @columns = columns
           if rows = s.fetch_all
             rows.each do |row|
               hash = {}
               cols.each{|n,i| hash[n] = convert_odbc_value(row[i])}
+              hash.delete(rn) if rn
               yield hash
             end
           end
@@ -126,7 +133,7 @@ module Sequel
         # ODBCColumn#mapSqlTypeToGenericType and Column#klass.
         case v
         when ::ODBC::TimeStamp
-          Sequel.database_to_application_timestamp([v.year, v.month, v.day, v.hour, v.minute, v.second])
+          db.to_application_timestamp([v.year, v.month, v.day, v.hour, v.minute, v.second])
         when ::ODBC::Time
           Sequel::SQLTime.create(v.hour, v.minute, v.second)
         when ::ODBC::Date

data/lib/sequel/adapters/odbc/db2.rb

@@ -7,10 +7,6 @@ module Sequel
     module DB2
       module DatabaseMethods
         include ::Sequel::DB2::DatabaseMethods
-
-        def dataset(opts=nil)
-          Sequel::ODBC::DB2::Dataset.new(self, opts)
-        end
       end
       
       class Dataset < ODBC::Dataset

data/lib/sequel/adapters/odbc/mssql.rb

@@ -9,11 +9,6 @@ module Sequel
         include Sequel::MSSQL::DatabaseMethods
         LAST_INSERT_ID_SQL='SELECT SCOPE_IDENTITY()'
         
-        # Return an instance of Sequel::ODBC::MSSQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::ODBC::MSSQL::Dataset.new(self, opts)
-        end
-        
         # Return the last inserted identity value.
         def execute_insert(sql, opts={})
           synchronize(opts[:server]) do |conn|

data/lib/sequel/adapters/openbase.rb

@@ -15,10 +15,6 @@ module Sequel
         )
       end
       
-      def dataset(opts = nil)
-        OpenBase::Dataset.new(self, opts)
-      end
-    
       def execute(sql, opts={})
         synchronize(opts[:server]) do |conn|
           r = log_yield(sql){conn.execute(sql)}
@@ -37,6 +33,8 @@ module Sequel
     
     class Dataset < Sequel::Dataset
       SELECT_CLAUSE_METHODS = clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
+
+      Database::DatasetClass = self
       
       def fetch_rows(sql)
         execute(sql) do |result|

data/lib/sequel/adapters/oracle.rb

@@ -13,6 +13,18 @@ module Sequel
       # ORA-03114: not connected to ORACLE
       CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114 ]      
       
+      ORACLE_TYPES = {:blob=>lambda{|b| Sequel::SQL::Blob.new(b.read)}}
+
+      # Hash of conversion procs for this database.
+      attr_reader :conversion_procs
+
+      def initialize(opts={})
+        super
+        @autosequence = opts[:autosequence]
+        @primary_key_sequences = {}
+        @conversion_procs = ORACLE_TYPES.dup
+      end
+
       def connect(server)
         opts = server_opts(server)
         if opts[:database]
@@ -22,6 +34,7 @@ module Sequel
           dbname = opts[:host]
         end
         conn = OCI8.new(opts[:user], opts[:password], dbname, opts[:privilege])
+        conn.prefetch_rows = typecast_value_integer(opts[:prefetch_rows]) if opts[:prefetch_rows]
         conn.autocommit = true
         conn.non_blocking = true
         
@@ -36,59 +49,129 @@ module Sequel
           conn.exec("ALTER SESSION SET TIME_ZONE='-00:00'")
         end
         
+        class << conn
+          attr_reader :prepared_statements
+        end
+        conn.instance_variable_set(:@prepared_statements, {})
+        
         conn
       end
-      
-      def dataset(opts = nil)
-        Oracle::Dataset.new(self, opts)
+
+      def execute(sql, opts={}, &block)
+        _execute(nil, sql, opts, &block)
       end
+      alias do execute
 
-      def schema_parse_table(table, opts={})
-        ds = dataset
-        ds.identifier_output_method = :downcase
-        schema_and_table = "#{"#{quote_identifier(opts[:schema])}." if opts[:schema]}#{quote_identifier(table)}"
-        table_schema = []
-        metadata = transaction(opts){|conn| conn.describe_table(schema_and_table)}
-        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
+      def execute_insert(sql, opts={})
+        _execute(:insert, sql, opts)
       end
 
-      def execute(sql, opts={})
+      private
+
+      def _execute(type, sql, opts={}, &block)
         synchronize(opts[:server]) do |conn|
           begin
-            r = log_yield(sql){conn.exec(sql)}
-            yield(r) if block_given?
-            r
-          rescue OCIException => e
+            return execute_prepared_statement(conn, type, sql, opts, &block) if sql.is_a?(Symbol)
+            if args = opts[:arguments]
+              r = conn.parse(sql)
+              args = cursor_bind_params(conn, r, args)
+              nr = log_yield(sql, args){r.exec}
+              r = nr unless block_given?
+            else
+              r = log_yield(sql){conn.exec(sql)}
+            end
+            if block_given?
+              begin
+                yield(r)
+              ensure
+                r.close
+              end
+            elsif type == :insert
+              last_insert_id(conn, opts)
+            else
+              r
+            end
+          rescue OCIException, RuntimeError => e
+            # ruby-oci8 is naughty and raises strings in some places
             raise_error(e)
           end
         end
       end
-      alias_method :do, :execute
 
-      private
-      
+      PS_TYPES = {'string'.freeze=>String, 'integer'.freeze=>Integer, 'float'.freeze=>Float,
+        'decimal'.freeze=>Float, 'date'.freeze=>Time, 'datetime'.freeze=>Time,
+        'time'.freeze=>Time, 'boolean'.freeze=>String, 'blob'.freeze=>OCI8::BLOB}
+      def cursor_bind_params(conn, cursor, args)
+        cursor
+        i = 0
+        args.map do |arg, type|
+          i += 1
+          case arg
+          when true
+            arg = 'Y'
+          when false
+            arg = 'N'
+          when BigDecimal
+            arg = arg.to_f
+          when ::Sequel::SQL::Blob
+            raise Error, "Sequel's oracle adapter does not currently support using a blob in a bound variable"
+          end
+          if t = PS_TYPES[type]
+            cursor.bind_param(i, arg, t)
+          else
+            cursor.bind_param(i, arg, arg.class)
+          end
+          arg
+        end
+      end
+
+      def execute_prepared_statement(conn, type, name, opts)
+        ps = prepared_statements[name]
+        sql = ps.prepared_sql
+        if cursora = conn.prepared_statements[name]
+          cursor, cursor_sql = cursora
+          if cursor_sql != sql
+            cursor.close
+            cursor = nil
+          end
+        end
+        unless cursor
+          cursor = log_yield("Preparing #{name}: #{sql}"){conn.parse(sql)}
+          conn.prepared_statements[name] = [cursor, sql]
+        end
+        args = cursor_bind_params(conn, cursor, opts[:arguments])
+        r = log_yield("Executing #{name}", args){cursor.exec}
+        if block_given?
+          yield(cursor)
+        elsif type == :insert
+          last_insert_id(conn, opts)
+        else
+          r
+        end
+      end
+
+      def last_insert_id(conn, opts)
+        unless sequence = opts[:sequence]
+          if t = opts[:table]
+            sequence = sequence_for_table(t)
+          end
+        end
+        if sequence
+          sql = "SELECT #{literal(sequence)}.currval FROM dual"
+          begin
+            cursor = log_yield(sql){conn.exec(sql)}
+            row = cursor.fetch
+            row.each{|v| return (v.to_i if v)}
+          rescue OCIError
+            nil
+          ensure
+            cursor.close if cursor
+          end
+        end
+      end
+
       def begin_transaction(conn, opts={})
         log_yield(TRANSACTION_BEGIN){conn.autocommit = false}
-        conn
       end
       
       def commit_transaction(conn, opts={})
@@ -102,44 +185,239 @@ module Sequel
       end
 
       def disconnect_error?(e, opts)
-        super || (e.is_a?(::OCIException) && CONNECTION_ERROR_CODES.include?(e.code))
+        super || (e.is_a?(::OCIError) && CONNECTION_ERROR_CODES.include?(e.code))
       end
       
-      def remove_transaction(conn)
-        conn.autocommit = true if conn
+      def oracle_column_type(h)
+        case h[:oci8_type]
+        when :number
+          case h[:scale]
+          when 0
+            :integer
+          when -127
+            :float
+          else
+            :decimal
+          end
+        when :date
+          :datetime
+        else
+          schema_column_type(h[:db_type])
+        end
+      end
+
+      def remove_transaction(conn, committed)
+        conn.autocommit = true
+      ensure
         super
       end
       
       def rollback_transaction(conn, opts={})
         log_yield(TRANSACTION_ROLLBACK){conn.rollback}
       end
+
+      def schema_parse_table(table, opts={})
+        schema, table = schema_and_table(table)
+        schema ||= opts[:schema]
+        schema_and_table = if ds = opts[:dataset]
+          ds.literal(schema ? SQL::QualifiedIdentifier.new(schema, table) : SQL::Identifier.new(table))
+        else
+          "#{"#{quote_identifier(schema)}." if schema}#{quote_identifier(table)}"
+        end
+        table_schema = []
+        m = output_identifier_meth(ds)
+        im = input_identifier_meth(ds)
+
+        # Primary Keys
+        ds = metadata_dataset.from(:all_constraints___cons, :all_cons_columns___cols).
+          where(:cols__table_name=>im.call(table), :cons__constraint_type=>'P',
+                :cons__constraint_name=>:cols__constraint_name, :cons__owner=>:cols__owner)
+        ds = ds.where(:cons__owner=>im.call(schema)) if schema
+        pks = ds.select_map(:cols__column_name)
+
+        # Default values
+        defaults =  metadata_dataset.from(:dba_tab_cols).
+          where(:table_name=>im.call(table)).
+          to_hash(:column_name, :data_default)
+
+        metadata = synchronize(opts[:server]) do |conn|
+          begin
+          log_yield("Connection.describe_table"){conn.describe_table(schema_and_table)}
+          rescue OCIError => e
+            raise_error(e)
+          end
+        end
+        metadata.columns.each do |column|
+          h = {
+              :primary_key => pks.include?(column.name),
+              :default => defaults[column.name],
+              :oci8_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?
+          }
+          h[:type] = oracle_column_type(h)
+          table_schema << [m.call(column.name), h]
+        end
+        table_schema
+      end
     end
     
     class Dataset < Sequel::Dataset
       include DatasetMethods
 
+      Database::DatasetClass = self
+
+      PREPARED_ARG_PLACEHOLDER = ':'.freeze
+      
+      # Oracle already supports named bind arguments, so use directly.
+      module ArgumentMapper
+        include Sequel::Dataset::ArgumentMapper
+        
+        protected
+        
+        # Return a hash with the same values as the given hash,
+        # but with the keys converted to strings.
+        def map_to_prepared_args(bind_vars)
+          prepared_args.map{|v, t| [bind_vars[v], t]}
+        end
+        
+        private
+        
+        # Oracle uses a : before the name of the argument for named
+        # arguments.
+        def prepared_arg(k)
+          y, type = k.to_s.split("__", 2)
+          prepared_args << [y.to_sym, type]
+          i = prepared_args.length
+          LiteralString.new(":#{i}")
+        end
+
+        # Always assume a prepared argument.
+        def prepared_arg?(k)
+          true
+        end
+      end
+      
+      # Oracle prepared statement uses a new prepared statement each time
+      # it is called, but it does use the bind arguments.
+      module BindArgumentMethods
+        include ArgumentMapper
+
+        private
+        
+        # Run execute_select on the database with the given SQL and 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
+
+      module PreparedStatementMethods
+        include BindArgumentMethods
+          
+        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, bind_vars={}, *values, &block)
+        ps = to_prepared_statement(type, values)
+        ps.extend(BindArgumentMethods)
+        ps.call(bind_vars, &block)
+      end
+      
+      # Prepare the given type of query with the given name and store
+      # it in the database.  Note that a new native prepared statement is
+      # created on each call to this prepared statement.
+      def prepare(type, name=nil, *values)
+        ps = to_prepared_statement(type, values)
+        ps.extend(PreparedStatementMethods)
+        if name
+          ps.prepared_statement_name = name
+          db.prepared_statements[name] = ps
+        end
+        ps
+      end
+      
       def fetch_rows(sql)
         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
+          offset = @opts[:offset]
+          rn = row_number_column
+          cps = db.conversion_procs
+          cols = columns = cursor.get_col_names.map{|c| output_identifier(c)}
+          metadata = cursor.column_metadata
+          cm = cols.zip(metadata).map{|c, m| [c, cps[m.data_type]]}
+          columns = cols.reject{|x| x == rn} if offset
+          @columns = columns
+          while r = cursor.fetch
+            row = {}
+            r.zip(cm).each{|v, (c, cp)| row[c] = ((v && cp) ? cp.call(v) : v)}
+            row.delete(rn) if offset
+            yield row
           end
         end
         self
       end
 
+      # Create a named prepared statement that is stored in the
+      # database (and connection) for reuse.
+      def prepare(type, name=nil, *values)
+        ps = to_prepared_statement(type, values)
+        ps.extend(PreparedStatementMethods)
+        if name
+          ps.prepared_statement_name = name
+          db.prepared_statements[name] = ps
+        end
+        ps
+      end
+      
+      # Oracle requires type specifiers for placeholders, at least
+      # if you ever want to use a nil/NULL value as the value for
+      # the placeholder.
+      def requires_placeholder_type_specifiers?
+        true
+      end
+
       private
 
       def literal_other(v)
         case v
         when OraDate
-          literal(Sequel.database_to_application_timestamp(v))
+          literal(db.to_application_timestamp(v))
         when OCI8::CLOB
           v.rewind
           literal(v.read)
@@ -147,6 +425,10 @@ module Sequel
           super
         end
       end
+
+      def prepared_arg_placeholder
+        PREPARED_ARG_PLACEHOLDER
+      end
     end
   end
 end