sequel 2.3.0 → 2.4.0

data/lib/sequel_core/adapters/jdbc/mysql.rb

@@ -2,52 +2,60 @@ require 'sequel_core/adapters/shared/mysql'
 
 module Sequel
   module JDBC
+    # Database and Dataset instance methods for MySQL specific
+    # support via JDBC.
     module MySQL
+      # Database instance methods for MySQL databases accessed via JDBC.
       module DatabaseMethods
         include Sequel::MySQL::DatabaseMethods
         
+        # Return instance of Sequel::JDBC::MySQL::Dataset with the given opts.
         def dataset(opts=nil)
           Sequel::JDBC::MySQL::Dataset.new(self, opts)
         end
         
-        def execute_insert(sql)
-          begin
-            log_info(sql)
-            @pool.hold do |conn|
-              stmt = conn.createStatement
-              begin
-                stmt.executeUpdate(sql)
-                rs = stmt.executeQuery('SELECT LAST_INSERT_ID()')
-                rs.next
-                rs.getInt(1)
-              rescue NativeException, JavaSQL::SQLException => e
-                raise Error, e.message
-              ensure
-                stmt.close
-              end
-            end
-          rescue NativeException, JavaSQL::SQLException => e
-            raise Error, "#{sql}\r\n#{e.message}"
-          end
-        end
-        
         private
         
+        # The database name for the given database.  Need to parse it out
+        # of the connection string, since the JDBC does no parsing on the
+        # given connection string by default.
         def database_name
           u = URI.parse(uri.sub(/\Ajdbc:/, ''))
           (m = /\/(.*)/.match(u.path)) && m[1]
         end
+        
+        # Get the last inserted id using LAST_INSERT_ID().
+        def last_insert_id(conn, opts={})
+          stmt = conn.createStatement
+          begin
+            rs = stmt.executeQuery('SELECT LAST_INSERT_ID()')
+            rs.next
+            rs.getInt(1)
+          ensure
+            stmt.close
+          end
+        end
       end
-    
+      
+      # Dataset class for MySQL datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::MySQL::DatasetMethods
         
+        # Use execute_insert to execute the insert_sql.
         def insert(*values)
-          @db.execute_insert(insert_sql(*values))
+          execute_insert(insert_sql(*values))
         end
         
+        # Use execute_insert to execute the replace_sql.
         def replace(*args)
-          @db.execute_insert(replace_sql(*args))
+          execute_insert(replace_sql(*args))
+        end
+        
+        private
+        
+        # Call execute_insert on the database.
+        def execute_insert(sql, opts={})
+          @db.execute_insert(sql, {:server=>@opts[:server] || :default}.merge(opts))
         end
       end
     end

data/lib/sequel_core/adapters/jdbc/postgresql.rb

@@ -4,12 +4,18 @@ module Sequel
   Postgres::CONVERTED_EXCEPTIONS << NativeException
   
   module JDBC
+    # Adapter, Database, and Dataset support for accessing a PostgreSQL
+    # database via JDBC.
     module Postgres
+      # Methods to add to the JDBC adapter/connection to allow it to work
+      # with the shared PostgreSQL code.
       module AdapterMethods
         include Sequel::Postgres::AdapterMethods
         
-        def execute(sql, method=:execute)
-          method = :executeQuery if block_given?
+        # Give the JDBC adapter a direct execute method, which creates
+        # a statement with the given sql and executes it.
+        def execute(sql, args=nil)
+          method = block_given? ? :executeQuery : :execute
           stmt = createStatement
           begin
             rows = stmt.send(method, sql)
@@ -21,6 +27,9 @@ module Sequel
           end
         end
         
+        private
+        
+        # JDBC specific method of getting specific values from a result set.
         def result_set_values(r, *vals)
           return if r.nil?
           r.next
@@ -34,22 +43,43 @@ module Sequel
         end
       end
     
+      # Methods to add to Database instances that access PostgreSQL via
+      # JDBC.
       module DatabaseMethods
         include Sequel::Postgres::DatabaseMethods
         
+        # Return instance of Sequel::JDBC::Postgres::Dataset with the given opts.
         def dataset(opts=nil)
           Sequel::JDBC::Postgres::Dataset.new(self, opts)
         end
         
+        # Run the INSERT sql on the database and return the primary key
+        # for the record.
+        def execute_insert(sql, opts={})
+          super(sql, {:type=>:insert}.merge(opts))
+        end
+        
+        private
+        
+        # Extend the adapter with the JDBC PostgreSQL AdapterMethods
         def setup_connection(conn)
+          conn = super(conn)
           conn.extend(Sequel::JDBC::Postgres::AdapterMethods)
           conn
         end
+        
+        # Call insert_result with the table and values specified in the opts.
+        def last_insert_id(conn, opts)
+          insert_result(conn, opts[:table], opts[:values])
+        end
       end
       
+      # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::Postgres::DatasetMethods
         
+        # Convert Java::JavaSql::Timestamps correctly, and handle SQL::Blobs
+        # correctly.
         def literal(v)
           case v
           when SQL::Blob

data/lib/sequel_core/adapters/jdbc/sqlite.rb

@@ -2,43 +2,39 @@ require 'sequel_core/adapters/shared/sqlite'
 
 module Sequel
   module JDBC
+    # Database and Dataset support for SQLite databases accessed via JDBC.
     module SQLite
+      # Instance methods for SQLite Database objects accessed via JDBC.
       module DatabaseMethods
         include Sequel::SQLite::DatabaseMethods
         
+        # Return Sequel::JDBC::SQLite::Dataset object with the given opts.
         def dataset(opts=nil)
           Sequel::JDBC::SQLite::Dataset.new(self, opts)
         end
         
-        def execute_insert(sql)
+        private
+        
+        # Use last_insert_rowid() to get the last inserted id.
+        def last_insert_id(conn, opts={})
+          stmt = conn.createStatement
           begin
-            log_info(sql)
-            @pool.hold do |conn|
-              stmt = conn.createStatement
-              begin
-                stmt.executeUpdate(sql)
-                rs = stmt.executeQuery('SELECT last_insert_rowid()')
-                rs.next
-                rs.getInt(1)
-              rescue NativeException, JavaSQL::SQLException => e
-                raise Error, e.message
-              ensure
-                stmt.close
-              end
-            end
-          rescue NativeException, JavaSQL::SQLException => e
-            raise Error, "#{sql}\r\n#{e.message}"
+            rs = stmt.executeQuery('SELECT last_insert_rowid()')
+            rs.next
+            rs.getInt(1)
+          ensure
+            stmt.close
           end
         end
         
-        private
-        
+        # Default to a single connection for a memory database.
         def connection_pool_default_options
           o = super
           uri == 'jdbc:sqlite::memory:' ? o.merge(:max_connections=>1) : o
         end
       end
-    
+      
+      # Dataset class for SQLite datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::SQLite::DatasetMethods
       end

data/lib/sequel_core/adapters/mysql.rb

@@ -1,8 +1,10 @@
 require 'mysql'
 require 'sequel_core/adapters/shared/mysql'
 
-# Monkey patch Mysql::Result to yield hashes with symbol keys
+# Add methods to get columns, yield hashes with symbol keys, and do
+# type conversion.
 class Mysql::Result
+  # Mapping of type numbers to conversion methods.
   MYSQL_TYPES = {
     0   => :to_d,     # MYSQL_TYPE_DECIMAL
     1   => :to_i,     # MYSQL_TYPE_TINY
@@ -32,21 +34,8 @@ class Mysql::Result
     # 254 => :to_s,     # MYSQL_TYPE_STRING
     # 255 => :to_s      # MYSQL_TYPE_GEOMETRY
   }
-
-  def convert_type(v, type)
-    if v
-      if type == 1 && Sequel.convert_tinyint_to_bool
-        # We special case tinyint here to avoid adding
-        # a method to an ancestor of Fixnum
-        v.to_i == 0 ? false : true
-      else
-        (t = MYSQL_TYPES[type]) ? v.send(t) : v
-      end
-    else
-      nil
-    end
-  end
-
+  
+  # Return an array of column name symbols for this result set.
   def columns(with_table = nil)
     unless @columns
       @column_types = []
@@ -58,18 +47,7 @@ class Mysql::Result
     @columns
   end
 
-  def each_array(with_table = nil)
-    c = columns
-    while row = fetch_row
-      c.each_with_index do |f, i|
-        if (t = MYSQL_TYPES[@column_types[i]]) && (v = row[i])
-          row[i] = v.send(t)
-        end
-      end
-      yield row
-    end
-  end
-
+  # yield a hash with symbol keys and type converted values.
   def sequel_each_hash(with_table = nil)
     c = columns
     while row = fetch_row
@@ -79,86 +57,104 @@ class Mysql::Result
     end
   end
   
+  private
+  
+  # Convert the type of v using the method in MYSQL_TYPES[type].
+  def convert_type(v, type)
+    if v
+      if type == 1 && Sequel.convert_tinyint_to_bool
+        # We special case tinyint here to avoid adding
+        # a method to an ancestor of Fixnum
+        v.to_i == 0 ? false : true
+      else
+        (t = MYSQL_TYPES[type]) ? v.send(t) : v
+      end
+    else
+      nil
+    end
+  end
+  
 end
 
 module Sequel
-  module MySQL    
+  # Module for holding all MySQL-related classes and modules for Sequel.
+  module MySQL
+    # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
       
       set_adapter_scheme :mysql
-
-      def connect
+      
+      # Connect to the database.  In addition to the usual database options,
+      # the following options have effect:
+      #
+      # * :encoding, :charset - Set all the related character sets for this
+      #   connection (connection, client, database, server, and results).
+      # * :socket - Use a unix socket file instead of connecting via TCP/IP.
+      def connect(server)
+        opts = server_opts(server)
         conn = Mysql.init
         conn.options(Mysql::OPT_LOCAL_INFILE, "client")
         conn.real_connect(
-          @opts[:host] || 'localhost',
-          @opts[:user],
-          @opts[:password],
-          @opts[:database],
-          @opts[:port],
-          @opts[:socket],
+          opts[:host] || 'localhost',
+          opts[:user],
+          opts[:password],
+          opts[:database],
+          opts[:port],
+          opts[:socket],
           Mysql::CLIENT_MULTI_RESULTS +
           Mysql::CLIENT_MULTI_STATEMENTS +
           Mysql::CLIENT_COMPRESS
         )
         conn.query_with_result = false
-        if encoding = @opts[:encoding] || @opts[:charset]
+        if encoding = opts[:encoding] || opts[:charset]
           conn.query("set character_set_connection = '#{encoding}'")
           conn.query("set character_set_client = '#{encoding}'")
           conn.query("set character_set_database = '#{encoding}'")
           conn.query("set character_set_server = '#{encoding}'")
           conn.query("set character_set_results = '#{encoding}'")
         end
+        conn.meta_eval{attr_accessor :prepared_statements}
+        conn.prepared_statements = {}
         conn.reconnect = true
         conn
       end
       
+      # Returns instance of Sequel::MySQL::Dataset with the given options.
       def dataset(opts = nil)
         MySQL::Dataset.new(self, opts)
       end
-
+      
+      # Closes all database connections.
       def disconnect
         @pool.disconnect {|c| c.close}
       end
-
-      def execute(sql, &block)
+      
+      # Executes the given SQL using an available connection, yielding the
+      # connection if the block is given.
+      def execute(sql, opts={}, &block)
+        return execute_prepared_statement(sql, opts, &block) if Symbol === sql
         begin
-          log_info(sql)
-          @pool.hold do |conn|
-            conn.query(sql)
-            block[conn] if block
-          end
+          synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
         rescue Mysql::Error => e
           raise Error.new(e.message)
         end
       end
-
-      def execute_select(sql, &block)
-        execute(sql) do |c|
-          r = c.use_result
-          begin
-            block[r]
-          ensure
-            r.free
-          end
-        end
-      end
       
-      def server_version
-        @server_version ||= (synchronize{|conn| conn.server_version if conn.respond_to?(:server_version)} || super)
+      # 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)
       end
       
-      def tables
-        @pool.hold do |conn|
-          conn.list_tables.map {|t| t.to_sym}
-        end
+      # Return an array of symbols specifying table names in the current database.
+      def tables(server=nil)
+        synchronize(server){|conn| conn.list_tables.map {|t| t.to_sym}}
       end
       
-      def transaction
-        @pool.hold do |conn|
-          @transactions ||= []
-          return yield(conn) if @transactions.include? Thread.current
+      # Support single level transactions on MySQL.
+      def transaction(server=nil)
+        synchronize(server) do |conn|
+          return yield(conn) if @transactions.include?(Thread.current)
           log_info(SQL_BEGIN)
           conn.query(SQL_BEGIN)
           begin
@@ -180,34 +176,103 @@ module Sequel
 
       private
       
+      # Execute the given SQL on the given connection.  If the :type
+      # option is :select, yield the result of the query, otherwise
+      # yield the connection if a block is given.
+      def _execute(conn, sql, opts)
+        log_info(sql)
+        conn.query(sql)
+        if opts[:type] == :select
+          r = conn.use_result
+          begin
+            yield r
+          ensure
+            r.free
+          end
+        else
+          yield conn if block_given?
+        end
+      end
+      
+      # MySQL doesn't need the connection pool to convert exceptions.
       def connection_pool_default_options
         super.merge(:pool_convert_exceptions=>false)
       end
       
+      # The database name when using the native adapter is always stored in
+      # the :database option.
       def database_name
         @opts[:database]
       end
+      
+      # Executes a prepared statement on an available connection.  If the
+      # prepared statement already exists for the connection and has the same
+      # SQL, reuse it, otherwise, prepare the new statement.  Because of the
+      # usual MySQL stupidity, we are forced to name arguments via separate
+      # SET queries.  Use @sequel_arg_N (for N starting at 1) for these
+      # arguments.
+      def execute_prepared_statement(ps_name, opts, &block)
+        args = opts[:arguments]
+        ps = prepared_statements[ps_name]
+        sql = ps.prepared_sql
+        synchronize(opts[:server]) do |conn|
+          unless conn.prepared_statements[ps_name] == sql
+            conn.prepared_statements[ps_name] = sql
+            s = "PREPARE #{ps_name} FROM '#{::Mysql.quote(sql)}'"
+            log_info(s)
+            conn.query(s)
+          end
+          i = 0
+          args.each do |arg|
+            s = "SET @sequel_arg_#{i+=1} = #{literal(arg)}"
+            log_info(s)
+            conn.query(s)
+          end
+          _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
+        end
+      end
     end
-
+    
+    # Dataset class for MySQL datasets accessed via the native driver.
     class Dataset < Sequel::Dataset
       include Sequel::MySQL::DatasetMethods
-
+      
+      # Methods for MySQL prepared statements using the native driver.
+      module PreparedStatementMethods
+        include Sequel::Dataset::UnnumberedArgumentMapper
+        
+        # Execute the prepared statement with the bind arguments instead of
+        # the given SQL.
+        def execute(sql, opts={}, &block)
+          super(prepared_statement_name, {: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(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+      end
+      
+      # Delete rows matching this dataset
       def delete(opts = nil)
-        @db.execute(delete_sql(opts)) {|c| c.affected_rows}
+        execute_dui(delete_sql(opts)){|c| c.affected_rows}
       end
-
+      
+      # Yield all rows matching this dataset
       def fetch_rows(sql)
-        @db.execute_select(sql) do |r|
+        execute(sql) do |r|
           @columns = r.columns
           r.sequel_each_hash {|row| yield row}
         end
         self
       end
-
+      
+      # Insert a new value into this dataset
       def insert(*values)
-        @db.execute(insert_sql(*values)) {|c| c.insert_id}
+        execute_dui(insert_sql(*values)){|c| c.insert_id}
       end
       
+      # Handle correct quoting of strings using ::MySQL.quote.
       def literal(v)
         case v
         when LiteralString
@@ -219,12 +284,35 @@ module Sequel
         end
       end
       
+      # Store the given type of prepared statement in the associated database
+      # with the given name.
+      def prepare(type, name, values=nil)
+        ps = to_prepared_statement(type, values)
+        ps.extend(PreparedStatementMethods)
+        ps.prepared_statement_name = name
+        db.prepared_statements[name] = ps
+      end
+      
+      # Replace (update or insert) the matching row.
       def replace(*args)
-        @db.execute(replace_sql(*args)) {|c| c.insert_id}
+        execute_dui(replace_sql(*args)){|c| c.insert_id}
       end
       
+      # Update the matching rows.
       def update(*args)
-        @db.execute(update_sql(*args)) {|c| c.affected_rows}
+        execute_dui(update_sql(*args)){|c| c.affected_rows}
+      end
+      
+      private
+      
+      # Set the :type option to :select if it hasn't been set.
+      def execute(sql, opts={}, &block)
+        super(sql, {:type=>:select}.merge(opts), &block)
+      end
+      
+      # Set the :type option to :dui if it hasn't been set.
+      def execute_dui(sql, opts={}, &block)
+        super(sql, {:type=>:dui}.merge(opts), &block)
       end
     end
   end