sequel 2.3.0 → 2.4.0

data/lib/sequel_core/adapters/dbi.rb

@@ -41,13 +41,14 @@ module Sequel
 
       private_class_method :uri_to_options
       
-      def connect
-        dbname = @opts[:database]
+      def connect(server)
+        opts = server_opts(server)
+        dbname = opts[:database]
         if dbname !~ /^DBI:/ then
           dbname = "DBI:#{dbname}"
-          [:host, :port].each{|sym| dbname += ";#{sym}=#{@opts[sym]}" unless @opts[sym].blank?}
+          [:host, :port].each{|sym| dbname += ";#{sym}=#{opts[sym]}" unless opts[sym].blank?}
         end
-        ::DBI.connect(dbname, @opts[:user], @opts[:password])
+        ::DBI.connect(dbname, opts[:user], opts[:password])
       end
       
       def disconnect
@@ -58,18 +59,18 @@ module Sequel
         DBI::Dataset.new(self, opts)
       end
     
-      def execute(sql)
+      def execute(sql, opts={})
         log_info(sql)
-        @pool.hold do |conn|
-          conn.execute(sql)
+        synchronize(opts[:server]) do |conn|
+          r = conn.execute(sql)
+          yield(r) if block_given?
+          r
         end
       end
       
-      def do(sql)
+      def do(sql, opts={})
         log_info(sql)
-        @pool.hold do |conn|
-          conn.do(sql)
-        end
+        synchronize(opts[:server]){|conn| conn.do(sql)}
       end
       alias_method :execute_dui, :do
       
@@ -92,8 +93,7 @@ module Sequel
       end
 
       def fetch_rows(sql, &block)
-        @db.synchronize do
-          s = @db.execute sql
+        execute(sql) do |s|
           begin
             @columns = s.column_names.map do |c|
               @db.lowercase ? c.downcase.to_sym : c.to_sym
@@ -106,6 +106,8 @@ module Sequel
         self
       end
       
+      private
+      
       def hash_row(stmt, row)
         @columns.inject({}) do |m, c|
           m[c] = row.shift

data/lib/sequel_core/adapters/informix.rb

@@ -11,12 +11,13 @@ module Sequel
       #   AUTO_INCREMENT
       # end
       
-      def connect
-        ::Informix.connect(@opts[:database], @opts[:user], @opts[:password])
+      def connect(server)
+        opts = server_opts(server)
+        ::Informix.connect(opts[:database], opts[:user], opts[:password])
       end
       
       def disconnect
-        @pool.disconnect {|c| c.close}
+        @pool.disconnect{|c| c.close}
       end
     
       def dataset(opts = nil)
@@ -24,15 +25,15 @@ module Sequel
       end
       
       # Returns number of rows affected
-      def execute_dui(sql)
+      def execute_dui(sql, opts={})
         log_info(sql)
-        @pool.hold {|c| c.immediate(sql)}
+        synchronize(opts[:server]){|c| c.immediate(sql)}
       end
       alias_method :do, :execute_dui
       
-      def execute(sql, &block)
+      def execute(sql, opts={})
         log_info(sql)
-        @pool.hold {|c| block[c.cursor(sql)]}
+        synchronize(opts[:server]){|c| yield c.cursor(sql)}
       end
       alias_method :query, :execute
     end
@@ -62,13 +63,11 @@ module Sequel
       end
       
       def fetch_rows(sql, &block)
-        @db.synchronize do
-          @db.execute(sql) do |cursor|
-            begin
-              cursor.open.each_hash(&block)
-            ensure
-              cursor.drop
-            end
+        execute(sql) do |cursor|
+          begin
+            cursor.open.each_hash(&block)
+          ensure
+            cursor.drop
           end
         end
         self

data/lib/sequel_core/adapters/jdbc.rb

@@ -1,9 +1,38 @@
 require 'java'
 
 module Sequel
+  # Houses Sequel's JDBC support when running on JRuby.
+  # Support for individual database types is done using sub adapters.
+  # PostgreSQL, MySQL, SQLite, 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
-    module JavaLang; include_package 'java.lang'; end
-    module JavaSQL; include_package 'java.sql'; end
+    # Make it accesing the java.lang hierarchy more ruby friendly.
+    module JavaLang
+      include_package 'java.lang'
+    end
+    
+    # Make it accesing the java.sql hierarchy more ruby friendly.
+    module JavaSQL
+      include_package 'java.sql'
+    end
+    
+    # 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'
         db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
@@ -23,9 +52,15 @@ module Sequel
         org.sqlite.JDBC
       end,
       :oracle=>proc{oracle.jdbc.driver.OracleDriver},
-      :sqlserver=>proc{com.microsoft.sqlserver.jdbc.SQLServerDriver}
+      :sqlserver=>proc do |db|
+        require 'sequel_core/adapters/shared/mssql'
+        db.extend(Sequel::MSSQL::DatabaseMethods)
+        com.microsoft.sqlserver.jdbc.SQLServerDriver
+      end
     }
     
+    # Allowing loading the necessary JDBC support via a gem, which
+    # works for PostgreSQL, MySQL, and SQLite.
     def self.load_gem(name)
       begin
         require "jdbc/#{name}"
@@ -34,12 +69,18 @@ module Sequel
       end
     end
 
+    # JDBC Databases offer a fairly uniform interface that does not change
+    # much based on the sub adapter.
     class Database < Sequel::Database
       set_adapter_scheme :jdbc
       
       # The type of database we are connecting to
       attr_reader :database_type
       
+      # Call the DATABASE_SETUP proc directly after initialization,
+      # so the object always uses sub adapter specific code.  Also,
+      # raise an error immediately if the connection doesn't have a
+      # uri, since JDBC requires one.
       def initialize(opts)
         super(opts)
         raise(Error, "No connection string specified") unless uri
@@ -48,38 +89,42 @@ module Sequel
         end
       end
       
-      def connect
-        setup_connection(JavaSQL::DriverManager.getConnection(uri))
+      # Connect to the database using JavaSQL::DriverManager.getConnection.
+      def connect(server)
+        setup_connection(JavaSQL::DriverManager.getConnection(uri(server_opts(server))))
       end
       
+      # Return instances of JDBC::Dataset with the given opts.
       def dataset(opts = nil)
         JDBC::Dataset.new(self, opts)
       end
       
+      # Close all adapter connections
       def disconnect
         @pool.disconnect {|c| c.close}
       end
       
-      def execute(sql)
-        log_info(sql)
-        @pool.hold do |conn|
-          stmt = conn.createStatement
-          begin
-            yield stmt.executeQuery(sql)
-          rescue NativeException, JavaSQL::SQLException => e
-            raise Error, e.message
-          ensure
-            stmt.close
-          end
-        end
-      end
-      
-      def execute_ddl(sql)
+      # Execute the given SQL.  If a block is given, if should be a SELECT
+      # statement or something else that returns rows.
+      def execute(sql, opts={}, &block)
+        return execute_prepared_statement(sql, opts, &block) if sql.is_one_of?(Symbol, Dataset)
         log_info(sql)
-        @pool.hold do |conn|
+        synchronize(opts[:server]) do |conn|
           stmt = conn.createStatement
           begin
-            stmt.execute(sql)
+            if block_given?
+              yield stmt.executeQuery(sql)
+            else
+              case opts[:type]
+              when :ddl
+                stmt.execute(sql)
+              when :insert
+                stmt.executeUpdate(sql)
+                last_insert_id(conn, opts)
+              else
+                stmt.executeUpdate(sql)
+              end
+            end
           rescue NativeException, JavaSQL::SQLException => e
             raise Error, e.message
           ensure
@@ -87,28 +132,25 @@ module Sequel
           end
         end
       end
+      alias execute_dui execute
       
-      def execute_dui(sql)
-        log_info(sql)
-        @pool.hold do |conn|
-          stmt = conn.createStatement
-          begin
-            stmt.executeUpdate(sql)
-          rescue NativeException, JavaSQL::SQLException => e
-            raise Error, e.message
-          ensure
-            stmt.close
-          end
-        end
+      # Execute the given DDL SQL, which should not return any
+      # values or rows.
+      def execute_ddl(sql, opts={})
+        execute(sql, {:type=>:ddl}.merge(opts))
       end
       
-      def setup_connection(conn)
-        conn
+      # Execute the given INSERT SQL, returning the last inserted
+      # row id.
+      def execute_insert(sql, opts={})
+        execute(sql, {:type=>:insert}.merge(opts))
       end
       
-      def transaction
-        @pool.hold do |conn|
-          @transactions ||= []
+      # 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|
           return yield(conn) if @transactions.include?(Thread.current)
           stmt = conn.createStatement
           begin
@@ -131,55 +173,196 @@ module Sequel
         end
       end
       
-      def uri
-        ur = @opts[:uri] || @opts[:url] || @opts[:database]
+      # The uri for this connection.  You can specify the uri
+      # using the :uri, :url, or :database options.  You don't
+      # need to worry about this if you use Sequel.connect
+      # with the JDBC connectrion strings.
+      def uri(opts={})
+        opts = @opts.merge(opts)
+        ur = opts[:uri] || opts[:url] || opts[:database]
         ur =~ /^\Ajdbc:/ ? ur : "jdbc:#{ur}"
       end
       alias url uri
       
       private
       
+      # Execute the prepared statement.  If the provided name is a
+      # dataset, use that as the prepared statement, otherwise use
+      # it as a key to look it up in the prepared_statements hash.
+      # If the connection we are using has already prepared an identical
+      # statement, use that statement instead of creating another.
+      # Otherwise, prepare a new statement for the connection, bind the
+      # variables, and execute it.
+      def execute_prepared_statement(name, opts={})
+        args = opts[:arguments]
+        if Dataset === name
+          ps = name
+          name = ps.prepared_statement_name
+        else
+          ps = prepared_statements[name]
+        end
+        sql = ps.prepared_sql
+        synchronize(opts[:server]) do |conn|
+          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)
+            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)
+          begin
+            if block_given?
+              yield cps.executeQuery
+            else
+              case opts[:type]
+              when :ddl
+                cps.execute
+              when :insert
+                cps.executeUpdate
+                last_insert_id(conn, opts)
+              else
+                cps.executeUpdate
+              end
+            end
+          rescue NativeException, JavaSQL::SQLException => e
+            raise Error, e.message
+          ensure
+            cps.close unless name
+          end
+        end
+      end
+      
+      # By default, there is no support for determining the last inserted
+      # id, so return nil.  This method should be overridden in
+      # sub adapters.
+      def last_insert_id(conn, opts)
+        nil
+      end
+      
+      # Java being java, you need to specify the type of each argument
+      # for the prepared statement, and bind it individually.  This
+      # guesses which JDBC method to use, and hopefully JRuby will convert
+      # things properly for us.
+      def set_ps_arg(cps, arg, i)
+        case arg
+        when Integer
+          cps.setInt(i, arg)
+        when String
+          cps.setString(i, arg)
+        when Date, Java::JavaSql::Date
+          cps.setDate(i, arg)
+        when Time, DateTime, Java::JavaSql::Timestamp
+          cps.setTimestamp(i, arg)
+        when Float
+          cps.setDouble(i, arg)
+        when nil
+          cps.setNull(i, JavaSQL::Types::NULL)
+        end
+      end
+      
+      # Add a prepared_statements accessor to the connection,
+      # 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}
+        conn.prepared_statements = {}
+        conn
+      end
+      
+      # The JDBC adapter should not need the pool to convert exceptions.
       def connection_pool_default_options
         super.merge(:pool_convert_exceptions=>false)
       end
     end
     
     class Dataset < Sequel::Dataset
+      # Use JDBC PreparedStatements instead of emulated ones.  Statements
+      # created using #prepare are cached at the connection level to allow
+      # reuse.  This also supports bind variables by using unnamed
+      # prepared statements created using #call.
+      module PreparedStatementMethods
+        include Sequel::Dataset::UnnumberedArgumentMapper
+        
+        private
+        
+        # Execute the prepared SQL using the stored type and
+        # arguments derived from the hash passed to call.
+        def execute(sql, opts={}, &block)
+          super(self, {:arguments=>bind_arguments, :type=>sql_query_type}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_dui(sql, opts={}, &block)
+          super(self, {:arguments=>bind_arguments, :type=>sql_query_type}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_insert(sql, opts={}, &block)
+          super(self, {:arguments=>bind_arguments, :type=>sql_query_type}.merge(opts), &block)
+        end
+      end
+      
+      # Create an unnamed prepared statement and call it.  Allows the
+      # use of bind variables.
+      def call(type, hash, values=nil, &block)
+        prepare(type, nil, values).call(hash, &block)
+      end
+      
+      # Correctly return rows from the database and return them as hashes.
+      def fetch_rows(sql, &block)
+        execute(sql) do |result|
+          # get column names
+          meta = result.getMetaData
+          column_count = meta.getColumnCount
+          @columns = []
+          column_count.times {|i| @columns << meta.getColumnName(i+1).to_sym}
+
+          # get rows
+          while result.next
+            row = {}
+            @columns.each_with_index {|v, i| row[v] = result.getObject(i+1)}
+            yield row
+          end
+        end
+        self
+      end
+      
+      # Use the ISO values for dates and times.
       def literal(v)
         case v
         when Time
           literal(v.iso8601)
-        when Date, DateTime, Java::JavaSql::Timestamp
+        when Date, DateTime, Java::JavaSql::Timestamp, Java::JavaSql::Date
           literal(v.to_s)
         else
           super
         end
       end
-
-      def fetch_rows(sql, &block)
-        @db.synchronize do
-          @db.execute(sql) do |result|
-            # get column names
-            meta = result.getMetaData
-            column_count = meta.getColumnCount
-            @columns = []
-            column_count.times {|i| @columns << meta.getColumnName(i+1).to_sym}
-
-            # get rows
-            while result.next
-              row = {}
-              @columns.each_with_index {|v, i| row[v] = result.getObject(i+1)}
-              yield row
-            end
-          end
+      
+      # Create a named prepared statement that is stored in the
+      # database (and connection) for reuse.
+      def prepare(type, name, values=nil)
+        ps = to_prepared_statement(type, values)
+        ps.extend(PreparedStatementMethods)
+        if name
+          ps.prepared_statement_name = name
+          db.prepared_statements[name] = ps
         end
-        self
+        ps
       end
     end
   end
 end
 
 class Java::JavaSQL::Timestamp
+  # Add a usec method in order to emulate Time values.
   def usec
     getNanos/1000
   end