sequel 2.3.0 → 2.4.0

data/lib/sequel_core/database.rb

@@ -40,6 +40,9 @@ module Sequel
 
     # Whether to quote identifiers (columns and tables) for this database
     attr_writer :quote_identifiers
+    
+    # The prepared statement objects for this database, keyed by name
+    attr_reader :prepared_statements
 
     # Constructs a new instance of a database connection with the specified
     # options hash.
@@ -51,8 +54,10 @@ module Sequel
       @quote_identifiers = opts.include?(:quote_identifiers) ? opts[:quote_identifiers] : @@quote_identifiers
       @single_threaded = opts.include?(:single_threaded) ? opts[:single_threaded] : @@single_threaded
       @schemas = nil
+      @prepared_statements = {}
+      @transactions = []
       @pool = (@single_threaded ? SingleThreadedPool : ConnectionPool).new(connection_pool_default_options.merge(opts), &block)
-      @pool.connection_proc = proc {connect} unless block
+      @pool.connection_proc = proc{|server| connect(server)} unless block
 
       @loggers = Array(opts[:logger]) + Array(opts[:loggers])
       ::Sequel::DATABASES.push(self)
@@ -191,6 +196,12 @@ module Sequel
       (String === args.first) ? fetch(*args, &block) : from(*args, &block)
     end
     
+    # Call the prepared statement with the given name with the given hash
+    # of arguments.
+    def call(ps_name, hash={})
+      prepared_statements[ps_name].call(hash)
+    end
+    
     # Connects to the database. This method should be overridden by descendants.
     def connect
       raise NotImplementedError, "#connect should be overridden by adapters"
@@ -208,20 +219,20 @@ module Sequel
     end
 
     # Executes the given SQL. This method should be overridden in descendants.
-    def execute(sql)
+    def execute(sql, opts={})
       raise NotImplementedError, "#execute should be overridden by adapters"
     end
     
     # Method that should be used when submitting any DDL (Data Definition
     # Language) SQL.  By default, calls execute_dui.
-    def execute_ddl(sql)
-      execute_dui(sql)
+    def execute_ddl(sql, opts={}, &block)
+      execute_dui(sql, opts, &block)
     end
 
     # Method that should be used when issuing a DELETE, UPDATE, or INSERT
     # statement.  By default, calls execute.
-    def execute_dui(sql)
-      execute(sql)
+    def execute_dui(sql, opts={}, &block)
+      execute(sql, opts, &block)
     end
 
     # Fetches records for an arbitrary SQL statement. If a block is given,
@@ -273,7 +284,8 @@ module Sequel
 
     # Log a message at level info to all loggers.  All SQL logging
     # goes through this method.
-    def log_info(message)
+    def log_info(message, args=nil)
+      message = "#{message}; #{args.inspect}" if args
       @loggers.each{|logger| logger.info(message)}
     end
 
@@ -319,8 +331,8 @@ module Sequel
     end
     
     # Acquires a database connection, yielding it to the passed block.
-    def synchronize(&block)
-      @pool.hold(&block)
+    def synchronize(server=nil, &block)
+      @pool.hold(server || :default, &block)
     end
 
     # Returns true if a table with the given name exists.
@@ -339,8 +351,8 @@ module Sequel
     
     # Attempts to acquire a database connection.  Returns true if successful.
     # Will probably raise an error if unsuccessful.
-    def test_connection
-      synchronize{|conn|}
+    def test_connection(server=nil)
+      synchronize(server){|conn|}
       true
     end
     
@@ -348,12 +360,9 @@ module Sequel
     # supported - calling #transaction within a transaction will reuse the 
     # current transaction. Should be overridden for databases that support nested 
     # transactions.
-    def transaction
-      @pool.hold do |conn|
-        @transactions ||= []
-        if @transactions.include? Thread.current
-          return yield(conn)
-        end
+    def transaction(server=nil)
+      synchronize(server) do |conn|
+        return yield(conn) if @transactions.include?(Thread.current)
         log_info(SQL_BEGIN)
         conn.execute(SQL_BEGIN)
         begin
@@ -461,6 +470,26 @@ module Sequel
     alias_method :url, :uri
     
     private
+    
+    # Return the options for the given server by merging the generic
+    # options for all server with the specific options for the given
+    # server specified in the :servers option.
+    def server_opts(server)
+      opts = if @opts[:servers] && server_options = @opts[:servers][server]
+        case server_options
+        when Hash
+          @opts.merge(server_options)
+        when Proc
+          @opts.merge(server_options.call(self))
+        else
+          raise Error, 'Server opts should be a hash or proc'
+        end
+      else
+        @opts.dup
+      end
+      opts.delete(:servers)
+      opts
+    end
 
     # The default options for the connection pool.
     def connection_pool_default_options

data/lib/sequel_core/dataset.rb

@@ -1,4 +1,4 @@
-%w'callback convenience pagination query schema sql'.each do |f|
+%w'callback convenience pagination prepared_statements query schema sql'.each do |f|
   require "sequel_core/dataset/#{f}"
 end
 
@@ -26,42 +26,6 @@ module Sequel
   # Datasets are Enumerable objects, so they can be manipulated using any
   # of the Enumerable methods, such as map, inject, etc.
   #
-  # === The Dataset Adapter Interface
-  #
-  # Each adapter should define its own dataset class as a descendant of
-  # Sequel::Dataset. The following methods should be overridden by the adapter
-  # Dataset class (each method with the stock implementation):
-  #
-  #   # Iterate over the results of the SQL query and call the supplied
-  #   # block with each record (as a hash).
-  #   def fetch_rows(sql, &block)
-  #     @db.synchronize do
-  #       r = @db.execute(sql)
-  #       r.each(&block)
-  #     end
-  #   end
-  #
-  #   # Insert records.
-  #   def insert(*values)
-  #     @db.synchronize do
-  #       @db.execute(insert_sql(*values)).last_insert_id
-  #     end
-  #   end
-  #
-  #   # Update records.
-  #   def update(*args)
-  #     @db.synchronize do
-  #       @db.execute(update_sql(*args)).affected_rows
-  #     end
-  #   end
-  #
-  #   # Delete records.
-  #   def delete(opts = nil)
-  #     @db.synchronize do
-  #       @db.execute(delete_sql(opts)).affected_rows
-  #     end
-  #   end
-  #
   # === Methods added via metaprogramming
   #
   # Some methods are added via metaprogramming:
@@ -221,7 +185,7 @@ module Sequel
 
     # Deletes the records in the dataset. Adapters should override this method.
     def delete(*args)
-      @db.execute_dui(delete_sql(*args))
+      execute_dui(delete_sql(*args))
     end
     
     # Iterates over the records in the dataset.
@@ -249,7 +213,7 @@ module Sequel
     # Inserts values into the associated table. Adapters should override this
     # method.
     def insert(*values)
-      @db.execute_dui(insert_sql(*values))
+      execute_dui(insert_sql(*values))
     end
   
     # Returns a string representation of the dataset including the class name 
@@ -282,6 +246,13 @@ module Sequel
     def quote_identifiers?
       @quote_identifiers
     end
+    
+    # Set the server for this dataset to use.  Used to pick a specific database
+    # shard to run a query against, or to override the default SELECT uses
+    # :read_only database and all other queries use the :default database.
+    def server(servr)
+      clone(:server=>servr)
+    end
 
     # Alias for set, but not aliased directly so subclasses
     # don't have to override both methods.
@@ -430,7 +401,7 @@ module Sequel
     
     # Updates values for the dataset. Adapters should override this method.
     def update(*args)
-      @db.execute_dui(update_sql(*args))
+      execute_dui(update_sql(*args))
     end
   
     # Add the mutation methods via metaprogramming
@@ -444,6 +415,16 @@ module Sequel
     end
 
     private
+    
+    # Execute the given SQL on the database using execute.
+    def execute(sql, opts={}, &block)
+      @db.execute(sql, {:server=>@opts[:server] || :read_only}.merge(opts), &block)
+    end
+    
+    # Execute the given SQL on the database using execute_dui.
+    def execute_dui(sql, opts={}, &block)
+      @db.execute_dui(sql, {:server=>@opts[:server] || :default}.merge(opts), &block)
+    end
 
     # Modify the receiver with the results of sending the meth, args, and block
     # to the receiver and merging the options of the resulting dataset into

data/lib/sequel_core/dataset/convenience.rb

@@ -136,7 +136,7 @@ module Sequel
         table = @opts[:from].first
         columns, dataset = *args
         sql = "INSERT INTO #{quote_identifier(table)} #{literal(columns)} VALUES #{literal(dataset)}"
-        return @db.transaction {@db.execute_dui sql}
+        return @db.transaction{execute_dui(sql)}
       else
         # we assume that an array of hashes is given
         hashes, opts = *args
@@ -153,11 +153,11 @@ module Sequel
       if slice_size
         values.each_slice(slice_size) do |slice|
           statements = multi_insert_sql(columns, slice)
-          @db.transaction {statements.each {|st| @db.execute_dui(st)}}
+          @db.transaction{statements.each{|st| execute_dui(st)}}
         end
       else
         statements = multi_insert_sql(columns, values)
-        @db.transaction {statements.each {|st| @db.execute_dui(st)}}
+        @db.transaction{statements.each{|st| execute_dui(st)}}
       end
     end
     alias_method :import, :multi_insert

data/lib/sequel_core/dataset/prepared_statements.rb

@@ -0,0 +1,218 @@
+module Sequel 
+  class Dataset
+    PREPARED_ARG_PLACEHOLDER = '?'.lit.freeze
+    
+    # Default implementation of the argument mapper to allow
+    # native database support for bind variables and prepared
+    # statements (as opposed to the emulated ones used by default).
+    module ArgumentMapper
+      SQL_QUERY_TYPE = Hash.new{|h,k| h[k] = k}
+      SQL_QUERY_TYPE[:first] = SQL_QUERY_TYPE[:all] = :select
+      
+      # The name of the prepared statement, if any.
+      attr_accessor :prepared_statement_name
+      
+      # The bind arguments to use for running this prepared statement
+      attr_accessor :bind_arguments
+      
+      # Set the bind arguments based on the hash and call super.
+      def call(hash, &block)
+        ds = clone
+        ds.prepared_sql
+        ds.bind_arguments = ds.map_to_prepared_args(hash)
+        ds.prepared_args = hash
+        ds.run(&block)
+      end
+        
+      # Override the given *_sql method based on the type, and
+      # cache the result of the sql.  This requires that the object
+      # that includes this module implement prepared_args_hash.
+      def prepared_sql
+        return @prepared_sql if @prepared_sql
+        @prepared_args = prepared_args_hash
+        @prepared_sql = super
+        meta_def("#{sql_query_type}_sql"){|*args| prepared_sql}
+        @prepared_sql
+      end
+      
+      private
+      
+      def sql_query_type
+        SQL_QUERY_TYPE[@prepared_type]
+      end
+    end
+
+    # Backbone of the prepared statement support.  Grafts bind variable
+    # support into datasets by hijacking #literal and using placeholders.
+    # By default, emulates prepared statements and bind variables by
+    # taking the hash of bind variables and directly substituting them
+    # into the query, which works on all databases, as it is no different
+    # from using the dataset without bind variables.
+    module PreparedStatementMethods
+      PLACEHOLDER_RE = /\A\$(.*)\z/
+      
+      # The type of prepared statement, should be one of :select,
+      # :insert, :update, or :delete
+      attr_accessor :prepared_type
+      
+      # The bind variable hash to use when substituting
+      attr_accessor :prepared_args
+      
+      # The argument to supply to insert and update, which may use
+      # placeholders specified by prepared_args
+      attr_accessor :prepared_modify_values
+      
+      # Sets the prepared_args to the given hash and runs the
+      # prepared statement.
+      def call(hash, &block)
+        ds = clone
+        ds.prepared_args = hash
+        ds.run(&block)
+      end
+      
+      # Returns the SQL for the prepared statement, depending on
+      # the type of the statement and the prepared_modify_values.
+      def prepared_sql
+        case @prepared_type
+        when :select, :all
+          select_sql
+        when :first
+          select_sql(:limit=>1)
+        when :insert
+          insert_sql(@prepared_modify_values)
+        when :update
+          update_sql(@prepared_modify_values)
+        when :delete
+          delete_sql
+        end
+      end
+      
+      # Changes the values of symbols if they start with $ and
+      # prepared_args is present.  If so, they are considered placeholders,
+      # and they are substituted using prepared_arg.
+      def literal(v)
+        case v
+        when Symbol
+          if match = PLACEHOLDER_RE.match(v.to_s) and @prepared_args
+            super(prepared_arg(match[1].to_sym))
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+      
+      # Programmer friendly string showing this is a prepared statement,
+      # with the prepared SQL it represents (which in general won't have
+      # substituted variables).
+      def inspect
+        "<#{self.class.name}/PreparedStatement #{prepared_sql.inspect}>"
+      end
+      
+      protected
+      
+      # Run the method based on the type of prepared statement, with
+      # :select running #all to get all of the rows, and the other
+      # types running the method with the same name as the type.
+      def run(&block)
+        case @prepared_type
+        when :select, :all
+          all(&block)
+        when :first
+          first
+        when :insert
+          insert(@prepared_modify_values)
+        when :update
+          update(@prepared_modify_values)
+        when :delete
+          delete
+        end
+      end
+      
+      private
+      
+      # Returns the value of the prepared_args hash for the given key.
+      def prepared_arg(k)
+        @prepared_args[k]
+      end
+    end
+    
+    # Default implementation for an argument mapper that uses
+    # unnumbered SQL placeholder arguments.  Keeps track of which
+    # arguments have been used, and allows arguments to
+    # be used more than once.
+    module UnnumberedArgumentMapper
+      include ArgumentMapper
+      
+      protected
+      
+      # Returns a single output array mapping the values of the input hash.
+      # Keys in the input hash that are used more than once in the query
+      # have multiple entries in the output array.
+      def map_to_prepared_args(hash)
+        array = []
+        @prepared_args.each{|k,vs| vs.each{|v| array[v] = hash[k]}}
+        array
+      end
+      
+      private
+      
+      # Uses a separate array of each key, holding the positions
+      # in the output array (necessary to support arguments
+      # that are used more than once).
+      def prepared_args_hash
+        Hash.new{|h,k| h[k] = Array.new}
+      end
+      
+      # Associates the argument with name k with the next position in
+      # the output array.
+      def prepared_arg(k)
+        @max_prepared_arg ||= 0
+        @prepared_args[k] << @max_prepared_arg
+        @max_prepared_arg += 1
+        prepared_arg_placeholder
+      end
+    end
+    
+    # For the given type (:select, :insert, :update, or :delete),
+    # run the sql with the bind variables
+    # specified in the hash.  values is a hash of passed to
+    # insert or update (if one of those types is used),
+    # which may contain placeholders.
+    def call(type, bind_variables={}, values=nil)
+      to_prepared_statement(type, values).call(bind_variables)
+    end
+    
+    # Prepare an SQL statement for later execution. This returns
+    # a clone of the dataset extended with PreparedStatementMethods,
+    # on which you can call call with the hash of bind variables to
+    # do substitution.  The prepared statement is also stored in
+    # the associated database.  The following usage is identical:
+    #
+    #   ps = prepare(:select, :select_by_name)
+    #   ps.call(:name=>'Blah')
+    #   db.call(:select_by_name, :name=>'Blah')
+    def prepare(type, name, values=nil)
+      db.prepared_statements[name] = to_prepared_statement(type, values)
+    end
+    
+    private
+    
+    # The argument placeholder.  Most databases used unnumbered
+    # arguments with question marks, so that is the default.
+    def prepared_arg_placeholder
+      PREPARED_ARG_PLACEHOLDER
+    end
+    
+    # Return a cloned copy of the current dataset extended with
+    # PreparedStatementMethods, setting the type and modify values.
+    def to_prepared_statement(type, values=nil)
+      ps = clone
+      ps.extend(PreparedStatementMethods)
+      ps.prepared_type = type
+      ps.prepared_modify_values = values
+      ps
+    end
+  end
+end