sequel 3.5.0 → 3.6.0

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

@@ -1,4 +1,7 @@
 module Sequel
+  Dataset::NON_SQL_OPTIONS << :insert_ignore
+  Dataset::NON_SQL_OPTIONS << :on_duplicate_key_update
+
   module MySQL
     class << self
       # Set the default options used for CREATE TABLE
@@ -311,37 +314,7 @@ module Sequel
       # MySQL specific syntax for REPLACE (aka UPSERT, or update if exists,
       # insert if it doesn't).
       def replace_sql(*values)
-        from = source_list(@opts[:from])
-        if values.empty?
-          "REPLACE INTO #{from} DEFAULT VALUES"
-        else
-          values = values[0] if values.size == 1
-          
-          case values
-          when Array
-            if values.empty?
-              "REPLACE INTO #{from} DEFAULT VALUES"
-            else
-              "REPLACE INTO #{from} VALUES #{literal(values)}"
-            end
-          when Hash
-            if values.empty?
-              "REPLACE INTO #{from} DEFAULT VALUES"
-            else
-              fl, vl = [], []
-              values.each {|k, v| fl << literal(k.is_a?(String) ? k.to_sym : k); vl << literal(v)}
-              "REPLACE INTO #{from} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
-            end
-          when Dataset
-            "REPLACE INTO #{from} #{literal(values)}"
-          else
-            if values.respond_to?(:values)
-              replace_sql(values.values)
-            else  
-              "REPLACE INTO #{from} VALUES (#{literal(values)})"
-            end
-          end
-        end
+        clone(:replace=>true).insert_sql(*values)
       end
       
       #  does not support DISTINCT ON
@@ -360,6 +333,13 @@ module Sequel
       def supports_timestamp_usecs?
         false
       end
+      
+      protected
+      
+      # If this is an replace instead of an insert, use replace instead
+      def _insert_sql
+        @opts[:replace] ? clause_sql(:replace) : super
+      end
 
       private
 
@@ -372,6 +352,7 @@ module Sequel
       def insert_clause_methods
         INSERT_CLAUSE_METHODS
       end
+      alias replace_clause_methods insert_clause_methods
 
       # MySQL doesn't use the SQL standard DEFAULT VALUES.
       def insert_columns_sql(sql)

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

@@ -1,4 +1,6 @@
 module Sequel
+  Dataset::NON_SQL_OPTIONS << :disable_insert_returning
+
   # Top level module for holding all PostgreSQL-related modules and classes
   # for Sequel.  There are a few module level accessors that are added via
   # metaprogramming.  These are:
@@ -601,7 +603,7 @@ module Sequel
           return @prepared_sql if @prepared_sql
           super
           if @prepared_type == :insert and !@opts[:disable_insert_returning] and server_version >= 80200
-            @prepared_sql = insert_returning_pk_sql(@prepared_modify_values)
+            @prepared_sql = insert_returning_pk_sql(*@prepared_modify_values)
             meta_def(:insert_returning_pk_sql){|*args| prepared_sql}
           end
           @prepared_sql
@@ -672,17 +674,18 @@ module Sequel
         naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record
       end
 
-      # Locks the table with the specified mode.
-      def lock(mode, server=nil)
-        sql = LOCK % [source_list(@opts[:from]), mode]
-        @db.synchronize(server) do
-          if block_given? # perform locking inside a transaction and yield to block
-            @db.transaction(server){@db.execute(sql, :server=>server); yield}
-          else
-            @db.execute(sql, :server=>server) # lock without a transaction
-            self
-          end
+      # Locks all tables in the dataset's FROM clause (but not in JOINs) with
+      # the specified mode (e.g. 'EXCLUSIVE').  If a block is given, starts
+      # a new transaction, locks the table, and yields.  If a block is not given
+      # just locks the tables.  Note that PostgreSQL will probably raise an error
+      # if you lock the table outside of an existing transaction.  Returns nil.
+      def lock(mode, opts={})
+        if block_given? # perform locking inside a transaction and yield to block
+          @db.transaction(opts){lock(mode, opts); yield}
+        else
+          @db.execute(LOCK % [source_list(@opts[:from]), mode], opts) # lock without a transaction
         end
+        nil
       end
       
       # For PostgreSQL version > 8.2, allow inserting multiple rows at once.
@@ -705,7 +708,7 @@ module Sequel
 
       # Return a clone of the dataset with an addition named window that can be referenced in window functions.
       def window(name, opts)
-        clone(:window=>(@opts[:windows]||[]) + [[name, SQL::Window.new(opts)]])
+        clone(:window=>(@opts[:window]||[]) + [[name, SQL::Window.new(opts)]])
       end
       
       private

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

@@ -265,6 +265,19 @@ module Sequel
         @opts[:where] ? super : filter(1=>1).delete
       end
       
+      # Return an array of strings specifying a query explanation for a SELECT of the
+      # current dataset.
+      def explain
+        db.send(:metadata_dataset).clone(:sql=>"EXPLAIN #{select_sql}").
+          map{|x| "#{x[:addr]}|#{x[:opcode]}|#{(1..5).map{|i| x[:"p#{i}"]}.join('|')}|#{x[:comment]}"}
+      end
+      
+      # HAVING requires GROUP BY on SQLite
+      def having(*cond, &block)
+        raise(InvalidOperation, "Can only specify a HAVING clause on a grouped dataset") unless @opts[:group]
+        super
+      end
+      
       # SQLite uses the nonstandard ` (backtick) for quoting identifiers.
       def quoted_identifier(c)
         "`#{c}`"
@@ -280,6 +293,11 @@ module Sequel
         false
       end
       
+      # SQLite does not support multiple columns for the IN/NOT IN operators
+      def supports_multiple_column_in?
+        false
+      end
+      
       # SQLite supports timezones in literal timestamps, since it stores them
       # as text.
       def supports_timestamp_timezones?

data/lib/sequel/adapters/sqlite.rb

@@ -122,7 +122,6 @@ module Sequel
     class Dataset < Sequel::Dataset
       include ::Sequel::SQLite::DatasetMethods
       
-      EXPLAIN = 'EXPLAIN %s'.freeze
       PREPARED_ARG_PLACEHOLDER = ':'.freeze
       
       # SQLite already supports named bind arguments, so use directly.
@@ -172,20 +171,6 @@ module Sequel
         end
       end
       
-      # Prepare an unnamed statement of the given type and call it with the
-      # given values.
-      def call(type, hash, values=nil, &block)
-        prepare(type, nil, values).call(hash, &block)
-      end
-      
-      # Return an array of strings specifying a query explanation for the
-      # current dataset.
-      def explain
-        res = []
-        @db.result_set(EXPLAIN % select_sql(opts), nil) {|r| res << r}
-        res
-      end
-      
       # Yield a hash for each row in the dataset.
       def fetch_rows(sql)
         execute(sql) do |result|
@@ -203,7 +188,7 @@ module Sequel
       # Prepare the given type of query with the given name and store
       # it in the database.  Note that a new native prepared statement is
       # created on each call to this prepared statement.
-      def prepare(type, name=nil, values=nil)
+      def prepare(type, name=nil, *values)
         ps = to_prepared_statement(type, values)
         ps.extend(PreparedStatementMethods)
         db.prepared_statements[name] = ps if name

data/lib/sequel/connection_pool.rb

@@ -11,7 +11,7 @@ class Sequel::ConnectionPool
   # The maximum number of connections.
   attr_reader :max_size
   
-  # The mutex that protects access to the other internal vairables.  You must use
+  # The mutex that protects access to the other internal variables.  You must use
   # this if you want to manipulate the variables safely.
   attr_reader :mutex
   

data/lib/sequel/core.rb

@@ -249,7 +249,7 @@ module Sequel
   
   require(%w"metaprogramming sql connection_pool exceptions dataset database timezones version")
   require(%w"schema_generator schema_methods schema_sql", 'database')
-  require(%w"convenience graph prepared_statements sql", 'dataset')
+  require(%w"actions convenience features graph prepared_statements query sql", 'dataset')
   require('core_sql') if !defined?(::SEQUEL_NO_CORE_EXTENSIONS) && !ENV.has_key?('SEQUEL_NO_CORE_EXTENSIONS')
 
   # Add the database adapter class methods to Sequel via metaprogramming

data/lib/sequel/database.rb

@@ -576,7 +576,7 @@ module Sequel
         t = begin_transaction(conn)
         yield(conn)
       rescue Exception => e
-        rollback_transaction(t)
+        rollback_transaction(t) if t
         transaction_error(e)
       ensure
         begin

data/lib/sequel/database/schema_generator.rb

@@ -78,6 +78,8 @@ module Sequel
       #   See Schema::SQL#on_delete_clause for options.
       # * :size - The size of the column, generally used with string
       #   columns to specify the maximum number of characters the column will hold.
+      #   An array of two integers can be provided to set the size and the
+      #   precision, respectively, of decimal columns.
       # * :unique - Mark the column as unique, generally has the same effect as
       #   creating a unique index on the column.
       # * :unsigned - Make the column type unsigned, only useful for integer

data/lib/sequel/database/schema_sql.rb

@@ -159,7 +159,7 @@ module Sequel
       elsif index[:where]
         raise Error, "Partial indexes are not supported for this database"
       else
-        "CREATE #{'UNIQUE ' if index[:unique]}INDEX #{quote_identifier(index_name)} ON #{quote_identifier(table_name)} #{literal(index[:columns])}"
+        "CREATE #{'UNIQUE ' if index[:unique]}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}"
       end
     end
   

data/lib/sequel/dataset.rb

@@ -20,17 +20,6 @@ module Sequel
   #
   # Datasets are Enumerable objects, so they can be manipulated using any
   # of the Enumerable methods, such as map, inject, etc.
-  #
-  # === Methods added via metaprogramming
-  #
-  # Some methods are added via metaprogramming:
-  #
-  # * ! methods - These methods are the same as their non-! counterparts,
-  #   but they modify the receiver instead of returning a modified copy
-  #   of the dataset.
-  # * inner_join, full_outer_join, right_outer_join, left_outer_join - 
-  #   This methods are shortcuts to join_table with the join type
-  #   already specified.
   class Dataset
     extend Metaprogramming
     include Metaprogramming
@@ -50,6 +39,10 @@ module Sequel
     set_defaults set_graph_aliases set_overrides unfiltered ungraphed ungrouped union
     unlimited unordered where with with_recursive with_sql'.collect{|x| x.to_sym}
 
+    # Which options don't affect the SQL generation.  Used by simple_select_all?
+    # to determine if this is a simple SELECT * FROM table.
+    NON_SQL_OPTIONS = [:server, :defaults, :overrides]
+
     NOTIMPL_MSG = "This method must be overridden in Sequel adapters".freeze
     WITH_SUPPORTED=:select_with_sql
 
@@ -103,12 +96,6 @@ module Sequel
 
     ### Instance Methods ###
 
-    # Alias for insert, but not aliased directly so subclasses
-    # don't have to override both methods.
-    def <<(*args)
-      insert(*args)
-    end
-
     # Return the dataset as an aliased expression with the given alias. You can
     # use this as a FROM or JOIN dataset, or as a column if this dataset
     # returns a single row and column.
@@ -116,16 +103,6 @@ module Sequel
       ::Sequel::SQL::AliasedExpression.new(self, aliaz)
     end
 
-    # Returns an array with all records in the dataset. If a block is given,
-    # the array is iterated over after all items have been loaded.
-    def all(&block)
-      a = []
-      each{|r| a << r}
-      post_load(a)
-      a.each(&block) if block
-      a
-    end
-  
     # Returns a new clone of the dataset with with the given options merged.
     # If the options changed include options in COLUMN_CHANGE_OPTS, the cached
     # columns are deleted.
@@ -136,30 +113,6 @@ module Sequel
       c
     end
     
-    # Returns the columns in the result set in order.
-    # If the columns are currently cached, returns the cached value. Otherwise,
-    # a SELECT query is performed to get a single row. Adapters are expected
-    # to fill the columns cache with the column information when a query is performed.
-    # If the dataset does not have any rows, this may be an empty array depending on how
-    # the adapter is programmed.
-    #
-    # If you are looking for all columns for a single table and maybe some information about
-    # each column (e.g. type), see Database#schema.
-    def columns
-      return @columns if @columns
-      ds = unfiltered.unordered.clone(:distinct => nil, :limit => 1)
-      ds.each{break}
-      @columns = ds.instance_variable_get(:@columns)
-      @columns || []
-    end
-    
-    # Remove the cached list of columns and do a SELECT query to find
-    # the columns.
-    def columns!
-      @columns = nil
-      columns
-    end
-    
     # Add a mutation method to this dataset instance.
     def def_mutation_method(*meths)
       meths.each do |meth|
@@ -167,44 +120,6 @@ module Sequel
       end
     end
 
-    # Deletes the records in the dataset.  The returned value is generally the
-    # number of records deleted, but that is adapter dependent.  See delete_sql.
-    def delete
-      execute_dui(delete_sql)
-    end
-    
-    # Iterates over the records in the dataset as they are yielded from the
-    # database adapter, and returns self.
-    #
-    # Note that this method is not safe to use on many adapters if you are
-    # running additional queries inside the provided block.  If you are
-    # running queries inside the block, you use should all instead of each.
-    def each(&block)
-      if @opts[:graph]
-        graph_each(&block)
-      else
-        if row_proc = @row_proc
-          fetch_rows(select_sql){|r| yield row_proc.call(r)}
-        else
-          fetch_rows(select_sql, &block)
-        end
-      end
-      self
-    end
-
-    # Executes a select query and fetches records, passing each record to the
-    # supplied block.  The yielded records should be hashes with symbol keys.
-    def fetch_rows(sql, &block)
-      raise NotImplementedError, NOTIMPL_MSG
-    end
-  
-    # Inserts values into the associated table.  The returned value is generally
-    # the value of the primary key for the inserted row, but that is adapter dependent.
-    # See insert_sql.
-    def insert(*values)
-      execute_insert(insert_sql(*values))
-    end
-  
     # Returns a string representation of the dataset including the class name 
     # and the corresponding SQL select statement.
     def inspect
@@ -219,17 +134,6 @@ module Sequel
       ds
     end
     
-    # Whether this dataset quotes identifiers.
-    def quote_identifiers?
-      @quote_identifiers
-    end
-    
-    # Whether the dataset requires SQL standard datetimes (false by default,
-    # as most allow strings with ISO 8601 format.
-    def requires_sql_standard_datetimes?
-      false
-    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 (which is SELECT uses
     # :read_only database and all other queries use the :default database).
@@ -237,12 +141,6 @@ module Sequel
       clone(:server=>servr)
     end
 
-    # Alias for set, but not aliased directly so subclasses
-    # don't have to override both methods.
-    def set(*args)
-      update(*args)
-    end
-
     # Set the default values for insert and update statements.  The values hash passed
     # to insert or update are merged into this hash.
     def set_defaults(hash)
@@ -255,57 +153,6 @@ module Sequel
       clone(:overrides=>hash.merge(@opts[:overrides]||{}))
     end
     
-    # Whether the dataset supports common table expressions (the WITH clause).
-    def supports_cte?
-      select_clause_methods.include?(WITH_SUPPORTED)
-    end
-
-    # Whether the dataset supports the DISTINCT ON clause, true by default.
-    def supports_distinct_on?
-      true
-    end
-
-    # Whether the dataset supports the INTERSECT and EXCEPT compound operations, true by default.
-    def supports_intersect_except?
-      true
-    end
-
-    # Whether the dataset supports the INTERSECT ALL and EXCEPT ALL compound operations, true by default.
-    def supports_intersect_except_all?
-      true
-    end
-
-    # Whether the dataset supports the IS TRUE syntax.
-    def supports_is_true?
-      true
-    end
-    
-    # Whether the dataset supports timezones in literal timestamps
-    def supports_timestamp_timezones?
-      false
-    end
-    
-    # Whether the dataset supports fractional seconds in literal timestamps
-    def supports_timestamp_usecs?
-      true
-    end
-    
-    # Whether the dataset supports window functions.
-    def supports_window_functions?
-      false
-    end
-    
-    # Truncates the dataset.  Returns nil.
-    def truncate
-      execute_ddl(truncate_sql)
-    end
-
-    # Updates values for the dataset.  The returned value is generally the
-    # number of rows updated, but that is adapter dependent.  See update_sql.
-    def update(values={})
-      execute_dui(update_sql(values))
-    end
-  
     # Add the mutation methods via metaprogramming
     def_mutation_method(*MUTATION_METHODS)
 
@@ -318,7 +165,7 @@ module Sequel
 
     # Whether this dataset is a simple SELECT * FROM table.
     def simple_select_all?
-      o = @opts.reject{|k,v| v.nil?}
+      o = @opts.reject{|k,v| v.nil? || NON_SQL_OPTIONS.include?(k)}
       o.length == 1 && (f = o[:from]) && f.length == 1 && f.first.is_a?(Symbol)
     end
 
@@ -329,27 +176,6 @@ module Sequel
       {:server=>@opts[:server] || :default}.merge(opts)
     end
 
-    # 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_ddl.
-    def execute_ddl(sql, opts={}, &block)
-      @db.execute_ddl(sql, default_server_opts(opts), &block)
-      nil
-    end
-    
-    # Execute the given SQL on the database using execute_dui.
-    def execute_dui(sql, opts={}, &block)
-      @db.execute_dui(sql, default_server_opts(opts), &block)
-    end
-    
-    # Execute the given SQL on the database using execute_insert.
-    def execute_insert(sql, opts={}, &block)
-      @db.execute_insert(sql, default_server_opts(opts), &block)
-    end
-    
     # Modify the identifier returned from the database based on the
     # identifier_output_method.
     def input_identifier(v)