sequel 2.11.0 → 2.12.0

data/lib/{sequel_core → sequel}/adapters/informix.rb

@@ -1,4 +1,4 @@
-require 'sequel_core/adapters/utils/unsupported'
+Sequel.require 'adapters/utils/unsupported'
 require 'informix'
 
 module Sequel

data/lib/{sequel_core → sequel}/adapters/jdbc.rb

@@ -1,5 +1,5 @@
 require 'java'
-require 'sequel_core/adapters/utils/stored_procedures'
+Sequel.require 'adapters/utils/stored_procedures'
 
 module Sequel
   # Houses Sequel's JDBC support when running on JRuby.
@@ -35,35 +35,35 @@ module Sequel
     # Contains procs keyed on sub adapter type that extend the
     # given database object so it supports the correct database type.
     DATABASE_SETUP = {:postgresql=>proc do |db|
-        require 'sequel_core/adapters/jdbc/postgresql'
+        Sequel.require 'adapters/jdbc/postgresql'
         db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
         JDBC.load_gem('postgres')
         org.postgresql.Driver
       end,
       :mysql=>proc do |db|
-        require 'sequel_core/adapters/jdbc/mysql'
+        Sequel.require 'adapters/jdbc/mysql'
         db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
         JDBC.load_gem('mysql')
         com.mysql.jdbc.Driver
       end,
       :sqlite=>proc do |db|
-        require 'sequel_core/adapters/jdbc/sqlite'
+        Sequel.require 'adapters/jdbc/sqlite'
         db.extend(Sequel::JDBC::SQLite::DatabaseMethods)
         JDBC.load_gem('sqlite3')
         org.sqlite.JDBC
       end,
       :oracle=>proc do |db|
-        require 'sequel_core/adapters/jdbc/oracle'
+        Sequel.require 'adapters/jdbc/oracle'
         db.extend(Sequel::JDBC::Oracle::DatabaseMethods)
         Java::oracle.jdbc.driver.OracleDriver
       end,
       :sqlserver=>proc do |db|
-        require 'sequel_core/adapters/shared/mssql'
+        Sequel.require 'adapters/shared/mssql'
         db.extend(Sequel::MSSQL::DatabaseMethods)
         com.microsoft.sqlserver.jdbc.SQLServerDriver
       end,
       :h2=>proc do |db|
-        require 'sequel_core/adapters/jdbc/h2'
+        Sequel.require 'adapters/jdbc/h2'
         db.extend(Sequel::JDBC::H2::DatabaseMethods)
         JDBC.load_gem('h2')
         org.h2.Driver
@@ -146,7 +146,7 @@ module Sequel
       # statement or something else that returns rows.
       def execute(sql, opts={}, &block)
         return call_sproc(sql, opts, &block) if opts[:sproc]
-        return execute_prepared_statement(sql, opts, &block) if sql.is_one_of?(Symbol, Dataset)
+        return execute_prepared_statement(sql, opts, &block) if [Symbol, Dataset].any?{|c| sql.is_a?(c)}
         log_info(sql)
         synchronize(opts[:server]) do |conn|
           stmt = conn.createStatement
@@ -196,8 +196,12 @@ module Sequel
       # Default transaction method that should work on most JDBC
       # databases.  Does not use the JDBC transaction methods, uses
       # SQL BEGIN/ROLLBACK/COMMIT statements instead.
-      def transaction(server=nil)
-        synchronize(server) do |conn|
+      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)
           stmt = conn.createStatement
           begin
@@ -334,7 +338,9 @@ module Sequel
       # and set it to an empty hash.  This is used to store
       # adapter specific prepared statements.
       def setup_connection(conn)
-        conn.meta_eval{attr_accessor :prepared_statements}
+        class << conn
+          attr_accessor :prepared_statements
+        end
         conn.prepared_statements = {}
         conn
       end
@@ -432,9 +438,9 @@ module Sequel
       def convert_type(v)
         case v
         when Java::JavaSQL::Timestamp, Java::JavaSQL::Time
-          v.to_string.to_sequel_time
+          Sequel.string_to_datetime(v.to_string)
         when Java::JavaSQL::Date
-          v.to_string.to_date
+          Sequel.string_to_date(v.to_string)
         when Java::JavaIo::BufferedReader
           lines = []
           while(line = v.read_line) do lines << line end
@@ -458,7 +464,7 @@ module Sequel
         meta = result.getMetaData
         column_count = meta.getColumnCount
         @columns = []
-        column_count.times{|i| @columns << output_identifier(meta.getColumnName(i+1))}
+        column_count.times{|i| @columns << output_identifier(meta.getColumnLabel(i+1))}
 
         # get rows
         while result.next
@@ -474,6 +480,7 @@ end
 class Java::JavaSQL::Timestamp
   # Add a usec method in order to emulate Time values.
   def usec
+    Deprecation.deprecate('Java::JavaSQL::Timestamp#usec', 'Use timestamp.getNanos/1000')
     getNanos/1000
   end
 end

data/lib/{sequel_core → sequel}/adapters/jdbc/h2.rb

@@ -1,4 +1,4 @@
-require 'sequel_core/adapters/utils/date_format'
+Sequel.require %w'date_format unsupported', 'adapters/utils'
 
 module Sequel
   module JDBC
@@ -6,6 +6,18 @@ module Sequel
     module H2
       # Instance methods for H2 Database objects accessed via JDBC.
       module DatabaseMethods
+        # Return Sequel::JDBC::H2::Dataset object with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::H2::Dataset.new(self, opts)
+        end
+        
+        # H2 uses an IDENTITY type
+        def serial_primary_key_options
+          {:primary_key => true, :type => :identity}
+        end
+        
+        private
+        
         # H2 needs to add a primary key column as a constraint
         def alter_table_sql(table, op)
           case op[:op]
@@ -21,18 +33,6 @@ module Sequel
           end
         end
       
-        # Return Sequel::JDBC::H2::Dataset object with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::H2::Dataset.new(self, opts)
-        end
-        
-        # H2 uses an IDENTITY type
-        def serial_primary_key_options
-          {:primary_key => true, :type => :identity}
-        end
-        
-        private
-        
         # Use IDENTITY() to get the last inserted id.
         def last_insert_id(conn, opts={})
           stmt = conn.createStatement
@@ -55,6 +55,7 @@ module Sequel
       # Dataset class for H2 datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Dataset::SQLStandardDateFormat
+        include Dataset::UnsupportedIsTrue
       end
     end
   end

data/lib/{sequel_core → sequel}/adapters/jdbc/mysql.rb

@@ -1,4 +1,4 @@
-require 'sequel_core/adapters/shared/mysql'
+Sequel.require 'adapters/shared/mysql'
 
 module Sequel
   module JDBC

data/lib/{sequel_core → sequel}/adapters/jdbc/oracle.rb

@@ -1,4 +1,4 @@
-require 'sequel_core/adapters/shared/oracle'
+Sequel.require 'adapters/shared/oracle'
 
 module Sequel
   module JDBC

data/lib/{sequel_core → sequel}/adapters/jdbc/postgresql.rb

@@ -1,4 +1,4 @@
-require 'sequel_core/adapters/shared/postgres'
+Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   Postgres::CONVERTED_EXCEPTIONS << NativeException

data/lib/{sequel_core → sequel}/adapters/jdbc/sqlite.rb

@@ -1,4 +1,4 @@
-require 'sequel_core/adapters/shared/sqlite'
+Sequel.require 'adapters/shared/sqlite'
 
 module Sequel
   module JDBC

data/lib/{sequel_core → sequel}/adapters/mysql.rb

@@ -1,40 +1,55 @@
 require 'mysql'
-require 'sequel_core/adapters/shared/mysql'
-require 'sequel_core/adapters/utils/stored_procedures'
+Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
 
 module Sequel
   # Module for holding all MySQL-related classes and modules for Sequel.
+  #
+  # A class level convert_invalid_date_time accessor exists if
+  # the native adapter is used.  If 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.  If is false by default, which means that
+  # invalid dates and times will raise errors.
   module MySQL
-    # Mapping of type numbers to conversion methods.
-    MYSQL_TYPES = {
-      0   => :to_d,     # MYSQL_TYPE_DECIMAL
-      1   => :to_i,     # MYSQL_TYPE_TINY
-      2   => :to_i,     # MYSQL_TYPE_SHORT
-      3   => :to_i,     # MYSQL_TYPE_LONG
-      4   => :to_f,     # MYSQL_TYPE_FLOAT
-      5   => :to_f,     # MYSQL_TYPE_DOUBLE
-      # 6   => ??,        # MYSQL_TYPE_NULL
-      7   => :to_sequel_time,  # MYSQL_TYPE_TIMESTAMP
-      8   => :to_i,     # MYSQL_TYPE_LONGLONG
-      9   => :to_i,     # MYSQL_TYPE_INT24
-      10  => :to_date,  # MYSQL_TYPE_DATE
-      11  => :to_time,  # MYSQL_TYPE_TIME
-      12  => :to_sequel_time,  # MYSQL_TYPE_DATETIME
-      13  => :to_i,     # MYSQL_TYPE_YEAR
-      14  => :to_date,  # MYSQL_TYPE_NEWDATE
-      # 15  => :to_s      # MYSQL_TYPE_VARCHAR
-      # 16  => :to_s,     # MYSQL_TYPE_BIT
-      246 => :to_d,     # MYSQL_TYPE_NEWDECIMAL
-      247 => :to_i,     # MYSQL_TYPE_ENUM
-      248 => :to_i,      # MYSQL_TYPE_SET
-      249 => :to_sequel_blob,     # MYSQL_TYPE_TINY_BLOB
-      250 => :to_sequel_blob,     # MYSQL_TYPE_MEDIUM_BLOB
-      251 => :to_sequel_blob,     # MYSQL_TYPE_LONG_BLOB
-      252 => :to_sequel_blob,     # MYSQL_TYPE_BLOB
-      # 253 => :to_s,     # MYSQL_TYPE_VAR_STRING
-      # 254 => :to_s,     # MYSQL_TYPE_STRING
-      # 255 => :to_s      # MYSQL_TYPE_GEOMETRY
+    # Mapping of type numbers to conversion procs
+    MYSQL_TYPES = {}
+
+    # Use only a single proc for each type to save on memory
+    MYSQL_TYPE_PROCS = {
+      [0, 246]  => lambda{|v| BigDecimal.new(v)},                       # decimal
+      [1, 2, 3, 8, 9, 13, 247, 248]  => lambda{|v| v.to_i},             # integer
+      [4, 5]  => lambda{|v| v.to_f},                                    # float
+      [10, 14]  => lambda{|v| convert_date_time(:string_to_date, v)},   # date
+      [7, 12] => lambda{|v| convert_date_time(:string_to_datetime, v)}, # datetime
+      [11]  => lambda{|v| convert_date_time(:string_to_time, v)},       # time
+      [249, 250, 251, 252]  => lambda{|v| Sequel::SQL::Blob.new(v)}     # blob
     }
+    MYSQL_TYPE_PROCS.each do |k,v|
+      k.each{|n| MYSQL_TYPES[n] = v}
+    end
+    
+    @convert_invalid_date_time = false
+
+    class << self
+      attr_accessor :convert_invalid_date_time
+    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 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
@@ -88,7 +103,9 @@ module Sequel
         conn.query("set SQL_AUTO_IS_NULL=0") unless opts[:auto_is_null]
 
         conn.query_with_result = false
-        conn.meta_eval{attr_accessor :prepared_statements}
+        class << conn
+          attr_accessor :prepared_statements
+        end
         conn.prepared_statements = {}
         conn.reconnect = true
         conn
@@ -117,8 +134,12 @@ module Sequel
       end
       
       # Support single level transactions on MySQL.
-      def transaction(server=nil)
-        synchronize(server) do |conn|
+      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.query(begin_transaction_sql)
@@ -276,8 +297,8 @@ module Sequel
       end
       
       # Delete rows matching this dataset
-      def delete(opts = nil)
-        execute_dui(delete_sql(opts)){|c| c.affected_rows}
+      def delete(opts = (defarg=true;nil))
+        execute_dui(defarg ? delete_sql : delete_sql(opts)){|c| c.affected_rows}
       end
       
       # Yield all rows matching this dataset
@@ -317,8 +338,8 @@ module Sequel
       end
       
       # Update the matching rows.
-      def update(*args)
-        execute_dui(update_sql(*args)){|c| c.affected_rows}
+      def update(values={}, opts=(defarg=true;nil))
+        execute_dui(defarg ? update_sql(values) : update_sql(values, opts)){|c| c.affected_rows}
       end
       
       private
@@ -331,7 +352,7 @@ module Sequel
             # a method to an ancestor of Fixnum
             v.to_i == 0 ? false : true
           else
-            (t = MYSQL_TYPES[type]) ? v.send(t) : v
+            (b = MYSQL_TYPES[type]) ? b.call(v) : v
           end
         else
           nil

data/lib/{sequel_core → sequel}/adapters/odbc.rb

@@ -12,10 +12,10 @@ module Sequel
         super(opts)
         case opts[:db_type]
         when 'mssql'
-          require 'sequel_core/adapters/shared/mssql'
+          Sequel.require 'adapters/shared/mssql'
           extend Sequel::MSSQL::DatabaseMethods
         when 'progress'
-          require 'sequel_core/adapters/shared/progress'
+          Sequel.require 'adapters/shared/progress'
           extend Sequel::Progress::DatabaseMethods
         end
       end
@@ -64,8 +64,12 @@ module Sequel
       alias_method :do, :execute_dui
 
       # Support single level transactions on ODBC
-      def transaction(server=nil)
-        synchronize(server) do |conn|
+      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)

data/lib/{sequel_core → sequel}/adapters/oracle.rb

@@ -1,5 +1,5 @@
 require 'oci8'
-require 'sequel_core/adapters/shared/oracle'
+Sequel.require 'adapters/shared/oracle'
 
 module Sequel
   module Oracle
@@ -30,7 +30,35 @@ module Sequel
       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|
@@ -47,19 +75,22 @@ module Sequel
           end
         end
       end
-      alias_method :do, :execute
+      alias do execute
       
-      def transaction(server=nil)
-        synchronize(server) do |conn|
+      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
+            raise e unless Rollback === e
           ensure
             conn.commit unless e
             conn.autocommit = true

data/lib/{sequel_core → sequel}/adapters/postgres.rb

@@ -1,4 +1,4 @@
-require 'sequel_core/adapters/shared/postgres'
+Sequel.require 'adapters/shared/postgres'
 
 begin 
   require 'pg' 
@@ -41,7 +41,7 @@ rescue LoadError => e
             def escape_bytea(obj)
               self.class.encode_bytea(obj)
             end
-            metaalias :unescape_bytea, :decode_bytea
+            instance_eval{alias unescape_bytea decode_bytea}
           rescue
             # If no valid bytea escaping method can be found, create one that
             # raises an error
@@ -83,31 +83,31 @@ module Sequel
     CONVERTED_EXCEPTIONS << PGError
     
     # Hash with integer keys and proc values for converting PostgreSQL types.
-    PG_TYPES = {
-      16 => lambda{ |s| s == 't' }, # boolean
-      17 => lambda{ |s| ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) }, # bytea
-      20 => lambda{ |s| s.to_i }, # int8
-      21 => lambda{ |s| s.to_i }, # int2
-      22 => lambda{ |s| s.to_i }, # int2vector
-      23 => lambda{ |s| s.to_i }, # int4
-      26 => lambda{ |s| s.to_i }, # oid
-      700 => lambda{ |s| s.to_f }, # float4
-      701 => lambda{ |s| s.to_f }, # float8
-      790 => lambda{ |s| s.to_d }, # money
-      1082 => lambda{ |s| @use_iso_date_format ? Date.new(*s.split("-").map{|x| x.to_i}) : s.to_date }, # date
-      1083 => lambda{ |s| s.to_time }, # time without time zone
-      1114 => lambda{ |s| s.to_sequel_time }, # timestamp without time zone
-      1184 => lambda{ |s| s.to_sequel_time }, # timestamp with time zone
-      1266 => lambda{ |s| s.to_time }, # time with time zone
-      1700 => lambda{ |s| s.to_d }, # numeric
+    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
 
-    # 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.
-    metaattr_accessor :use_iso_date_format
+    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.
@@ -195,7 +195,7 @@ module Sequel
       def connect(server)
         opts = server_opts(server)
         conn = Adapter.connect(
-          (opts[:host] unless opts[:host].blank?),
+          (opts[:host] unless blank_object?(opts[:host])),
           opts[:port] || 5432,
           nil, '',
           opts[:database],