sequel 3.48.0 → 4.0.0

data/lib/sequel/database/schema_methods.rb

@@ -46,7 +46,7 @@ module Sequel
     # :ignore_errors :: Ignore any DatabaseErrors that are raised
     #
     # See <tt>alter_table</tt>.
-    def add_index(table, columns, options={})
+    def add_index(table, columns, options=OPTS)
       e = options[:ignore_errors]
       begin
         alter_table(table){add_index(columns, options)}
@@ -117,7 +117,7 @@ module Sequel
     # :name :: The name of the table to create
     # :no_index :: Set to true not to create the second index.
     # :no_primary_key :: Set to true to not create the primary key.
-    def create_join_table(hash, options={})
+    def create_join_table(hash, options=OPTS)
       keys = hash.keys.sort_by{|k| k.to_s}
       create_table(join_table_name(hash, options), options) do
         keys.each do |key|
@@ -158,7 +158,7 @@ module Sequel
     # :unlogged :: Create the table as an unlogged table.
     #
     # See <tt>Schema::Generator</tt> and the {"Schema Modification" guide}[link:files/doc/schema_modification_rdoc.html].
-    def create_table(name, options={}, &block)
+    def create_table(name, options=OPTS, &block)
       remove_cached_schema(name)
       options = {:generator=>options} if options.is_a?(Schema::CreateTableGenerator)
       if sql = options[:as]
@@ -178,7 +178,7 @@ module Sequel
     #   # SELECT NULL FROM a LIMIT 1 -- check existence
     #   # DROP TABLE a -- drop table if already exists
     #   # CREATE TABLE a (a integer)
-    def create_table!(name, options={}, &block)
+    def create_table!(name, options=OPTS, &block)
       drop_table?(name)
       create_table(name, options, &block)
     end
@@ -188,7 +188,7 @@ module Sequel
     #   DB.create_table?(:a){Integer :a} 
     #   # SELECT NULL FROM a LIMIT 1 -- check existence
     #   # CREATE TABLE a (a integer) -- if it doesn't already exist
-    def create_table?(name, options={}, &block)
+    def create_table?(name, options=OPTS, &block)
       if supports_create_table_if_not_exists?
         create_table(name, options.merge(:if_not_exists=>true), &block)
       elsif !table_exists?(name)
@@ -209,7 +209,7 @@ module Sequel
     #
     # For databases where replacing a view is not natively supported, support
     # is emulated by dropping a view with the same name before creating the view.
-    def create_or_replace_view(name, source, options = {})
+    def create_or_replace_view(name, source, options = OPTS)
       if supports_create_or_replace_view?
         options = options.merge(:replace=>true)
       else
@@ -224,9 +224,23 @@ module Sequel
     #   DB.create_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
     #   DB.create_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
     #
+    # Options:
+    # :columns :: The column names to use for the view.  If not given,
+    #             automatically determined based on the input dataset.
+    #
     # PostgreSQL/SQLite specific option:
     # :temp :: Create a temporary view, automatically dropped on disconnect.
-    def create_view(name, source, options = {})
+    #
+    # PostgreSQL specific option:
+    # :materialized :: Creates a materialized view, similar to a regular view,
+    #                  but backed by a physical table.
+    # :recursive :: Creates a recursive view.  As columns must be specified for
+    #               recursive views, you can also set them as the value of this
+    #               option.  Since a recursive view requires a union that isn't
+    #               in a subquery, if you are providing a Dataset as the source
+    #               argument, if should probably call the union method with the
+    #               :all=>true and :from_self=>false options.
+    def create_view(name, source, options = OPTS)
       execute_ddl(create_view_sql(name, source, options))
       remove_cached_schema(name)
       nil
@@ -247,7 +261,7 @@ module Sequel
     #   DB.drop_index :posts, [:author, :title]
     #
     # See <tt>alter_table</tt>.
-    def drop_index(table, columns, options={})
+    def drop_index(table, columns, options=OPTS)
       alter_table(table){drop_index(columns, options)}
     end
 
@@ -256,7 +270,7 @@ module Sequel
     #
     #   drop_join_table(:cat_id=>:cats, :dog_id=>:dogs)
     #   # DROP TABLE cats_dogs
-    def drop_join_table(hash, options={})
+    def drop_join_table(hash, options=OPTS)
       drop_table(join_table_name(hash, options), options)
     end
     
@@ -299,6 +313,13 @@ module Sequel
     #   DB.drop_view(:cheap_items)
     #   DB.drop_view(:cheap_items, :pricey_items)
     #   DB.drop_view(:cheap_items, :pricey_items, :cascade=>true)
+    #
+    # Options:
+    # :cascade :: Also drop objects depending on this view.
+    #
+    # PostgreSQL specific options:
+    # :if_exists :: Do not raise an error if the view does not exist.
+    # :materialized :: Drop a materialized view.
     def drop_view(*names)
       options = names.last.is_a?(Hash) ? names.pop : {}
       names.each do |n|
@@ -542,7 +563,10 @@ module Sequel
       case constraint[:type]
       when :check
         check = constraint[:check]
-        sql << "CHECK #{filter_expr((check.is_a?(Array) && check.length == 1) ? check.first : check)}"
+        check = check.first if check.is_a?(Array) && check.length == 1
+        check = filter_expr(check)
+        check = "(#{check})" unless check[0..0] == '(' && check[-1..-1] == ')'
+        sql << "CHECK #{check}"
       when :primary_key
         sql << "PRIMARY KEY #{literal(constraint[:columns])}"
       when :foreign_key
@@ -631,22 +655,32 @@ module Sequel
       "CREATE #{temporary_table_sql if options[:temp]}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
     end
 
+    # DDL fragment for initial part of CREATE VIEW statement
+    def create_view_prefix_sql(name, options)
+      create_view_sql_append_columns("CREATE #{'OR REPLACE 'if options[:replace]}VIEW #{quote_schema_table(name)}", options[:columns])
+    end
+
     # DDL statement for creating a view.
     def create_view_sql(name, source, options)
       source = source.sql if source.is_a?(Dataset)
       "#{create_view_prefix_sql(name, options)} AS #{source}"
     end
 
-    # DDL fragment for initial part of CREATE VIEW statement
-    def create_view_prefix_sql(name, options)
-      "CREATE #{'OR REPLACE 'if options[:replace]}VIEW #{quote_schema_table(name)}"
+    # Append the column list to the SQL, if a column list is given.
+    def create_view_sql_append_columns(sql, columns)
+      if columns
+        sql << ' ('
+        schema_utility_dataset.send(:identifier_list_append, sql, columns)
+        sql << ')'
+      end
+      sql
     end
 
     # Default index name for the table and columns, may be too long
     # for certain databases.
     def default_index_name(table_name, columns)
       schema, table = schema_and_table(table_name)
-      "#{"#{schema}_" if schema and schema != _default_schema}#{table}_#{columns.map{|c| [String, Symbol].any?{|cl| c.is_a?(cl)} ? c : literal(c).gsub(/\W/, '_')}.join(UNDERSCORE)}_index"
+      "#{"#{schema}_" if schema}#{table}_#{columns.map{|c| [String, Symbol].any?{|cl| c.is_a?(cl)} ? c : literal(c).gsub(/\W/, '_')}.join(UNDERSCORE)}_index"
     end
   
     # Get foreign key name for given table and columns.
@@ -752,12 +786,6 @@ module Sequel
       "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_schema_table(new_name)}"
     end
 
-    # REMOVE40
-    def reset_schema_utility_dataset
-      Sequel::Deprecation.deprecate('Database#reset_schema_utility_dataset', 'Switch to Database#reset_default_dataset')
-      reset_default_dataset
-    end
-
     # Split the schema information from the table
     def schema_and_table(table_name)
       schema_utility_dataset.schema_and_table(table_name)

data/lib/sequel/database/transactions.rb

@@ -36,10 +36,6 @@ module Sequel
     #
     # The following general options are respected:
     #
-    # :disconnect :: If set to :retry, automatically sets the :retry_on option
-    #                with a Sequel::DatabaseDisconnectError.  This option is only
-    #                present for backwards compatibility, please use the :retry_on
-    #                option instead.
     # :isolation :: The transaction isolation level to use for this transaction,
     #               should be :uncommitted, :committed, :repeatable, or :serializable,
     #               used if given and the database/adapter supports customizable
@@ -72,13 +68,7 @@ module Sequel
     # :synchronous :: if non-nil, set synchronous_commit
     #                 appropriately.  Valid values true, :on, false, :off, :local (9.1+),
     #                 and :remote_write (9.2+).
-    def transaction(opts={}, &block)
-      if opts[:disconnect] == :retry
-        Sequel::Deprecation.deprecate('Database#transaction :disconnect=>:retry option', 'Please switch to :retry_on=>Sequel::DatabaseDisconnectError.')
-        raise(Error, 'cannot specify both :disconnect=>:retry and :retry_on') if opts[:retry_on]
-        return transaction(opts.merge(:retry_on=>Sequel::DatabaseDisconnectError, :disconnect=>nil), &block)
-      end
-
+    def transaction(opts=OPTS, &block)
       if retry_on = opts[:retry_on]
         num_retries = opts.fetch(:num_retries, 5)
         begin
@@ -96,7 +86,7 @@ module Sequel
         synchronize(opts[:server]) do |conn|
           if already_in_transaction?(conn, opts)
             if opts[:retrying]
-              raise Sequel::Error, "cannot set :disconnect=>:retry or :retry_on options if you are already inside a transaction"
+              raise Sequel::Error, "cannot set :retry_on options if you are already inside a transaction"
             end
             return yield(conn)
           end
@@ -111,7 +101,7 @@ module Sequel
     # block will cause the transaction to be rolled back.  If the exception is
     # not a Sequel::Rollback, the error will be reraised. If no exception occurs
     # inside the block, the transaction is commited.
-    def _transaction(conn, opts={})
+    def _transaction(conn, opts=OPTS)
       rollback = opts[:rollback]
       begin
         add_transaction(conn, opts)
@@ -207,7 +197,7 @@ module Sequel
     end
 
     # Start a new database transaction or a new savepoint on the given connection.
-    def begin_transaction(conn, opts={})
+    def begin_transaction(conn, opts=OPTS)
       if supports_savepoints?
         th = _trans(conn)
         if (depth = th[:savepoint_level]) > 0
@@ -266,7 +256,7 @@ module Sequel
     end
 
     # Commit the active transaction on the connection
-    def commit_transaction(conn, opts={})
+    def commit_transaction(conn, opts=OPTS)
       if supports_savepoints?
         depth = _trans(conn)[:savepoint_level]
         log_connection_execute(conn, depth > 1 ? commit_savepoint_sql(depth-1) : commit_transaction_sql)
@@ -307,7 +297,7 @@ module Sequel
     end
 
     # Rollback the active transaction on the connection
-    def rollback_transaction(conn, opts={})
+    def rollback_transaction(conn, opts=OPTS)
       if supports_savepoints?
         depth = _trans(conn)[:savepoint_level]
         log_connection_execute(conn, depth > 1 ? rollback_savepoint_sql(depth-1) : rollback_transaction_sql)
@@ -334,7 +324,7 @@ module Sequel
     end
 
     # Raise a database error unless the exception is an Rollback.
-    def transaction_error(e, opts={})
+    def transaction_error(e, opts=OPTS)
       if e.is_a?(Rollback)
         raise e if opts[:rollback] == :reraise
       else

data/lib/sequel/dataset.rb

@@ -23,6 +23,8 @@ module Sequel
   #
   # For more information, see the {"Dataset Basics" guide}[link:files/doc/dataset_basics_rdoc.html].
   class Dataset
+    OPTS = Sequel::OPTS
+
     include Enumerable
     include SQL::AliasMethods
     include SQL::BooleanMethods

data/lib/sequel/dataset/actions.rb

@@ -34,16 +34,6 @@ module Sequel
       first(*conditions)
     end
 
-    # Update all records matching the conditions with the values specified.
-    # Returns the number of rows affected.
-    #
-    #   DB[:table][:id=>1] = {:id=>2} # UPDATE table SET id = 2 WHERE id = 1
-    #   # => 1 # number of rows affected
-    def []=(conditions, values)
-      Sequel::Deprecation.deprecate('Dataset#[]=', 'Please load the sequel_3_dataset_methods extension to continue using it')
-      filter(conditions).update(values)
-    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.
     #
@@ -148,9 +138,7 @@ module Sequel
     # running queries inside the block, you should use +all+ instead of +each+
     # for the outer queries, or use a separate thread or shard inside +each+.
     def each
-      if @opts[:graph]
-        graph_each{|r| yield r}
-      elsif row_proc = @row_proc
+      if row_proc = @row_proc
         fetch_rows(select_sql){|r| yield row_proc.call(r)}
       else
         fetch_rows(select_sql){|r| yield r}
@@ -166,15 +154,6 @@ module Sequel
       get(Sequel::SQL::AliasedExpression.new(1, :one)).nil?
     end
 
-    # Executes a select query and fetches records, yielding each record to the
-    # supplied block.  The yielded records should be hashes with symbol keys.
-    # This method should probably should not be called by user code, use +each+
-    # instead.
-    def fetch_rows(sql)
-      Sequel::Deprecation.deprecate('Dataset#fetch_rows default implementation and Sequel::NotImplemented', 'All dataset instances can be assumed to implement fetch_rows')
-      raise NotImplemented, NOTIMPL_MSG
-    end
-    
     # If a integer argument is given, it is interpreted as a limit, and then returns all 
     # matching records up to that limit.  If no argument is passed,
     # it returns the first matching record.  If any other type of
@@ -237,7 +216,7 @@ module Sequel
     #   DB[:table].get(:id) # SELECT id FROM table LIMIT 1
     #   # => 3
     #
-    #   ds.get{sum(id)} # SELECT sum(id) FROM table LIMIT 1
+    #   ds.get{sum(id)} # SELECT sum(id) AS v FROM table LIMIT 1
     #   # => 6
     #
     # You can pass an array of arguments to return multiple arguments,
@@ -260,7 +239,7 @@ module Sequel
         ds = if column.is_a?(Array)
           ds.select(*column)
         else
-          ds.select(column)
+          ds.select(auto_alias_expression(column))
         end
       end
 
@@ -296,7 +275,7 @@ module Sequel
     # :server :: Set the server/shard to use for the transaction and insert
     #            queries.
     # :slice :: Same as :commit_every, :commit_every takes precedence.
-    def import(columns, values, opts={})
+    def import(columns, values, opts=OPTS)
       return @db.transaction{insert(columns, values)} if values.is_a?(Dataset)
 
       return if values.empty?
@@ -360,30 +339,6 @@ module Sequel
       end
     end
     
-    # Inserts multiple values. If a block is given it is invoked for each
-    # item in the given array before inserting it.  See +multi_insert+ as
-    # a possibly faster version that may be able to insert multiple
-    # records in one SQL statement (if supported by the database).
-    # Returns an array of primary keys of inserted rows.
-    #
-    #   DB[:table].insert_multiple([{:x=>1}, {:x=>2}])
-    #   # => [4, 5]
-    #   # INSERT INTO table (x) VALUES (1)
-    #   # INSERT INTO table (x) VALUES (2)
-    #
-    #   DB[:table].insert_multiple([{:x=>1}, {:x=>2}]){|row| row[:y] = row[:x] * 2; row }
-    #   # => [6, 7]
-    #   # INSERT INTO table (x, y) VALUES (1, 2)
-    #   # INSERT INTO table (x, y) VALUES (2, 4)
-    def insert_multiple(array, &block)
-      Sequel::Deprecation.deprecate('Dataset#insert_multiple', 'Please load the sequel_3_dataset_methods extension to continue using it')
-      if block
-        array.map{|i| insert(block.call(i))}
-      else
-        array.map{|i| insert(i)}
-      end
-    end
-    
     # Returns the interval between minimum and maximum values for the given 
     # column/expression. Uses a virtual row block if no argument is given.
     #
@@ -472,7 +427,7 @@ module Sequel
     # values.
     #
     # This respects the same options as #import.
-    def multi_insert(hashes, opts={})
+    def multi_insert(hashes, opts=OPTS)
       return if hashes.empty?
       columns = hashes.first.keys
       import(columns, hashes.map{|h| columns.map{|c| h[c]}}, opts)
@@ -491,7 +446,7 @@ module Sequel
     #
     # Options:
     # :rows_per_fetch :: The number of rows to fetch per query.  Defaults to 1000.
-    def paged_each(opts={})
+    def paged_each(opts=OPTS)
       unless @opts[:order]
         raise Sequel::Error, "Dataset#paged_each requires the dataset be ordered"
       end
@@ -622,13 +577,6 @@ module Sequel
       _select_map(column, true, &block)
     end
 
-    # Alias for update, but not aliased directly so subclasses
-    # don't have to override both methods.
-    def set(*args)
-      Sequel::Deprecation.deprecate('Dataset#set', 'Please switch to Dataset#update or load the sequel_3_dataset_methods extension to continue using it')
-      update(*args)
-    end
-    
     # Returns the first record in the dataset, or nil if the dataset
     # has no records. Users should probably use +first+ instead of
     # this method.
@@ -657,29 +605,6 @@ module Sequel
       aggregate_dataset.get{sum(column).as(:sum)}
     end
 
-    # Returns a string in CSV format containing the dataset records. By 
-    # default the CSV representation includes the column titles in the
-    # first line. You can turn that off by passing false as the 
-    # include_column_titles argument.
-    #
-    # This does not use a CSV library or handle quoting of values in
-    # any way.  If any values in any of the rows could include commas or line
-    # endings, you shouldn't use this.
-    #
-    #   puts DB[:table].to_csv # SELECT * FROM table
-    #   # id,name
-    #   # 1,Jim
-    #   # 2,Bob
-    def to_csv(include_column_titles = true)
-      Sequel::Deprecation.deprecate('Dataset#to_csv', 'Please load the sequel_3_dataset_methods extension to continue using it')
-      n = naked
-      cols = n.columns
-      csv = ''
-      csv << "#{cols.join(COMMA_SEPARATOR)}\r\n" if include_column_titles
-      n.each{|r| csv << "#{cols.collect{|c| r[c]}.join(COMMA_SEPARATOR)}\r\n"}
-      csv
-    end
-    
     # Returns a hash with one column used as key and another used as value.
     # If rows have duplicate values for the key column, the latter row(s)
     # will overwrite the value of the previous row(s). If the value_column
@@ -785,7 +710,7 @@ module Sequel
     #
     #   DB[:table].update(:x=>:x+1, :y=>0) # UPDATE table SET x = (x + 1), y = 0
     #   # => 10
-    def update(values={}, &block)
+    def update(values=OPTS, &block)
       sql = update_sql(values)
       if uses_returning?(:update)
         returning_fetch_rows(sql, &block)
@@ -840,12 +765,21 @@ module Sequel
       columns = Array(column)
       virtual_row_columns(columns, block)
       select_cols = order ? columns.map{|c| c.is_a?(SQL::OrderedExpression) ? c.expression : c} : columns
-      ds = ds.select(*select_cols)
       ds = ds.order(*columns.map{|c| unaliased_identifier(c)}) if order
       if column.is_a?(Array) || (columns.length > 1)
-        ds._select_map_multiple(hash_key_symbols(select_cols))
+        ds.select(*select_cols)._select_map_multiple(hash_key_symbols(select_cols))
+      else
+        ds.select(auto_alias_expression(select_cols.first))._select_map_single
+      end
+    end
+
+    # Automatically alias the given expression if it does not have an identifiable alias.
+    def auto_alias_expression(v)
+      case v
+      when LiteralString, Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression
+        v
       else
-        ds._select_map_single
+        SQL::AliasedExpression.new(v, :v)
       end
     end
 
@@ -856,23 +790,23 @@ module Sequel
 
     # Execute the given select SQL on the database using execute. Use the
     # :read_only server unless a specific server is set.
-    def execute(sql, opts={}, &block)
+    def execute(sql, opts=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)
+    def execute_ddl(sql, opts=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)
+    def execute_dui(sql, opts=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)
+    def execute_insert(sql, opts=OPTS, &block)
       @db.execute_insert(sql, default_server_opts(opts), &block)
     end
     
@@ -903,8 +837,6 @@ module Sequel
     def hash_key_symbol(s)
       if v = _hash_key_symbol(s)
         v
-      elsif block_given?
-        yield
       else
         raise(Error, "#{s.inspect} is not supported, should be a Symbol, SQL::Identifier, SQL::QualifiedIdentifier, or SQL::AliasedExpression")
       end