sequel 2.3.0 → 2.4.0

data/lib/sequel_core/adapters/odbc.rb

@@ -4,21 +4,21 @@ module Sequel
   module ODBC
     class Database < Sequel::Database
       set_adapter_scheme :odbc
-    
-      # def connect
-      #   conn = ::ODBC::connect(@opts[:database], @opts[:user], @opts[:password])
-      #   conn.autocommit = true
-      #   conn
-      # end
 
       GUARDED_DRV_NAME = /^\{.+\}$/.freeze
       DRV_NAME_GUARDS = '{%s}'.freeze
 
-      def connect
-        if @opts.include? :driver
+      def connect(server)
+        opts = server_opts(server)
+        case opts[:db_type]
+        when 'mssql'
+          require 'sequel_core/adapters/shared/mssql'
+          extend Sequel::MSSQL::DatabaseMethods
+        end
+        if opts.include? :driver
           drv = ::ODBC::Driver.new
           drv.name = 'Sequel ODBC Driver130'
-          @opts.each do |param, value|
+          opts.each do |param, value|
             if :driver == param and not (value =~ GUARDED_DRV_NAME)
               value = DRV_NAME_GUARDS % value
             end
@@ -27,7 +27,7 @@ module Sequel
           db = ::ODBC::Database.new
           conn = db.drvconnect(drv)
         else
-          conn = ::ODBC::connect(@opts[:database], @opts[:user], @opts[:password])
+          conn = ::ODBC::connect(opts[:database], opts[:user], opts[:password])
         end
         conn.autocommit = true
         conn
@@ -45,20 +45,20 @@ module Sequel
       # you call execute manually, or you will get warnings.  See the
       # fetch_rows method source code for an example of how to drop
       # the statements.
-      def execute(sql)
+      def execute(sql, opts={})
         log_info(sql)
-        @pool.hold do |conn|
-          conn.run(sql)
+        synchronize(opts[:server]) do |conn|
+          r = conn.run(sql)
+          yield(r) if block_given?
+          r
         end
       end
       
-      def do(sql)
+      def execute_dui(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
+      alias_method :do, :execute_dui
     end
     
     class Dataset < Sequel::Dataset
@@ -90,8 +90,7 @@ module Sequel
       UNTITLED_COLUMN = 'untitled_%d'.freeze
 
       def fetch_rows(sql, &block)
-        @db.synchronize do
-          s = @db.execute sql
+        execute(sql) do |s|
           begin
             untitled_count = 0
             @columns = s.columns(true).map do |c|
@@ -108,20 +107,8 @@ module Sequel
         end
         self
       end
-    
-      # def fetch_rows(sql, &block)
-      #   @db.synchronize do
-      #     s = @db.execute sql
-      #     begin
-      #       @columns = s.columns(true).map {|c| c.name.to_sym}
-      #       rows = s.fetch_all
-      #       rows.each {|row| yield hash_row(row)}
-      #     ensure
-      #       s.drop unless s.nil? rescue nil
-      #     end
-      #   end
-      #   self
-      # end
+      
+      private
       
       def hash_row(row)
         hash = {}

data/lib/sequel_core/adapters/openbase.rb

@@ -5,7 +5,8 @@ module Sequel
     class Database < Sequel::Database
       set_adapter_scheme :openbase
       
-      def connect
+      def connect(server)
+        opts = server_opts(server)
         OpenBase.new(
           opts[:database],
           opts[:host] || 'localhost',
@@ -23,11 +24,14 @@ module Sequel
         OpenBase::Dataset.new(self, opts)
       end
     
-      def execute(sql)
+      def execute(sql, opts={})
         log_info(sql)
-        @pool.hold {|conn| conn.execute(sql)}
+        synchronize(opts[:server]) do |conn|
+          r = conn.execute(sql)
+          yield(r) if block_given?
+          r
+        end
       end
-      
       alias_method :do, :execute
     end
     
@@ -43,9 +47,8 @@ module Sequel
         end
       end
 
-      def fetch_rows(sql, &block)
-        @db.synchronize do
-          result = @db.execute sql
+      def fetch_rows(sql)
+        execute(sql) do |result|
           begin
             @columns = result.column_infos.map {|c| c.name.to_sym}
             result.each do |r|

data/lib/sequel_core/adapters/oracle.rb

@@ -5,20 +5,15 @@ module Sequel
     class Database < Sequel::Database
       set_adapter_scheme :oracle
       
-      # AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
-      # 
-      # def auto_increment_sql
-      #   AUTO_INCREMENT
-      # end
-
-      def connect
-        if @opts[:database]
-          dbname = @opts[:host] ? \
-            "//#{@opts[:host]}#{":#{@opts[:port]}" if @opts[:port]}/#{@opts[:database]}" : @opts[:database]
+      def connect(server)
+        opts = server_opts(server)
+        if opts[:database]
+          dbname = opts[:host] ? \
+            "//#{opts[:host]}#{":#{opts[:port]}" if opts[:port]}/#{opts[:database]}" : opts[:database]
         else
-          dbname = @opts[:host]
+          dbname = opts[:host]
         end
-        conn = OCI8.new(@opts[:user], @opts[:password], dbname, @opts[:privilege])
+        conn = OCI8.new(opts[:user], opts[:password], dbname, opts[:privilege])
         conn.autocommit = true
         conn.non_blocking = true
         conn
@@ -32,11 +27,14 @@ module Sequel
         Oracle::Dataset.new(self, opts)
       end
     
-      def execute(sql)
+      def execute(sql, opts={})
         log_info(sql)
-        @pool.hold {|conn| conn.exec(sql)}
+        synchronize(opts[:server]) do |conn|
+          r = conn.exec(sql)
+          yield(r) if block_given?
+          r
+        end
       end
-      
       alias_method :do, :execute
       
       def tables
@@ -49,12 +47,9 @@ module Sequel
         from(:tab).filter(:tname => name.to_s.upcase, :tabtype => 'TABLE').count > 0
       end
 
-      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)
           
           conn.autocommit = false
           begin
@@ -83,8 +78,7 @@ module Sequel
       end
 
       def fetch_rows(sql, &block)
-        @db.synchronize do
-          cursor = @db.execute sql
+        execute(sql) do |cursor|
           begin
             @columns = cursor.get_col_names.map {|c| c.downcase.to_sym}
             while r = cursor.fetch

data/lib/sequel_core/adapters/postgres.rb

@@ -2,16 +2,23 @@ require 'sequel_core/adapters/shared/postgres'
 
 begin 
   require 'pg' 
+  SEQUEL_POSTGRES_USES_PG = true
 rescue LoadError => e 
-  begin 
-    require 'postgres' 
+  SEQUEL_POSTGRES_USES_PG = false
+  begin
+    require 'postgres'
+    # Attempt to get uniform behavior for the PGconn object no matter
+    # if pg, postgres, or postgres-pr is used.
     class PGconn
       unless method_defined?(:escape_string)
         if self.respond_to?(:escape)
+          # If there is no escape_string instead method, but there is an
+          # escape class method, use that instead.
           def escape_string(str)
             self.class.escape(str)
           end
         else
+          # Raise an error if no valid string escaping method can be found.
           def escape_string(obj)
             raise Sequel::Error, "string escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
           end
@@ -19,6 +26,8 @@ rescue LoadError => e
       end
       unless method_defined?(:escape_bytea)
         if self.respond_to?(:escape_bytea)
+          # If there is no escape_bytea instance method, but there is an
+          # escape_bytea class method, use that instead.
           def escape_bytea(obj)
             self.class.escape_bytea(obj)
           end
@@ -27,14 +36,20 @@ rescue LoadError => e
             require 'postgres-pr/typeconv/conv'
             require 'postgres-pr/typeconv/bytea'
             extend Postgres::Conversion
+            # If we are using postgres-pr, use the encode_bytea method from
+            # that.
             def escape_bytea(obj)
               self.class.encode_bytea(obj)
             end
             metaalias :unescape_bytea, :decode_bytea
           rescue
+            # If no valid bytea escaping method can be found, create one that
+            # raises an error
             def escape_bytea(obj)
               raise Sequel::Error, "bytea escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
             end
+            # If no valid bytea unescaping method can be found, create one that
+            # raises an error
             def self.unescape_bytea(obj)
               raise Sequel::Error, "bytea unescaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
             end
@@ -56,8 +71,12 @@ rescue LoadError => e
 end
 
 module Sequel
+  # Top level module for holding all PostgreSQL-related modules and classes
+  # for Sequel.
   module Postgres
     CONVERTED_EXCEPTIONS << PGError
+    
+    # Hash with integer keys and proc values for converting PostgreSQL types.
     PG_TYPES = {
       16 => lambda{ |s| Postgres.string_to_bool(s) }, # boolean
       17 => lambda{ |s| Adapter.unescape_bytea(s).to_blob }, # bytea
@@ -78,6 +97,7 @@ module Sequel
       1700 => lambda{ |s| s.to_d }, # numeric
     }
     
+    # Module method for converting a PostgreSQL string to a boolean value.
     def self.string_to_bool(s)
       if(s.blank?)
         nil
@@ -87,34 +107,43 @@ module Sequel
         false
       end
     end
-  
+    
+    # PGconn subclass for connection specific methods used with the
+    # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn
       include Sequel::Postgres::AdapterMethods
       self.translate_results = false if respond_to?(:translate_results=)
       
-      def connected?
-        status == Adapter::CONNECTION_OK
-      end
-      
-      def execute(sql, &block)
+      # Execute the given SQL with this connection.  If a block is given,
+      # yield the results, otherwise, return the number of changed rows.
+      def execute(sql, args=nil)
         q = nil
         begin
-          q = exec(sql)
+          q = args ? exec(sql, args) : exec(sql)
         rescue PGError => e
-          unless connected?
-            reset
-            q = exec(sql)
-          else
-            raise e
-          end
+          raise if status == Adapter::CONNECTION_OK
+          reset
+          q = args ? exec(sql, args) : exec(sql)
         end
         begin
-          block ? block[q] : q.cmd_tuples
+          block_given? ? yield(q) : q.cmd_tuples
         ensure
           q.clear
         end
       end
       
+      if SEQUEL_POSTGRES_USES_PG
+        # Hash of prepared statements for this connection.  Keys are
+        # string names of the server side prepared statement, and values
+        # are SQL strings.
+        def prepared_statements
+          @prepared_statements ||= {}
+        end
+      end
+      
+      private
+      
+      # Return the requested values for the given row.
       def result_set_values(r, *vals)
         return if r.nil? || (r.ntuples == 0)
         case vals.length
@@ -125,39 +154,65 @@ module Sequel
         end
       end
     end
-
+    
+    # Database class for PostgreSQL databases used with Sequel and the
+    # pg, postgres, or postgres-pr driver.
     class Database < Sequel::Database
       include Sequel::Postgres::DatabaseMethods
       
       set_adapter_scheme :postgres
-    
-      def connect
+      
+      # Connects to the database.  In addition to the standard database
+      # options, using the :encoding or :charset option changes the
+      # client encoding for the connection.
+      def connect(server)
+        opts = server_opts(server)
         conn = Adapter.connect(
-          @opts[:host] || 'localhost',
-          @opts[:port] || 5432,
+          opts[:host] || 'localhost',
+          opts[:port] || 5432,
           '', '',
-          @opts[:database],
-          @opts[:user],
-          @opts[:password]
+          opts[:database],
+          opts[:user],
+          opts[:password]
         )
-        if encoding = @opts[:encoding] || @opts[:charset]
+        if encoding = opts[:encoding] || opts[:charset]
           conn.set_client_encoding(encoding)
         end
         conn
       end
       
+      # Return instance of Sequel::Postgres::Dataset with the given options.
       def dataset(opts = nil)
         Postgres::Dataset.new(self, opts)
       end
       
+      # Disconnect all active connections.
       def disconnect
         @pool.disconnect {|c| c.finish}
       end
-    
-      def execute(sql, &block)
+      
+      # Execute the given SQL with the given args on an available connection.
+      def execute(sql, opts={}, &block)
+        return execute_prepared_statement(sql, opts, &block) if Symbol === sql
         begin
-          log_info(sql)
-          @pool.hold {|conn| conn.execute(sql, &block)}
+          log_info(sql, opts[:arguments])
+          synchronize(opts[:server]){|conn| conn.execute(sql, opts[:arguments], &block)}
+        rescue => e
+          log_info(e.message)
+          raise convert_pgerror(e)
+        end
+      end
+      
+      # Insert the values into the table and return the primary key (if
+      # automatically generated).
+      def execute_insert(sql, opts={})
+        return execute(sql, opts) if Symbol === sql
+        begin 
+          log_info(sql, opts[:arguments])
+          synchronize(opts[:server]) do |conn|
+            conn.execute(sql, opts[:arguments])
+            insert_result(conn, opts[:table], opts[:values])
+          end
         rescue => e
           log_info(e.message)
           raise convert_pgerror(e)
@@ -166,18 +221,60 @@ module Sequel
       
       private
 
-      # PostgreSQL doesn't need the pool to convert exceptions, either.
+      # PostgreSQL doesn't need the connection pool to convert exceptions.
       def connection_pool_default_options
         super.merge(:pool_convert_exceptions=>false)
       end
+      
+      # Execute the prepared statement with the given name on an available
+      # connection, using the given args.  If the connection has not prepared
+      # a statement with the given name yet, prepare it.  If the connection
+      # has prepared a statement with the same name and different SQL,
+      # deallocate that statement first and then prepare this statement.
+      # If a block is given, yield the result, otherwise, return the number
+      # of rows changed.  If the :insert option is passed, return the value
+      # of the primary key for the last inserted row.
+      def execute_prepared_statement(name, opts={})
+        ps = prepared_statements[name]
+        sql = ps.prepared_sql
+        ps_name = name.to_s
+        args = opts[:arguments]
+        synchronize(opts[:server]) do |conn|
+          unless conn.prepared_statements[ps_name] == sql
+            if conn.prepared_statements.include?(ps_name)
+              s = "DEALLOCATE #{ps_name}"
+              log_info(s)
+              conn.execute(s) unless conn.prepared_statements[ps_name] == sql
+            end
+            conn.prepared_statements[ps_name] = sql
+            log_info("PREPARE #{ps_name} AS #{sql}")
+            conn.prepare(ps_name, sql)
+          end
+          log_info("EXECUTE #{ps_name}", args)
+          q = conn.exec_prepared(ps_name, args)
+          if opts[:table] && opts[:values]
+            insert_result(conn, opts[:table], opts[:values])
+          else
+            begin
+              block_given? ? yield(q) : q.cmd_tuples
+            ensure
+              q.clear
+            end
+          end
+        end
+      end
     end
-  
+    
+    # Dataset class for PostgreSQL datasets that use the pg, postgres, or
+    # postgres-pr driver.
     class Dataset < Sequel::Dataset
       include Sequel::Postgres::DatasetMethods
-
-      def fetch_rows(sql, &block)
+      
+      # yield all rows returned by executing the given SQL and converting
+      # the types.
+      def fetch_rows(sql)
         @columns = []
-        @db.execute(sql) do |res|
+        execute(sql) do |res|
           (0...res.ntuples).each do |recnum|
             converted_rec = {}
             (0...res.nfields).each do |fieldnum|
@@ -193,7 +290,121 @@ module Sequel
           end
         end
       end
+      
+      if SEQUEL_POSTGRES_USES_PG
+        
+        PREPARED_ARG_PLACEHOLDER = '$'.lit.freeze
+        
+        # PostgreSQL specific argument mapper used for mapping the named
+        # argument hash to a array with numbered arguments.  Only used with
+        # the pg driver.
+        module ArgumentMapper
+          include Sequel::Dataset::ArgumentMapper
+          
+          protected
+          
+          # Return an array of strings for each of the hash values, inserting
+          # them to the correct position in the array.
+          def map_to_prepared_args(hash)
+            array = []
+            @prepared_args.each{|k,v| array[v] = hash[k].to_s}
+            array
+          end
+          
+          private
+          
+          # PostgreSQL most of the time requires type information for each of
+          # arguments to a prepared statement.  Handle this by allowing the
+          # named argument to have a __* suffix, with the * being the type.
+          # In the generated SQL, cast the bound argument to that type to
+          # elminate ambiguity (and PostgreSQL from raising an exception).
+          def prepared_arg(k)
+            y, type = k.to_s.split("__")
+            "#{prepared_arg_placeholder}#{@prepared_args[y.to_sym]}#{"::#{type}" if type}".lit
+          end
+          
+          # If the named argument has already been used, return the position in
+          # the output array that it is mapped to.  Otherwise, map it to the
+          # next position in the array.
+          def prepared_args_hash
+            max_prepared_arg = 0
+            Hash.new do |h,k|
+              h[k] = max_prepared_arg
+              max_prepared_arg += 1
+            end
+          end
+        end
+        
+        # Allow use of bind arguments for PostgreSQL using the pg driver.
+        module BindArgumentMethods
+          include ArgumentMapper
+          
+          private
+          
+          # Execute the given SQL with the stored bind arguments.
+          def execute(sql, opts={}, &block)
+            super(sql, {: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(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+          end
+          
+          # Same as execute, explicit due to intricacies of alias and super.
+          def execute_insert(sql, opts={}, &block)
+            super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+          end
+        end
+        
+        # Allow use of server side prepared statements for PostgreSQL using the
+        # pg driver.
+        module PreparedStatementMethods
+          include BindArgumentMethods
+          
+          private
+          
+          # Execute the stored prepared statement name and the stored bind
+          # arguments instead of the SQL given.
+          def execute(sql, opts={}, &block)
+            super(prepared_statement_name, opts, &block)
+          end
+          
+          # Same as execute, explicit due to intricacies of alias and super.
+          def execute_dui(sql, opts={}, &block)
+            super(prepared_statement_name, opts, &block)
+          end
+          
+          # Same as execute, explicit due to intricacies of alias and super.
+          def execute_insert(sql, opts={}, &block)
+            super(prepared_statement_name, opts, &block)
+          end
+        end
+        
+        # Execute the given type of statement with the hash of values.
+        def call(type, hash, values=nil, &block)
+          ps = to_prepared_statement(type, values)
+          ps.extend(BindArgumentMethods)
+          ps.call(hash, &block)
+        end
+        
+        # Prepare the given type of statement with the given name, and store
+        # it in the database to be called later.
+        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
+        
+        private
+        
+        # PostgreSQL uses $N for placeholders instead of ?, so use a $
+        # as the placeholder.
+        def prepared_arg_placeholder
+          PREPARED_ARG_PLACEHOLDER
+        end
+      end
     end
   end
 end
-