sequel 3.10.0 → 3.11.0

data/lib/sequel/adapters/dbi.rb

@@ -26,6 +26,11 @@ module Sequel
         when 'mssql'
           Sequel.ts_require 'adapters/shared/mssql'
           extend Sequel::MSSQL::DatabaseMethods
+          def self.dataset(*args)
+            ds = super
+            ds.extend Sequel::MSSQL::DatasetMethods
+            ds
+          end
         end
       end
 
@@ -63,17 +68,15 @@ module Sequel
       end
     
       def execute(sql, opts={})
-        log_info(sql)
         synchronize(opts[:server]) do |conn|
-          r = conn.execute(sql)
+          r = log_yield(sql){conn.execute(sql)}
           yield(r) if block_given?
           r
         end
       end
       
       def do(sql, opts={})
-        log_info(sql)
-        synchronize(opts[:server]){|conn| conn.do(sql)}
+        synchronize(opts[:server]){|conn| log_yield(sql){conn.do(sql)}}
       end
       alias_method :execute_dui, :do
 

data/lib/sequel/adapters/do.rb

@@ -66,11 +66,10 @@ module Sequel
       # Otherwise, the return value is the insert id if opts[:type] is :insert,
       # or the number of affected rows, otherwise.
       def execute(sql, opts={})
-        log_info(sql)
         synchronize(opts[:server]) do |conn|
           begin
             command = conn.create_command(sql)
-            res = block_given? ? command.execute_reader : command.execute_non_query
+            res = log_yield(sql){block_given? ? command.execute_reader : command.execute_non_query}
           rescue ::DataObjects::Error => e
             raise_error(e)
           end
@@ -121,21 +120,23 @@ module Sequel
       # substitute our own.
       def begin_transaction(conn)
         return super if supports_savepoints?
-        log_info(TRANSACTION_BEGIN)
-        t = ::DataObjects::Transaction.create_for_uri(uri)
-        t.instance_variable_get(:@connection).close
-        t.instance_variable_set(:@connection, conn)
-        t.begin
-        t
+        log_yield(TRANSACTION_BEGIN) do
+          t = ::DataObjects::Transaction.create_for_uri(uri)
+          t.instance_variable_get(:@connection).close
+          t.instance_variable_set(:@connection, conn)
+          t.begin
+          t
+        end
       end
       
       # DataObjects requires transactions be prepared before being
       # committed, so we do that.
       def commit_transaction(t)
         return super if supports_savepoints?
-        log_info(TRANSACTION_ROLLBACK)
-        t.prepare
-        t.commit 
+        log_yield(TRANSACTION_ROLLBACK) do
+          t.prepare
+          t.commit 
+        end
       end
       
       # Method to call on a statement object to execute SQL that does
@@ -151,15 +152,13 @@ module Sequel
       
       # Execute SQL on the connection by creating a command first
       def log_connection_execute(conn, sql)
-        log_info(sql)
-        conn.create_command(sql).execute_non_query
+        log_yield(sql){conn.create_command(sql).execute_non_query}
       end
       
       # We use the transactions rollback method to rollback.
       def rollback_transaction(t)
         return super if supports_savepoints?
-        log_info(TRANSACTION_COMMIT)
-        t.rollback
+        log_yield(TRANSACTION_COMMIT){t.rollback}
       end
       
       # Allow extending the given connection when it is first created.

data/lib/sequel/adapters/do/postgres.rb

@@ -19,13 +19,12 @@ module Sequel
           begin
             if block_given?
               begin
-                reader = command.execute_reader
-                yield(reader)
+                yield(reader = @db.log_yield(sql){command.execute_reader})
               ensure
                 reader.close if reader
               end
             else
-              command.execute_non_query
+              @db.log_yield(sql){command.execute_non_query}
             end
           rescue ::DataObjects::Error => e
             raise_error(e)
@@ -64,9 +63,9 @@ module Sequel
         # Run the INSERT sql on the database and return the primary key
         # for the record.
         def execute_insert(sql, opts={})
-          log_info(sql)
           synchronize(opts[:server]) do |conn|
-            conn.create_command(sql).execute_non_query
+            com = conn.create_command(sql)
+            log_yield(sql){com.execute_non_query}
             insert_result(conn, opts[:table], opts[:values])
           end
         end

data/lib/sequel/adapters/do/sqlite.rb

@@ -20,6 +20,15 @@ module Sequel
           o = super
           uri == 'sqlite3::memory:' ? o.merge(:max_connections=>1) : o
         end
+        
+        # Execute the connection pragmas on the connection
+        def setup_connection(conn)
+          connection_pragmas.each do |s|
+            com = conn.create_command(s)
+            log_yield(s){com.execute_non_query}
+          end
+          super
+        end
       end
       
       # Dataset class for SQLite datasets accessed via DataObjects.

data/lib/sequel/adapters/firebird.rb

@@ -43,15 +43,13 @@ module Sequel
       end
 
       def execute(sql, opts={})
-        log_info(sql)
         begin
           synchronize(opts[:server]) do |conn|
-            r = conn.execute(sql)
+            r = log_yield(sql){conn.execute(sql)}
             yield(r) if block_given?
             r
           end
         rescue => e
-          log_info(e.message)
           raise_error(e, :classes=>[Fb::Error])
         end
       end
@@ -105,14 +103,12 @@ module Sequel
       end
       
       def begin_transaction(conn)
-        log_info(TRANSACTION_BEGIN)
-        conn.transaction
+        log_yield(TRANSACTION_BEGIN){conn.transaction}
         conn
       end
 
       def commit_transaction(conn)
-        log_info(TRANSACTION_COMMIT)
-        conn.commit
+        log_yield(TRANSACTION_COMMIT){conn.commit}
       end
       
       def create_sequence_sql(name, opts={})
@@ -160,7 +156,7 @@ module Sequel
         events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
         whence = opts[:after] ? 'AFTER' : 'BEFORE'
         inactive = opts[:inactive] ? 'INACTIVE' : 'ACTIVE'
-        position = opts[:position] ? opts[:position] : 0
+        position = opts.fetch(:position, 0)
         sql = <<-end_sql
           CREATE TRIGGER #{quote_identifier(name)} for #{quote_identifier(table)}
           #{inactive} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} position #{position}
@@ -187,8 +183,7 @@ module Sequel
       end
       
       def rollback_transaction(conn)
-        log_info(TRANSACTION_ROLLBACK)
-        conn.rollback
+        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
       end
 
       def type_literal_generic_string(column)

data/lib/sequel/adapters/informix.rb

@@ -18,14 +18,12 @@ module Sequel
       
       # Returns number of rows affected
       def execute_dui(sql, opts={})
-        log_info(sql)
-        synchronize(opts[:server]){|c| c.immediate(sql)}
+        synchronize(opts[:server]){|c| log_yield(sql){c.immediate(sql)}}
       end
       alias_method :do, :execute_dui
       
       def execute(sql, opts={})
-        log_info(sql)
-        synchronize(opts[:server]){|c| yield c.cursor(sql)}
+        synchronize(opts[:server]){|c| yield log_yield(sql){c.cursor(sql)}}
       end
       alias_method :query, :execute
       

data/lib/sequel/adapters/jdbc.rb

@@ -3,24 +3,6 @@ Sequel.require 'adapters/utils/stored_procedures'
 
 module Sequel
   # Houses Sequel's JDBC support when running on JRuby.
-  # Support for individual database types is done using sub adapters.
-  # PostgreSQL, MySQL, SQLite, Oracle, and MSSQL all have relatively good support,
-  # close the the level supported by the native adapter.
-  # PostgreSQL, MySQL, SQLite can load necessary support using
-  # the jdbc-* gem, if it is installed, though they will work if you
-  # have the correct .jar in your CLASSPATH.  Oracle and MSSQL should
-  # load the necessary support if you have the .jar in your CLASSPATH.
-  # For all other databases, the Java class should be loaded manually
-  # before calling Sequel.connect.
-  #
-  # Note that when using a JDBC adapter, the best way to use Sequel
-  # is via Sequel.connect, NOT Sequel.jdbc.  Use the JDBC connection
-  # string when connecting, which will be in a different format than
-  # the native connection string.  The connection string should start
-  # with 'jdbc:'.  For PostgreSQL, use 'jdbc:postgresql:', and for
-  # SQLite you do not need 2 preceding slashes for the database name
-  # (use no preceding slashes for a relative path, and one preceding
-  # slash for an absolute path).
   module JDBC
     # Make it accesing the java.lang hierarchy more ruby friendly.
     module JavaLang
@@ -31,6 +13,19 @@ module Sequel
     module JavaSQL
       include_package 'java.sql'
     end
+
+    # Make it accesing the javax.naming hierarchy more ruby friendly.
+    module JavaxNaming
+      include_package 'javax.naming'
+    end
+
+    # Used to identify a jndi connection and to extract the jndi
+    # resource name.
+    JNDI_URI_REGEXP = /\Ajdbc:jndi:(.+)/
+    
+    # The types to check for 0 scale to transform :decimal types
+    # to :integer.
+    DECIMAL_TYPE_RE = /number|numeric|decimal/io
     
     # Contains procs keyed on sub adapter type that extend the
     # given database object so it supports the correct database type.
@@ -62,6 +57,12 @@ module Sequel
         db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
         com.microsoft.sqlserver.jdbc.SQLServerDriver
       end,
+      :jtds=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/mssql'
+        db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
+        JDBC.load_gem('jtds')
+        Java::net.sourceforge.jtds.jdbc.Driver
+      end,
       :h2=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/h2'
         db.extend(Sequel::JDBC::H2::DatabaseMethods)
@@ -93,6 +94,9 @@ module Sequel
       # The type of database we are connecting to
       attr_reader :database_type
       
+      # The Java database driver we are using
+      attr_reader :driver
+      
       # Whether to convert some Java types to ruby types when retrieving rows.
       # True by default, can be set to false to roughly double performance when
       # fetching rows.
@@ -104,11 +108,14 @@ module Sequel
       # uri, since JDBC requires one.
       def initialize(opts)
         super
-        @convert_types = @opts.include?(:convert_types) ? typecast_value_boolean(@opts[:convert_types]) : true
+        @convert_types = typecast_value_boolean(@opts.fetch(:convert_types, true))
         raise(Error, "No connection string specified") unless uri
-        if match = /\Ajdbc:([^:]+)/.match(uri) and prok = DATABASE_SETUP[match[1].to_sym]
-          prok.call(self)
-        end
+        
+        resolved_uri = jndi? ? get_uri_from_jndi : uri
+
+        if match = /\Ajdbc:([^:]+)/.match(resolved_uri) and prok = DATABASE_SETUP[match[1].to_sym]
+          @driver = prok.call(self)
+        end        
       end
       
       # Execute the given stored procedure with the give name. If a block is
@@ -124,14 +131,14 @@ module Sequel
 
           begin
             if block_given?
-              yield cps.executeQuery
+              yield log_yield(sql){cps.executeQuery}
             else
               case opts[:type]
               when :insert
-                cps.executeUpdate
+                log_yield(sql){cps.executeUpdate}
                 last_insert_id(conn, opts)
               else
-                cps.executeUpdate
+                log_yield(sql){cps.executeUpdate}
               end
             end
           rescue NativeException, JavaSQL::SQLException => e
@@ -141,12 +148,29 @@ module Sequel
           end
         end
       end
-      
+         
       # Connect to the database using JavaSQL::DriverManager.getConnection.
       def connect(server)
-        args = [uri(server_opts(server))]
-        args.concat([opts[:user], opts[:password]]) if opts[:user] && opts[:password]
-        setup_connection(JavaSQL::DriverManager.getConnection(*args))
+        opts = server_opts(server)
+        conn = if jndi?
+          get_connection_from_jndi
+        else
+          args = [uri(opts)]
+          args.concat([opts[:user], opts[:password]]) if opts[:user] && opts[:password]
+          begin
+            JavaSQL::DriverManager.getConnection(*args)
+          rescue
+            # If the DriverManager can't get the connection - use the connect
+            # method of the driver. (This happens under Tomcat for instance)
+            props = java.util.Properties.new
+            if opts && opts[:user] && opts[:password]
+              props.setProperty("user", opts[:user])
+              props.setProperty("password", opts[:password])
+            end
+            driver.new.connect(args[0], props)
+          end
+        end
+        setup_connection(conn)
       end
       
       # Return instances of JDBC::Dataset with the given opts.
@@ -159,21 +183,26 @@ module Sequel
       def execute(sql, opts={}, &block)
         return call_sproc(sql, opts, &block) if opts[:sproc]
         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
           begin
             if block_given?
-              yield stmt.executeQuery(sql)
+              yield log_yield(sql){stmt.executeQuery(sql)}
             else
               case opts[:type]
               when :ddl
-                stmt.execute(sql)
+                log_yield(sql){stmt.execute(sql)}
               when :insert
-                stmt.executeUpdate(sql)
+                log_yield(sql) do
+                  if requires_return_generated_keys?
+                    stmt.executeUpdate(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS)
+                  else
+                    stmt.executeUpdate(sql)
+                  end
+                end
                 last_insert_id(conn, opts.merge(:stmt=>stmt))
               else
-                stmt.executeUpdate(sql)
+                log_yield(sql){stmt.executeUpdate(sql)}
               end
             end
           rescue NativeException, JavaSQL::SQLException => e
@@ -235,9 +264,14 @@ module Sequel
         ur = opts[:uri] || opts[:url] || opts[:database]
         ur =~ /^\Ajdbc:/ ? ur : "jdbc:#{ur}"
       end
+
+      # Whether or not JNDI is being used for this connection.
+      def jndi?
+        !!(uri =~ JNDI_URI_REGEXP)
+      end
       
       private
-      
+         
       # JDBC uses a statement object to execute SQL on the database
       def begin_transaction(conn)
         conn = conn.createStatement unless supports_savepoints?
@@ -269,29 +303,25 @@ module Sequel
           if name and cps = conn.prepared_statements[name] and cps[0] == sql
             cps = cps[1]
           else
-            if cps
-              log_info("Closing #{name}")
-              cps[1].close
-            end
-            log_info("Preparing#{" #{name}:" if name} #{sql}")
-            cps = conn.prepareStatement(sql)
+            log_yield("Closing #{name}"){cps[1].close} if cps
+            cps = log_yield("Preparing#{" #{name}:" if name} #{sql}"){conn.prepareStatement(sql)}
             conn.prepared_statements[name] = [sql, cps] if name
           end
           i = 0
           args.each{|arg| set_ps_arg(cps, arg, i+=1)}
-          log_info("Executing#{" #{name}" if name}", args)
+          msg = "Executing#{" #{name}" if name}"
           begin
             if block_given?
-              yield cps.executeQuery
+              yield log_yield(msg, args){cps.executeQuery}
             else
               case opts[:type]
               when :ddl
-                cps.execute
+                log_yield(msg, args){cps.execute}
               when :insert
-                cps.executeUpdate
+                log_yield(msg, args){cps.executeUpdate}
                 last_insert_id(conn, opts.merge(:prepared=>true))
               else
-                cps.executeUpdate
+                log_yield(msg, args){cps.executeUpdate}
               end
             end
           rescue NativeException, JavaSQL::SQLException => e
@@ -301,7 +331,21 @@ module Sequel
           end
         end
       end
+
+      # Gets the JDBC connection uri from the JNDI resource.
+      def get_uri_from_jndi
+        conn = get_connection_from_jndi
+        conn.meta_data.url
+      ensure
+        conn.close if conn
+      end
       
+      # Gets the connection from JNDI.
+      def get_connection_from_jndi
+        jndi_name = JNDI_URI_REGEXP.match(uri)[1]
+        JavaxNaming::InitialContext.new.lookup(jndi_name).connection
+      end
+            
       # Support fractional seconds for Time objects used in bound variables
       def java_sql_timestamp(time)
         millis = time.to_i * 1000
@@ -319,7 +363,14 @@ module Sequel
       
       # Yield the metadata for this database
       def metadata(*args, &block)
-        synchronize{|c| metadata_dataset.send(:process_result_set, c.getMetaData.send(*args), &block)}
+        synchronize do |c|
+          result = c.getMetaData.send(*args)
+          begin
+            metadata_dataset.send(:process_result_set, result, &block)
+          ensure
+            result.close
+          end
+        end
       end
 
       # Treat SQLExceptions with a "Connection Error" SQLState as disconnects
@@ -388,7 +439,11 @@ module Sequel
           pks << h[:column_name]
         end
         metadata(:getColumns, nil, schema, table, nil) do |h|
-          ts << [m.call(h[:column_name]), {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name]), :column_size=>h[:column_size]}]
+          s = {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name]), :column_size=>h[:column_size], :scale=>h[:decimal_digits]}
+          if s[:db_type] =~ DECIMAL_TYPE_RE && s[:scale] == 0
+            s[:type] = :integer
+          end
+          ts << [m.call(h[:column_name]), s]
         end
         ts
       end
@@ -397,6 +452,13 @@ module Sequel
       def transaction_statement_object(conn)
         conn.createStatement
       end
+
+      # This method determines whether or not to add
+      # Statement.RETURN_GENERATED_KEYS as an argument when inserting rows.
+      # Sub-adapters that require this should override this method.
+      def requires_return_generated_keys?
+        false
+      end
     end
     
     class Dataset < Sequel::Dataset
@@ -498,7 +560,7 @@ module Sequel
         when Java::byte[]
           Sequel::SQL::Blob.new(String.from_java_bytes(v))
         when Java::JavaSQL::Blob
-          convert_type(v.getBytes(0, v.length))
+          convert_type(v.getBytes(1, v.length))
         else
           v
         end