sequel 3.21.0 → 3.28.0

data/lib/sequel/adapters/mysql2.rb

@@ -1,6 +1,5 @@
 require 'mysql2' unless defined? Mysql2
-
-Sequel.require %w'shared/mysql', 'adapters'
+Sequel.require %w'shared/mysql_prepared_statements', 'adapters'
 
 module Sequel
   # Module for holding all Mysql2-related classes and modules for Sequel.
@@ -8,6 +7,7 @@ module Sequel
     # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
+      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)/
@@ -21,7 +21,6 @@ module Sequel
       #   a filter for an autoincrement column equals NULL to return the last
       #   inserted row.
       # * :charset - Same as :encoding (:encoding takes precendence)
-      # * :compress - Set to false to not compress results from the server
       # * :config_default_group - The default group to read from the in
       #   the MySQL config file.
       # * :config_local_infile - If provided, sets the Mysql::OPT_LOCAL_INFILE
@@ -57,6 +56,7 @@ module Sequel
 
         sqls.each{|sql| log_yield(sql){conn.query(sql)}}
 
+        add_prepared_statements_cache(conn)
         conn
       end
 
@@ -65,16 +65,6 @@ module Sequel
         Mysql2::Dataset.new(self, opts)
       end
 
-      # Executes the given SQL using an available connection, yielding the
-      # connection if the block is given.
-      def execute(sql, opts={}, &block)
-        if opts[:sproc]
-          call_sproc(sql, opts, &block)
-        else
-          synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
-        end
-      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)
@@ -94,7 +84,7 @@ module Sequel
             yield conn
           end
         rescue ::Mysql2::Error => e
-          raise_error(e, :disconnect=>MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message))
+          raise_error(e)
         end
       end
 
@@ -108,6 +98,10 @@ module Sequel
         [::Mysql2::Error]
       end
 
+      def disconnect_error?(e, opts)
+        super || (e.is_a?(::Mysql2::Error) && MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message))
+      end
+
       # The database name when using the native adapter is always stored in
       # the :database option.
       def database_name
@@ -128,6 +122,7 @@ module Sequel
     # Dataset class for MySQL datasets accessed via the native driver.
     class Dataset < Sequel::Dataset
       include Sequel::MySQL::DatasetMethods
+      include Sequel::MySQL::PreparedStatements::DatasetMethods
 
       # Delete rows matching this dataset
       def delete

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

@@ -0,0 +1,21 @@
+Sequel.require 'adapters/shared/db2'
+
+module Sequel
+  module ODBC
+    # Database and Dataset instance methods for DB2 specific
+    # support via ODBC.
+    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
+        include ::Sequel::DB2::DatasetMethods
+      end
+    end
+  end
+end

data/lib/sequel/adapters/odbc.rb

@@ -15,9 +15,13 @@ module Sequel
         when 'mssql'
           Sequel.ts_require 'adapters/odbc/mssql'
           extend Sequel::ODBC::MSSQL::DatabaseMethods
+          set_mssql_unicode_strings
         when 'progress'
           Sequel.ts_require 'adapters/shared/progress'
           extend Sequel::Progress::DatabaseMethods
+        when 'db2'
+          Sequel.ts_require 'adapters/odbc/db2'
+          extend Sequel::ODBC::DB2::DatabaseMethods
         end
       end
 
@@ -51,7 +55,7 @@ module Sequel
             r = log_yield(sql){conn.run(sql)}
             yield(r) if block_given?
           rescue ::ODBC::Error, ArgumentError => e
-            raise_error(e, :disconnect=>DISCONNECT_ERRORS.match(e.message))
+            raise_error(e)
           ensure
             r.drop if r
           end
@@ -64,7 +68,7 @@ module Sequel
           begin
             log_yield(sql){conn.do(sql)}
           rescue ::ODBC::Error, ArgumentError => e
-            raise_error(e, :disconnect=>DISCONNECT_ERRORS.match(e.message))
+            raise_error(e)
           end
         end
       end
@@ -76,9 +80,17 @@ module Sequel
         :do
       end
 
+      def database_error_classes
+        [::ODBC::Error]
+      end
+
       def disconnect_connection(c)
         c.disconnect
       end
+
+      def disconnect_error?(e, opts)
+        super || (e.is_a?(::ODBC::Error) && DISCONNECT_ERRORS.match(e.message))
+      end
     end
     
     class Dataset < Sequel::Dataset
@@ -116,7 +128,7 @@ module Sequel
         when ::ODBC::TimeStamp
           Sequel.database_to_application_timestamp([v.year, v.month, v.day, v.hour, v.minute, v.second])
         when ::ODBC::Time
-          Sequel.database_to_application_timestamp([now.year, now.month, now.day, v.hour, v.minute, v.second])
+          Sequel::SQLTime.create(v.hour, v.minute, v.second)
         when ::ODBC::Date
           Date.new(v.year, v.month, v.day)
         else

data/lib/sequel/adapters/oracle.rb

@@ -24,6 +24,18 @@ module Sequel
         conn = OCI8.new(opts[:user], opts[:password], dbname, opts[:privilege])
         conn.autocommit = true
         conn.non_blocking = true
+        
+        # The ruby-oci8 gem which retrieves oracle columns with a type of
+        # DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE is complex based on the
+        # ruby version (1.9.2 or later) and Oracle version (9 or later)
+        # In the now standard case of 1.9.2 and Oracle 9 or later, the timezone
+        # is determined by the Oracle session timezone. Thus if the user
+        # requests Sequel provide UTC timezone to the application,
+        # we need to alter the session timezone to be UTC
+        if Sequel.application_timezone == :utc
+          conn.exec("ALTER SESSION SET TIME_ZONE='-00:00'")
+        end
+        
         conn
       end
       
@@ -66,7 +78,7 @@ module Sequel
             yield(r) if block_given?
             r
           rescue OCIException => e
-            raise_error(e, :disconnect=>CONNECTION_ERROR_CODES.include?(e.code))
+            raise_error(e)
           end
         end
       end
@@ -88,6 +100,10 @@ module Sequel
       rescue OCIInvalidHandle
         nil
       end
+
+      def disconnect_error?(e, opts)
+        super || (e.is_a?(::OCIException) && CONNECTION_ERROR_CODES.include?(e.code))
+      end
       
       def remove_transaction(conn)
         conn.autocommit = true if conn

data/lib/sequel/adapters/postgres.rb

@@ -93,13 +93,14 @@ module Sequel
       def bytea(s) ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) end
       def integer(s) s.to_i end
       def float(s) s.to_f end
-      def numeric(s) ::BigDecimal.new(s) end
-      def date(s) ::Sequel.string_to_date(s) end
-      def date_iso(s) ::Date.new(*s.split("-").map{|x| x.to_i}) end
-      def time(s) ::Sequel.string_to_time(s) end
-      def timestamp(s) ::Sequel.database_to_application_timestamp(s) end
+      def date(s) ::Date.new(*s.split("-").map{|x| x.to_i}) end
     end.new
 
+    # Hash with type name symbols and callable values for converting PostgreSQL types.
+    # Non-builtin types that don't have fixed numbers should use this to register
+    # conversion procs.
+    PG_NAMED_TYPES = {}
+
     # Hash with integer keys and callable values for converting PostgreSQL types.
     PG_TYPES = {}
     {
@@ -107,9 +108,9 @@ module Sequel
       [17] => tt.method(:bytea),
       [20, 21, 22, 23, 26] => tt.method(:integer),
       [700, 701] => tt.method(:float),
-      [790, 1700] => tt.method(:numeric),
-      [1083, 1266] => tt.method(:time),
-      [1114, 1184] => tt.method(:timestamp)
+      [790, 1700] => ::BigDecimal.method(:new),
+      [1083, 1266] => ::Sequel.method(:string_to_time),
+      [1114, 1184] => ::Sequel.method(:database_to_application_timestamp)
     }.each do |k,v|
       k.each{|n| PG_TYPES[n] = v}
     end
@@ -123,7 +124,7 @@ module Sequel
 
     # Modify the type translator for the date type depending on the value given.
     def self.use_iso_date_format=(v)
-      PG_TYPES[1082] = TYPE_TRANSLATOR.method(v ? :date_iso : :date)
+      PG_TYPES[1082] = v ? TYPE_TRANSLATOR.method(:date) : Sequel.method(:string_to_date)
       @use_iso_date_format = v
     end
     self.use_iso_date_format = true
@@ -131,7 +132,10 @@ module Sequel
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn
+      DISCONNECT_ERROR_RE = /\Acould not receive data from server: Software caused connection abort/
+      
       include Sequel::Postgres::AdapterMethods
+
       self.translate_results = false if respond_to?(:translate_results=)
       
       # Hash of prepared statements for this connection.  Keys are
@@ -150,20 +154,23 @@ module Sequel
         end
         @prepared_statements = {} if SEQUEL_POSTGRES_USES_PG
       end
-      
+
       # Raise a Sequel::DatabaseDisconnectError if a PGError is raised and
       # the connection status cannot be determined or it is not OK.
       def check_disconnect_errors
         begin
           yield
         rescue PGError =>e
+          disconnect = false
           begin
             s = status
           rescue PGError
-            raise Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)
+            disconnect = true
           end
           status_ok = (s == Adapter::CONNECTION_OK)
-          status_ok ? raise : raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError))
+          disconnect ||= !status_ok
+          disconnect ||= e.message =~ DISCONNECT_ERROR_RE
+          disconnect ? raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)) : raise
         ensure
           block if status_ok
         end
@@ -176,7 +183,7 @@ module Sequel
         begin
           block_given? ? yield(q) : q.cmd_tuples
         ensure
-          q.clear
+          q.clear if q
         end
       end
 
@@ -194,6 +201,10 @@ module Sequel
       include Sequel::Postgres::DatabaseMethods
       
       set_adapter_scheme :postgres
+
+      # 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
       
       # Add the primary_keys and primary_key_sequences instance variables,
       # so we can get the correct return values for inserted rows.
@@ -225,9 +236,74 @@ module Sequel
         end
         conn.db = self
         conn.apply_connection_settings
+        @conversion_procs ||= get_conversion_procs(conn)
         conn
       end
       
+      if SEQUEL_POSTGRES_USES_PG
+        # +copy_table+ uses PostgreSQL's +COPY+ SQL statement to return formatted
+        # results directly to the caller.  This method is only support if pg is the
+        # underlying ruby driver.  This method should only be called if you want
+        # results returned to the client.  If you are using +COPY FROM+ or +COPY TO+
+        # with a filename, you should just use +run+ instead of this method.  This
+        # method does not currently support +COPY FROM STDIN+, but that may be supported
+        # in the future.
+        #
+        # The table argument supports the following types:
+        #
+        # String :: Uses the first argument directly as literal SQL. If you are using
+        #           a version of PostgreSQL before 9.0, you will probably want to
+        #           use a string if you are using any options at all, as the syntax
+        #           Sequel uses for options is only compatible with PostgreSQL 9.0+.
+        # Dataset :: Uses a query instead of a table name when copying.
+        # other :: Uses a table name (usually a symbol) when copying.
+        # 
+        # The following options are respected:
+        #
+        # :format :: The format to use.  text is the default, so this should be :csv or :binary.
+        # :options :: An options SQL string to use, which should contain comma separated options.
+        # :server :: The server on which to run the query.
+        #
+        # If a block is provided, the method continually yields to the block, one yield
+        # per row.  If a block is not provided, a single string is returned with all
+        # of the data.
+        def copy_table(table, opts={})
+          sql = if table.is_a?(String)
+            sql = table
+          else
+            if opts[:options] || opts[:format]
+              options = " ("
+              options << "FORMAT #{opts[:format]}" if opts[:format]
+              options << "#{', ' if opts[:format]}#{opts[:options]}" if opts[:options]
+              options << ')'
+            end
+            table = if table.is_a?(::Sequel::Dataset)
+              "(#{table.sql})"
+            else
+              literal(table)
+            end
+           sql = "COPY #{table} TO STDOUT#{options}"
+          end
+          synchronize(opts[:server]) do |conn| 
+            conn.execute(sql)
+            begin
+              if block_given?
+                while buf = conn.get_copy_data
+                  yield buf
+                end
+                nil
+              else
+                b = ''
+                b << buf while buf = conn.get_copy_data
+                b
+              end
+            ensure
+              raise DatabaseDisconnectError, "disconnecting as a partial COPY may leave the connection in an unusable state" if buf
+            end
+          end 
+        end
+      end
+        
       # Return instance of Sequel::Postgres::Dataset with the given options.
       def dataset(opts = nil)
         Postgres::Dataset.new(self, opts)
@@ -305,6 +381,19 @@ module Sequel
           end
         end
       end
+
+      # Return the conversion procs hash to use for this database
+      def get_conversion_procs(conn)
+        procs = PG_TYPES.dup
+        conn.execute("SELECT oid, typname FROM pg_type where typtype = 'b'") do |res|
+          res.ntuples.times do |recnum|
+            if pr = PG_NAMED_TYPES[res.getvalue(recnum, 1).to_sym]
+              procs[res.getvalue(recnum, 0).to_i] ||= pr
+            end
+          end
+        end
+        procs
+      end
     end
     
     # Dataset class for PostgreSQL datasets that use the pg, postgres, or
@@ -372,11 +461,17 @@ module Sequel
             end
             LiteralString.new("#{prepared_arg_placeholder}#{i}#{"::#{type}" if type}")
           end
+
+          # Always assume a prepared argument.
+          def prepared_arg?(k)
+           true
+          end
         end
 
         # Allow use of bind arguments for PostgreSQL using the pg driver.
         module BindArgumentMethods
           include ArgumentMapper
+          include ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods
           
           private
           
@@ -400,7 +495,6 @@ module Sequel
         # pg driver.
         module PreparedStatementMethods
           include BindArgumentMethods
-          include ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods
           
           private
           
@@ -427,7 +521,7 @@ module Sequel
           ps.extend(BindArgumentMethods)
           ps.call(bind_vars, &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)
@@ -483,8 +577,9 @@ module Sequel
       # field numers, type conversion procs, and name symbol arrays.
       def fetch_rows_set_cols(res)
         cols = []
+        procs = db.conversion_procs
         res.nfields.times do |fieldnum|
-          cols << [fieldnum, PG_TYPES[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
+          cols << [fieldnum, procs[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
         end
         @columns = cols.map{|c| c.at(2)}
         cols

data/lib/sequel/adapters/shared/access.rb

@@ -1,6 +1,7 @@
 module Sequel
   module Access
     module DatabaseMethods
+      # Access uses type :access as the database_type
       def database_type
         :access
       end
@@ -16,6 +17,7 @@ module Sequel
         from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map{|x| x.to_sym}
       end
 
+      # Access uses type Counter for an autoincrementing keys
       def serial_primary_key_options
         {:primary_key => true, :type=>:Counter}
       end
@@ -34,16 +36,35 @@ module Sequel
     module DatasetMethods
       SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'limit distinct columns from join where group order having compounds')
 
+      # Access doesn't support INTERSECT or EXCEPT
       def supports_intersect_except?
         false
       end
 
       private
 
+      # Access uses # to quote dates
+      def literal_date(d)
+        d.strftime('#%Y-%m-%d#')
+      end
+
+      # Access uses # to quote datetimes
+      def literal_datetime(t)
+        t.strftime('#%Y-%m-%d %H:%M:%S#')
+      end
+      alias literal_time literal_datetime
+
+      # Access uses TOP for limits
+      def select_limit_sql(sql)
+        sql << " TOP #{@opts[:limit]}" if @opts[:limit]
+      end
+
+      # Access uses [] for quoting identifiers
       def quoted_identifier(v)
         "[#{v}]"
       end
 
+      # Access requires the limit clause come before other clauses
       def select_clause_methods
         SELECT_CLAUSE_METHODS
       end