sequel 3.0.0 → 3.1.0

data/lib/sequel/adapters/odbc.rb

@@ -63,30 +63,11 @@ module Sequel
       end
       alias_method :do, :execute_dui
 
-      # Support single level transactions on ODBC
-      def transaction(opts={})
-        synchronize(opts[:server]) do |conn|
-          return yield(conn) if @transactions.include?(Thread.current)
-          log_info(begin_transaction_sql)
-          conn.do(begin_transaction_sql)
-          begin
-            @transactions << Thread.current
-            yield(conn)
-          rescue ::Exception => e
-            log_info(rollback_transaction_sql)
-            conn.do(rollback_transaction_sql)
-            transaction_error(e)
-          ensure
-            unless e
-              log_info(commit_transaction_sql)
-              conn.do(commit_transaction_sql)
-            end
-            @transactions.delete(Thread.current)
-          end
-        end
-      end
-
       private
+      
+      def connection_execute_method
+        :do
+      end
 
       def disconnect_connection(c)
         c.disconnect

data/lib/sequel/adapters/oracle.rb

@@ -75,31 +75,34 @@ module Sequel
           end
         end
       end
-      alias do execute
-      
-      def transaction(opts={})
-        synchronize(opts[:server]) do |conn|
-          return yield(conn) if @transactions.include?(Thread.current)
-          conn.autocommit = false
-          begin
-            @transactions << Thread.current
-            yield(conn)
-          rescue => e
-            conn.rollback
-            raise e unless Rollback === e
-          ensure
-            conn.commit unless e
-            conn.autocommit = true
-            @transactions.delete(Thread.current)
-          end
-        end
-      end
+      alias_method :do, :execute
 
       private
+      
+      def begin_transaction(conn)
+        log_info(TRANSACTION_BEGIN)
+        conn.autocommit = false
+        conn
+      end
+      
+      def commit_transaction(conn)
+        log_info(TRANSACTION_COMMIT)
+        conn.commit
+      end
 
       def disconnect_connection(c)
         c.logoff
       end
+      
+      def remove_transaction(conn)
+        conn.autocommit = true
+        super
+      end
+      
+      def rollback_transaction(conn)
+        log_info(TRANSACTION_ROLLBACK)
+        conn.rollback
+      end
     end
     
     class Dataset < Sequel::Dataset

data/lib/sequel/adapters/postgres.rb

@@ -115,6 +115,11 @@ module Sequel
       include Sequel::Postgres::AdapterMethods
       self.translate_results = false if respond_to?(:translate_results=)
       
+      # Hash of prepared statements for this connection.  Keys are
+      # string names of the server side prepared statement, and values
+      # are SQL strings.
+      attr_reader(:prepared_statements) if SEQUEL_POSTGRES_USES_PG
+      
       # Apply connection settings for this connection.  Current sets
       # the date style to ISO in order make Date object creation in ruby faster,
       # if Postgres.use_iso_date_format is true.
@@ -125,6 +130,7 @@ module Sequel
           @db.log_info(sql)
           execute(sql)
         end
+        @prepared_statements = {} if SEQUEL_POSTGRES_USES_PG
       end
 
       # Execute the given SQL with this connection.  If a block is given,
@@ -151,21 +157,6 @@ module Sequel
         end
       end
 
-      # Reapply the connection settings if the connection is reset.
-      def reset(*args, &block)
-        super(*args, &block)
-        apply_connection_settings
-      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.

data/lib/sequel/adapters/shared/mssql.rb

@@ -67,7 +67,7 @@ module Sequel
       
       def multi_insert_sql(columns, values)
         values = values.map {|r| "SELECT #{expression_list(r)}" }.join(" UNION ALL ")
-        ["INSERT INTO #{source_list(@opts[:from])} (#{identifier_list(columns)}) #{values}"]
+        ["#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) #{values}"]
       end
 
       # Allows you to do .nolock on a query

data/lib/sequel/adapters/shared/mysql.rb

@@ -1,4 +1,4 @@
-Sequel.require 'adapters/utils/unsupported'
+Sequel.require %w'unsupported savepoint_transactions', 'adapters/utils'
 
 module Sequel
   class Database
@@ -14,6 +14,8 @@ module Sequel
     # Methods shared by Database instances that connect to MySQL,
     # currently supported by the native and JDBC adapters.
     module DatabaseMethods
+      include Sequel::Database::SavepointTransactions
+    
       AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
       CAST_TYPES = {String=>:CHAR, Integer=>:SIGNED, Time=>:DATETIME, DateTime=>:DATETIME, Numeric=>:DECIMAL, BigDecimal=>:DECIMAL, File=>:BINARY}
       PRIMARY = 'PRIMARY'.freeze
@@ -33,17 +35,22 @@ module Sequel
       # Values are subhashes with two keys, :columns and :unique.  The value of :columns
       # is an array of symbols of column names.  The value of :unique is true or false
       # depending on if the index is unique.
+      #
+      # Does not include the primary key index or indexes on partial keys.
       def indexes(table)
         indexes = {}
+        remove_indexes = []
         m = output_identifier_meth
         im = input_identifier_meth
         metadata_dataset.with_sql("SHOW INDEX FROM ?", SQL::Identifier.new(im.call(table))).each do |r|
           name = r[:Key_name]
           next if name == PRIMARY
-          i = indexes[m.call(name)] ||= {:columns=>[], :unique=>r[:Non_unique] != 1}
+          name = m.call(name)
+          remove_indexes << name if r[:Sub_part]
+          i = indexes[name] ||= {:columns=>[], :unique=>r[:Non_unique] != 1}
           i[:columns] << m.call(r[:Column_name])
         end
-        indexes
+        indexes.reject{|k,v| remove_indexes.include?(k)}
       end
 
       # Get version of MySQL server, used for determined capabilities.
@@ -66,7 +73,7 @@ module Sequel
       def use(db_name)
         disconnect
         @opts[:database] = db_name if self << "USE #{db_name}"
-        @schemas = nil
+        @schemas = {}
         self
       end
       
@@ -105,6 +112,13 @@ module Sequel
         AUTO_INCREMENT
       end
       
+      # MySQL doesn't allow default values on text columns, so ignore if it the
+      # generic text type is used
+      def column_definition_sql(column)
+        column.delete(:default) if column[:type] == File || (column[:type] == String && column[:text] == true)
+        super
+      end
+      
       # Handle MySQL specific syntax for column references
       def column_references_sql(column)
         "#{", FOREIGN KEY (#{quote_identifier(column[:name])})" unless column[:type] == :check}#{super(column)}"
@@ -238,11 +252,6 @@ module Sequel
         _filter(:having, *cond, &block)
       end
       
-      # MySQL doesn't use the SQL standard DEFAULT VALUES.
-      def insert_default_values_sql
-        "INSERT INTO #{source_list(@opts[:from])} () VALUES ()"
-      end
-
       # Transforms an CROSS JOIN to an INNER JOIN if the expr is not nil.
       # Raises an error on use of :full_outer type, since MySQL doesn't support it.
       def join_table(type, table, expr=nil, table_alias={})
@@ -312,7 +321,7 @@ module Sequel
           update_string = update_cols.map{|c| "#{quote_identifier(c)}=VALUES(#{quote_identifier(c)})"}.join(COMMA_SEPARATOR)
         end
         values = values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)
-        ["INSERT#{' IGNORE' if opts[:insert_ignore]} INTO #{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}#{" ON DUPLICATE KEY UPDATE #{update_string}" if update_string}"]
+        ["#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}#{" ON DUPLICATE KEY UPDATE #{update_string}" if update_string}"]
       end
       
       # MySQL uses the nonstandard ` (backtick) for quoting identifiers.
@@ -366,6 +375,16 @@ module Sequel
 
       private
 
+      # MySQL supports INSERT IGNORE INTO
+      def insert_sql_base
+        "INSERT #{'IGNORE ' if opts[:insert_ignore]}INTO "
+      end
+
+      # MySQL doesn't use the SQL standard DEFAULT VALUES.
+      def insert_default_values_sql
+        "#{insert_sql_base}#{source_list(@opts[:from])} () VALUES ()"
+      end
+
       # Use MySQL Timestamp format
       def literal_datetime(v)
         v.strftime(TIMESTAMP_FORMAT)

data/lib/sequel/adapters/shared/oracle.rb

@@ -10,14 +10,6 @@ module Sequel
         self << create_sequence_sql(name, opts)
       end
 
-      def create_table(name, options={}, &block)
-        options = {:generator=>options} if options.is_a?(Schema::Generator)
-        generator = options[:generator] || Schema::Generator.new(self, &block)
-        drop_statement, create_statements = create_table_sql_list(name, generator, options)
-        (execute_ddl(drop_statement) rescue nil) if drop_statement
-        (create_statements + index_sql_list(name, generator.indexes)).each{|sql| execute_ddl(sql)}
-      end
-
       def create_trigger(*args)
         self << create_trigger_sql(*args)
       end
@@ -55,6 +47,12 @@ module Sequel
         "CREATE SEQUENCE #{quote_identifier(name)} start with #{opts [:start_with]||1} increment by #{opts[:increment_by]||1} nomaxvalue"
       end
 
+      def create_table_from_generator(name, generator, options)
+        drop_statement, create_statements = create_table_sql_list(name, generator, options)
+        (execute_ddl(drop_statement) rescue nil) if drop_statement
+        create_statements.each{|sql| execute_ddl(sql)}
+      end
+
       def create_table_sql_list(name, generator, options={})
         statements = [create_table_sql(name, generator, options)]
         drop_seq_statement = nil

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

@@ -1,3 +1,5 @@
+Sequel.require 'adapters/utils/savepoint_transactions'
+
 module Sequel
   # Top level module for holding all PostgreSQL-related modules and classes
   # for Sequel.  There are a few module level accessors that are added via
@@ -163,14 +165,13 @@ module Sequel
     
     # Methods shared by Database instances that connect to PostgreSQL.
     module DatabaseMethods
+      include Sequel::Database::SavepointTransactions
+      
       PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
       RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
       SQL_BEGIN = 'BEGIN'.freeze
-      SQL_SAVEPOINT = 'SAVEPOINT autopoint_%d'.freeze
       SQL_COMMIT = 'COMMIT'.freeze
-      SQL_ROLLBACK_TO_SAVEPOINT = 'ROLLBACK TO SAVEPOINT autopoint_%d'.freeze
       SQL_ROLLBACK = 'ROLLBACK'.freeze
-      SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
       SYSTEM_TABLE_REGEXP = /^pg|sql/.freeze
 
       # Creates the function in the database.  Arguments:
@@ -269,6 +270,9 @@ module Sequel
       # Values are subhashes with two keys, :columns and :unique.  The value of :columns
       # is an array of symbols of column names.  The value of :unique is true or false
       # depending on if the index is unique.
+      #
+      # This will not output any partial indexes, indexes that aren't valid or ready,
+      # or indexes that contain anything other than simple column references.
       def indexes(table)
         m = output_identifier_meth
         im = input_identifier_meth
@@ -278,8 +282,7 @@ module Sequel
           join(:pg_index___ind, :indrelid=>:oid, im.call(table)=>:relname).
           join(:pg_class___indc, :oid=>:indexrelid).
           join(:pg_attribute___att, :attrelid=>:tab__oid, :attnum=>SQL::Function.new(:ANY, :ind__indkey)).
-          filter(:indc__relkind=>'i', :ind__indisprimary=>false).
-          exclude(0=>SQL::Function.new(:ANY, :ind__indkey)).
+          filter(:indc__relkind=>'i', :ind__indisprimary=>false, :indexprs=>nil, :indpred=>nil, :indisvalid=>true, :indisready=>true, :indcheckxmin=>false).
           order(:indc__relname, (0...32).map{|x| [SQL::Subscript.new(:ind__indkey, [x]), x]}.case(32, :att__attnum)).
           select(:indc__relname___name, :ind__indisunique___unique, :att__attname___column)
         
@@ -324,7 +327,7 @@ module Sequel
       # maximum current value of the table's primary key.
       def reset_primary_key_sequence(table)
         pk = SQL::Identifier.new(primary_key(table))
-        seq = primary_key_sequence(table)
+        return unless seq = primary_key_sequence(table)
         db = self
         seq_ds = db.from(seq.lit)
         get{setval(seq, db[table].select{coalesce(max(pk)+seq_ds.select{:increment_by}, seq_ds.select(:min_value))}, false)}
@@ -369,60 +372,10 @@ module Sequel
       # * :schema - The schema to search (default_schema by default)
       # * :server - The server to use
       def tables(opts={})
-        ds = metadata_dataset.from(:pg_class).filter(:relkind=>'r').select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server])
-        ds.join!(:pg_namespace, :oid=>:relnamespace, :nspname=>(opts[:schema]||default_schema).to_s) if opts[:schema] || default_schema
+        ds = metadata_dataset.from(:pg_class).filter(:relkind=>'r').select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace, :nspname=>(opts[:schema]||default_schema||'public').to_s) 
         m = output_identifier_meth
         block_given? ? yield(ds) : ds.map{|r| m.call(r[:relname])}
       end
-      
-      # PostgreSQL supports multi-level transactions using save points.
-      # To use a savepoint instead of reusing the current transaction,
-      # use the :savepoint=>true option.
-      def transaction(opts={})
-        synchronize(opts[:server]) do |conn|
-          return yield(conn) if @transactions.include?(Thread.current) and !opts[:savepoint]
-          conn.transaction_depth ||= 0
-          if conn.transaction_depth > 0
-            log_info(SQL_SAVEPOINT % conn.transaction_depth)
-            conn.execute(SQL_SAVEPOINT % conn.transaction_depth)
-          else
-            log_info(SQL_BEGIN)
-            conn.execute(SQL_BEGIN)
-          end
-          begin
-            conn.transaction_depth += 1
-            @transactions << Thread.current
-            yield conn
-          rescue ::Exception => e
-            if conn.transaction_depth > 1
-              log_info(SQL_ROLLBACK_TO_SAVEPOINT % [conn.transaction_depth - 1])
-              conn.execute(SQL_ROLLBACK_TO_SAVEPOINT % [conn.transaction_depth - 1])
-            else
-              log_info(SQL_ROLLBACK)
-              conn.execute(SQL_ROLLBACK) rescue nil
-              @transactions.delete(Thread.current)
-            end
-            transaction_error(e, *CONVERTED_EXCEPTIONS)
-          ensure
-            unless e
-              begin
-                if conn.transaction_depth > 1
-                  log_info(SQL_RELEASE_SAVEPOINT % [conn.transaction_depth - 1])
-                  conn.execute(SQL_RELEASE_SAVEPOINT % [conn.transaction_depth - 1])
-                else
-                  log_info(SQL_COMMIT)
-                  conn.execute(SQL_COMMIT)
-                  @transactions.delete(Thread.current)
-                end
-              rescue => e
-                log_info(e.message)
-                raise_error(e, :classes=>CONVERTED_EXCEPTIONS)
-              end
-            end
-            conn.transaction_depth -= 1
-          end
-        end
-      end
 
       private
       
@@ -459,6 +412,11 @@ module Sequel
         "CREATE TRIGGER #{name} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} ON #{quote_schema_table(table)}#{' FOR EACH ROW' if opts[:each_row]} EXECUTE PROCEDURE #{function}(#{Array(opts[:args]).map{|a| literal(a)}.join(', ')})"
       end
       
+      # The errors that the main adapters can raise, depends on the adapter being used
+      def database_error_classes
+        CONVERTED_EXCEPTIONS
+      end
+      
       # SQL for dropping a function from the database. 
       def drop_function_sql(name, opts={})
         "DROP FUNCTION#{' IF EXISTS' if opts[:if_exists]} #{name}#{sql_function_args(opts[:args])}#{' CASCADE' if opts[:cascade]}"
@@ -694,11 +652,12 @@ module Sequel
       
       # Insert given values into the database.
       def insert(*values)
-        if !@opts[:sql] and !@opts[:disable_insert_returning] and server_version >= 80200
-          clone(default_server_opts(:sql=>insert_returning_pk_sql(*values))).single_value
+        if @opts[:sql]
+          execute_insert(insert_sql(*values))
+        elsif @opts[:disable_insert_returning] || server_version < 80200
+          execute_insert(insert_sql(*values), :table=>opts[:from].first, :values=>values.size == 1 ? values.first : values)
         else
-          execute_insert(insert_sql(*values), :table=>opts[:from].first,
-            :values=>values.size == 1 ? values.first : values)
+          clone(default_server_opts(:sql=>insert_returning_pk_sql(*values))).single_value
         end
       end
 
@@ -731,50 +690,47 @@ module Sequel
         
         # postgresql 8.2 introduces support for multi-row insert
         values = values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)
-        ["INSERT INTO #{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}"]
+        ["#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}"]
       end
       
       private
       
       # Use the RETURNING clause to return the primary key of the inserted record, if it exists
       def insert_returning_pk_sql(*values)
-        pk = db.primary_key(opts[:from].first)
+        pk = db.primary_key(opts[:from].first) if opts[:from] && !opts[:from].empty?
         insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : NULL, *values)
       end
       
+      # Use a generic blob quoting method, hopefully overridden in one of the subadapter methods
       def literal_blob(v)
         "'#{v.gsub(/[\000-\037\047\134\177-\377]/){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"}}'"
       end
 
+      # PostgreSQL supports fractional timestamps
       def literal_datetime(v)
         "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d", (v.sec_fraction * 86400000000).to_i)}'"
       end
 
+      # PostgreSQL uses FALSE for false values
       def literal_false
         BOOL_FALSE
       end
 
+      # Assume that SQL standard quoting is on, per Sequel's defaults
       def literal_string(v)
         "'#{v.gsub("'", "''")}'"
       end
 
+      # PostgreSQL uses FALSE for false values
       def literal_true
         BOOL_TRUE
       end
 
+      # PostgreSQL supports fractional times
       def literal_time(v)
         "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d",v.usec)}'"
       end
 
-      # PostgreSQL is smart and can use parantheses around all datasets to get
-      # the correct answers.
-      def select_compounds_sql(sql)
-        return unless @opts[:compounds]
-        @opts[:compounds].each do |type, dataset, all|
-          sql.replace("(#{sql} #{type.to_s.upcase}#{' ALL' if all} #{subselect_sql(dataset)})")
-        end
-      end
-
       # The order of clauses in the SELECT SQL statement
       def select_clause_order
         SELECT_CLAUSE_ORDER