sequel 3.34.1 → 3.35.0

data/lib/sequel/adapters/sqlite.rb

@@ -216,7 +216,7 @@ module Sequel
 
       # Execute a prepared statement on the database using the given name.
       def execute_prepared_statement(conn, type, name, opts, &block)
-        ps = prepared_statements[name]
+        ps = prepared_statement(name)
         sql = ps.prepared_sql
         args = opts[:arguments]
         ps_args = {}
@@ -382,7 +382,7 @@ module Sequel
         ps.extend(PreparedStatementMethods)
         if name
           ps.prepared_statement_name = name
-          db.prepared_statements[name] = ps
+          db.set_prepared_statement(name, ps)
         end
         ps
       end

data/lib/sequel/adapters/swift.rb

@@ -15,7 +15,7 @@ module Sequel
     DATABASE_SETUP = {:postgres=>proc do |db|
         Sequel.ts_require 'adapters/swift/postgres'
         db.extend(Sequel::Swift::Postgres::DatabaseMethods)
-        db.dataset_class = Sequel::Swift::Postgres::Dataset
+        db.extend_datasets Sequel::Postgres::DatasetMethods
         db.swift_class = ::Swift::DB::Postgres
       end,
       :mysql=>proc do |db|

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

@@ -7,27 +7,6 @@ module Sequel
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
     # database via Swift.
     module Postgres
-      # Methods to add to the Swift adapter/connection to allow it to work
-      # with the shared PostgreSQL code.
-      module AdapterMethods
-        include Sequel::Postgres::AdapterMethods
-        
-        # Log all SQL that goes through the execute method to the related
-        # database object.
-        def execute(sql, *args)
-          @db.log_yield(sql){super}
-        rescue SwiftError => e
-          @db.send(:raise_error, e)
-        end
-        
-        private
-        
-        # Swift specific method of getting specific values from a result set.
-        def single_value(row)
-          row.values.at(0)
-        end
-      end
-    
       # Methods to add to Database instances that access PostgreSQL via Swift.
       module DatabaseMethods
         include Sequel::Postgres::DatabaseMethods
@@ -41,51 +20,8 @@ module Sequel
           end
         end
         
-        # Run the SELECT SQL on the database and yield the rows
-        def execute(sql, opts={})
-          synchronize(opts[:server]) do |conn|
-            begin
-              res = conn.execute(sql)
-              yield res if block_given?
-              nil
-            rescue SwiftError => e
-              raise_error(e)
-            end
-          end
-        end
-        
-        # Run the DELETE/UPDATE SQL on the database and return the number
-        # of matched rows.
-        def execute_dui(sql, opts={})
-          synchronize(opts[:server]) do |conn|
-            begin
-              conn.execute(sql).rows
-            rescue SwiftError => e
-              raise_error(e)
-            end
-          end
-        end
-      
-        # Run the INSERT SQL on the database and return the primary key
-        # for the record.
-        def execute_insert(sql, opts={})
-          synchronize(opts[:server]) do |conn|
-            begin
-              conn.execute(sql)
-              insert_result(conn, opts[:table], opts[:values])
-            rescue SwiftError => e
-              raise_error(e)
-            end
-          end
-        end
-        
         private
         
-        # Execute SQL on the connection.
-        def log_connection_execute(conn, sql)
-          conn.execute(sql)
-        end
-
         # Remove all other options except for ones specifically handled, as
         # otherwise swift passes them to dbic++ which passes them to PostgreSQL
         # which can raise an error.
@@ -99,16 +35,10 @@ module Sequel
         # Extend the adapter with the Swift PostgreSQL AdapterMethods.
         def setup_connection(conn)
           conn = super(conn)
-          conn.extend(Sequel::Swift::Postgres::AdapterMethods)
-          conn.db = self
-          conn.apply_connection_settings
+          connection_configuration_sqls.each{|sql| log_yield(sql){conn.execute(sql)}}
           conn
         end
       end
-      
-      class Dataset < Swift::Dataset
-        include Sequel::Postgres::DatasetMethods
-      end
     end
   end
 end

data/lib/sequel/adapters/tinytds.rb

@@ -249,7 +249,7 @@ module Sequel
         ps.extend(PreparedStatementMethods)
         if name
           ps.prepared_statement_name = name
-          db.prepared_statements[name] = ps
+          db.set_prepared_statement(name, ps)
         end
         ps
       end
@@ -258,8 +258,8 @@ module Sequel
       
       # Properly escape the given string +v+.
       def literal_string_append(sql, v)
-        sql << 'N' if mssql_unicode_strings
-        sql << "'" << db.synchronize{|c| c.escape(v)} << "'"
+        sql << (mssql_unicode_strings ? UNICODE_STRING_START : APOS)
+        sql << db.synchronize{|c| c.escape(v)}.gsub(BACKSLASH_CRLF_RE, BACKSLASH_CRLF_REPLACE) << APOS
       end
     end
   end

data/lib/sequel/core.rb

@@ -1,4 +1,3 @@
-warn 'Sequel support for ruby <1.8.7 is deprecated and will be removed in 3.35.0' if RUBY_VERSION < '1.8.7'
 %w'bigdecimal date thread time uri'.each{|f| require f}
 
 # Top level module for Sequel
@@ -35,6 +34,9 @@ module Sequel
   # Mutex used to protect file loading/requireing
   @require_mutex = Mutex.new
   
+  # Whether Sequel is being run in single threaded mode
+  @single_threaded = false
+  
   class << self
     # Sequel converts two digit years in <tt>Date</tt>s and <tt>DateTime</tt>s by default,
     # so 01/02/03 is interpreted at January 2nd, 2003, and 12/13/99 is interpreted
@@ -89,6 +91,7 @@ module Sequel
 
     # Make thread safe requiring reentrant to prevent deadlocks.
     def check_requiring_thread
+      return yield if @single_threaded
       t = Thread.current
       return(yield) if @require_thread == t
       @require_mutex.synchronize do
@@ -234,13 +237,15 @@ module Sequel
     Array(files).each{|f| super("#{File.dirname(__FILE__).untaint}/#{"#{subdir}/" if subdir}#{f}")}
   end
   
-  # Set whether to set the single threaded mode for all databases by default. By default,
+  # Set whether Sequel is being used in single threaded mode. By default,
   # Sequel uses a thread-safe connection pool, which isn't as fast as the
-  # single threaded connection pool.  If your program will only have one thread,
-  # and speed is a priority, you may want to set this to true:
+  # single threaded connection pool, and also has some additional thread
+  # safety checks.  If your program will only have one thread,
+  # and speed is a priority, you should set this to true:
   #
   #   Sequel.single_threaded = true
   def self.single_threaded=(value)
+    @single_threaded = value
     Database.single_threaded = value
   end
 
@@ -283,6 +288,24 @@ module Sequel
     end
   end
 
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE != 'ruby'
+    # Mutex used to protect mutable data structures
+    @data_mutex = Mutex.new
+
+    # Unless in single threaded mode, protects access to any mutable
+    # global data structure in Sequel.
+    # Uses a non-reentrant mutex, so calling code should be careful.
+    def self.synchronize(&block)
+      @single_threaded ? yield : @data_mutex.synchronize(&block)
+    end
+  else
+    # Yield directly to the block.  You don't need to synchronize
+    # access on MRI because the GVL makes certain methods atomic.
+    def self.synchronize(&block)
+      yield
+    end
+  end
+
   # Uses a transaction on all given databases with the given options. This:
   #
   #   Sequel.transaction([DB1, DB2, DB3]){...}

data/lib/sequel/database/connecting.rb

@@ -81,7 +81,7 @@ module Sequel
       ensure
         if block_given?
           db.disconnect if db
-          ::Sequel::DATABASES.delete(db)
+          Sequel.synchronize{::Sequel::DATABASES.delete(db)}
         end
       end
       block_given? ? result : db
@@ -135,8 +135,10 @@ module Sequel
     #
     #   DB.add_servers(:f=>{:host=>"hash_host_f"})
     def add_servers(servers)
-      @opts[:servers] = @opts[:servers] ? @opts[:servers].merge(servers) : servers
-      @pool.add_servers(servers.keys)
+      if h = @opts[:servers]
+        Sequel.synchronize{h.merge!(servers)}
+        @pool.add_servers(servers.keys)
+      end
     end
     
     # Connects to the database. This method should be overridden by descendants.
@@ -191,11 +193,8 @@ module Sequel
     #
     #   DB.remove_servers(:f1, :f2)
     def remove_servers(*servers)
-      if @opts[:servers] && !@opts[:servers].empty?
-        servs = @opts[:servers].dup
-        servers.flatten!
-        servers.each{|s| servs.delete(s)}
-        @opts[:servers] = servs
+      if h = @opts[:servers]
+        servers.flatten.each{|s| Sequel.synchronize{h.delete(s)}}
         @pool.remove_servers(servers)
       end
     end

data/lib/sequel/database/logging.rb

@@ -17,6 +17,11 @@ module Sequel
     # is :info, it can be set to :debug to log at DEBUG level.
     attr_accessor :sql_log_level
 
+    # Log a message at error level, with information about the exception.
+    def log_exception(exception, message)
+      log_each(:error, "#{exception.class}: #{exception.message.strip}: #{message}")
+    end
+
     # Log a message at level info to all loggers.
     def log_info(message, args=nil)
       log_each(:info, args ? "#{message}; #{args.inspect}" : message)
@@ -31,7 +36,7 @@ module Sequel
       begin
         yield
       rescue => e
-        log_each(:error, "#{e.class}: #{e.message.strip}: #{sql}")
+        log_exception(e, sql)
         raise
       ensure
         log_duration(Time.now - start, sql) unless e

data/lib/sequel/database/misc.rb

@@ -59,11 +59,12 @@ module Sequel
       @quote_identifiers = nil
       @timezone = nil
       @dataset_class = dataset_class_default
+      @cache_schema = typecast_value_boolean(@opts.fetch(:cache_schema, true))
       @dataset_modules = []
       self.sql_log_level = @opts[:sql_log_level] ? @opts[:sql_log_level].to_sym : :info
       @pool = ConnectionPool.get_pool(@opts, &block)
 
-      ::Sequel::DATABASES.push(self)
+      Sequel.synchronize{::Sequel::DATABASES.push(self)}
     end
 
     # If a transaction is not currently in process, yield to the block immediately.
@@ -74,7 +75,7 @@ module Sequel
     def after_commit(opts={}, &block)
       raise Error, "must provide block to after_commit" unless block
       synchronize(opts[:server]) do |conn|
-        if h = @transactions[conn]
+        if h = _trans(conn)
           raise Error, "cannot call after_commit in a prepared transaction" if h[:prepare]
           (h[:after_commit] ||= []) << block
         else
@@ -91,7 +92,7 @@ module Sequel
     def after_rollback(opts={}, &block)
       raise Error, "must provide block to after_rollback" unless block
       synchronize(opts[:server]) do |conn|
-        if h = @transactions[conn]
+        if h = _trans(conn)
           raise Error, "cannot call after_rollback in a prepared transaction" if h[:prepare]
           (h[:after_rollback] ||= []) << block
         end
@@ -117,7 +118,7 @@ module Sequel
     # false otherwise.  Respects the :server option for selecting
     # a shard.
     def in_transaction?(opts={})
-      synchronize(opts[:server]){|conn| !!@transactions[conn]}
+      synchronize(opts[:server]){|conn| !!_trans(conn)}
     end
 
     # Returns a string representation of the database object including the
@@ -140,12 +141,22 @@ module Sequel
       schema_utility_dataset.literal(v)
     end
 
+    # Synchronize access to the prepared statements cache.
+    def prepared_statement(name)
+      Sequel.synchronize{prepared_statements[name]}
+    end
+
     # Default serial primary key options, used by the table creation
     # code.
     def serial_primary_key_options
       {:primary_key => true, :type => Integer, :auto_increment => true}
     end
 
+    # Cache the prepared statement object at the given name.
+    def set_prepared_statement(name, ps)
+      Sequel.synchronize{prepared_statements[name] = ps}
+    end
+
     # Whether the database supports CREATE TABLE IF NOT EXISTS syntax,
     # false by default.
     def supports_create_table_if_not_exists?
@@ -180,6 +191,11 @@ module Sequel
       false
     end
 
+    # Whether DDL statements work correctly in transactions, false by default.
+    def supports_transactional_ddl?
+      false
+    end
+
     # The timezone to use for this database, defaulting to <tt>Sequel.database_timezone</tt>.
     def timezone
       @timezone || Sequel.database_timezone

data/lib/sequel/database/query.rb

@@ -35,6 +35,11 @@ module Sequel
     # Database#transaction, as on MSSQL if affects all future transactions
     # on the same connection.
     attr_accessor :transaction_isolation_level
+
+    # Whether the schema should be cached for this database.  True by default
+    # for performance, can be set to false to always issue a database query to
+    # get the schema.
+    attr_accessor :cache_schema
     
     # Runs the supplied SQL statement string on the database server.
     # Returns self so it can be safely chained:
@@ -51,7 +56,7 @@ module Sequel
     #   DB[:items].filter(:id=>1).prepare(:first, :sa)
     #   DB.call(:sa) # SELECT * FROM items WHERE id = 1
     def call(ps_name, hash={})
-      prepared_statements[ps_name].call(hash)
+      prepared_statement(ps_name).call(hash)
     end
     
     # Executes the given SQL on the database. This method should be overridden in descendants.
@@ -189,13 +194,14 @@ module Sequel
       end
       opts[:schema] = sch if sch && !opts.include?(:schema)
 
-      @schemas.delete(quoted_name) if opts[:reload]
-      return @schemas[quoted_name] if @schemas[quoted_name]
+      Sequel.synchronize{@schemas.delete(quoted_name)} if opts[:reload]
+      return Sequel.synchronize{@schemas[quoted_name]} if @schemas[quoted_name]
 
       cols = schema_parse_table(table_name, opts)
       raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty?
       cols.each{|_,c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
-      @schemas[quoted_name] = cols
+      Sequel.synchronize{@schemas[quoted_name] = cols} if cache_schema
+      cols
     end
 
     # Returns true if a table with the given name exists.  This requires a query
@@ -286,7 +292,11 @@ module Sequel
           yield(conn)
         end
       rescue Exception => e
-        rollback_transaction(conn, opts)
+        begin
+          rollback_transaction(conn, opts)
+        rescue Exception => e3
+          raise_error(e3, :classes=>database_error_classes, :conn=>conn)
+        end
         transaction_error(e, :conn=>conn, :rollback=>rollback)
       ensure
         begin
@@ -299,36 +309,46 @@ module Sequel
       end
     end
 
+    # Synchronize access to the current transactions, returning the hash
+    # of options for the current transaction (if any)
+    def _trans(conn)
+      Sequel.synchronize{@transactions[conn]}
+    end
+
     # Add the current thread to the list of active transactions
     def add_transaction(conn, opts)
       if supports_savepoints?
-        unless @transactions[conn]
-          @transactions[conn] = {:savepoint_level=>0}
-          @transactions[conn][:prepare] = opts[:prepare] if opts[:prepare] && supports_prepared_transactions?
+        unless _trans(conn)
+          if (prep = opts[:prepare]) && supports_prepared_transactions?
+            Sequel.synchronize{@transactions[conn] = {:savepoint_level=>0, :prepare=>prep}}
+          else
+            Sequel.synchronize{@transactions[conn] = {:savepoint_level=>0}}
+          end
         end
+      elsif (prep = opts[:prepare]) && supports_prepared_transactions?
+        Sequel.synchronize{@transactions[conn] = {:prepare => prep}}
       else
-        @transactions[conn] = {}
-        @transactions[conn][:prepare] = opts[:prepare] if opts[:prepare] && supports_prepared_transactions?
+        Sequel.synchronize{@transactions[conn] = {}}
       end
     end    
 
     # Call all stored after_commit blocks for the given transaction
     def after_transaction_commit(conn)
-      if ary = @transactions[conn][:after_commit]
+      if ary = _trans(conn)[:after_commit]
         ary.each{|b| b.call}
       end
     end
 
     # Call all stored after_rollback blocks for the given transaction
     def after_transaction_rollback(conn)
-      if ary = @transactions[conn][:after_rollback]
+      if ary = _trans(conn)[:after_rollback]
         ary.each{|b| b.call}
       end
     end
 
     # Whether the current thread/connection is already inside a transaction
     def already_in_transaction?(conn, opts)
-      @transactions.has_key?(conn) && (!supports_savepoints? || !opts[:savepoint])
+      _trans(conn) && (!supports_savepoints? || !opts[:savepoint])
     end
     
     # SQL to start a new savepoint
@@ -345,7 +365,7 @@ module Sequel
     # Start a new database transaction or a new savepoint on the given connection.
     def begin_transaction(conn, opts={})
       if supports_savepoints?
-        th = @transactions[conn]
+        th = _trans(conn)
         if (depth = th[:savepoint_level]) > 0
           log_connection_execute(conn, begin_savepoint_sql(depth))
         else
@@ -452,7 +472,7 @@ module Sequel
     # Commit the active transaction on the connection
     def commit_transaction(conn, opts={})
       if supports_savepoints?
-        depth = @transactions[conn][:savepoint_level]
+        depth = _trans(conn)[:savepoint_level]
         log_connection_execute(conn, depth > 1 ? commit_savepoint_sql(depth-1) : commit_transaction_sql)
       else
         log_connection_execute(conn, commit_transaction_sql)
@@ -502,7 +522,7 @@ module Sequel
     
     # Remove the current thread from the list of active transactions
     def remove_transaction(conn, committed)
-      if !supports_savepoints? || ((@transactions[conn][:savepoint_level] -= 1) <= 0)
+      if !supports_savepoints? || ((_trans(conn)[:savepoint_level] -= 1) <= 0)
         begin
           if committed
             after_transaction_commit(conn)
@@ -510,7 +530,7 @@ module Sequel
             after_transaction_rollback(conn)
           end
         ensure
-          @transactions.delete(conn)
+          Sequel.synchronize{@transactions.delete(conn)}
         end
       end
     end
@@ -523,7 +543,7 @@ module Sequel
     # Rollback the active transaction on the connection
     def rollback_transaction(conn, opts={})
       if supports_savepoints?
-        depth = @transactions[conn][:savepoint_level]
+        depth = _trans(conn)[:savepoint_level]
         log_connection_execute(conn, depth > 1 ? rollback_savepoint_sql(depth-1) : rollback_transaction_sql)
       else
         log_connection_execute(conn, rollback_transaction_sql)