sequel 4.13.0 → 4.14.0

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

@@ -187,7 +187,7 @@ module Sequel
       # Array of symbols specifying the table names in the current database.
       #
       # Options:
-      # * :server - Set the server to use.
+      # :server :: Set the server to use.
       def tables(opts=OPTS)
         tables_and_views(TABLES_FILTER, opts)
       end
@@ -207,7 +207,7 @@ module Sequel
       # Array of symbols specifying the view names in the current database.
       #
       # Options:
-      # * :server - Set the server to use.
+      # :server :: Set the server to use.
       def views(opts=OPTS)
         tables_and_views(VIEWS_FILTER, opts)
       end

data/lib/sequel/ast_transformer.rb

@@ -69,7 +69,7 @@ module Sequel
       when SQL::JoinClause
         SQL::JoinClause.new(o.join_type, v(o.table_expr))
       when SQL::DelayedEvaluation
-        SQL::DelayedEvaluation.new(lambda{v(o.callable.call)})
+        SQL::DelayedEvaluation.new(lambda{|ds| v(o.call(ds))})
       when SQL::Wrapper
         SQL::Wrapper.new(v(o.value))
       else

data/lib/sequel/connection_pool/sharded_single.rb

@@ -3,12 +3,12 @@
 class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   # The single threaded pool takes the following options:
   #
-  # * :servers - A hash of servers to use.  Keys should be symbols.  If not
-  #   present, will use a single :default server.
-  # * :servers_hash - The base hash to use for the servers.  By default,
-  #   Sequel uses Hash.new(:default).  You can use a hash with a default proc
-  #   that raises an error if you want to catch all cases where a nonexistent
-  #   server is used.
+  # :servers :: A hash of servers to use.  Keys should be symbols.  If not
+  #             present, will use a single :default server.
+  # :servers_hash :: The base hash to use for the servers.  By default,
+  #                  Sequel uses Hash.new(:default).  You can use a hash with a default proc
+  #                  that raises an error if you want to catch all cases where a nonexistent
+  #                  server is used.
   def initialize(db, opts=OPTS)
     super
     @conns = {}
@@ -36,8 +36,8 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   
   # Disconnects from the database. Once a connection is requested using
   # #hold, the connection is reestablished. Options:
-  # * :server - Should be a symbol specifing the server to disconnect from,
-  #   or an array of symbols to specify multiple servers.
+  # :server :: Should be a symbol specifing the server to disconnect from,
+  #            or an array of symbols to specify multiple servers.
   def disconnect(opts=OPTS)
     (opts[:server] ? Array(opts[:server]) : servers).each{|s| disconnect_server(s)}
   end

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -7,12 +7,12 @@ Sequel.require 'connection_pool/threaded'
 # to be removed from the pool when they are returned to it.
 class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # The following additional options are respected:
-  # * :servers - A hash of servers to use.  Keys should be symbols.  If not
-  #   present, will use a single :default server.
-  # * :servers_hash - The base hash to use for the servers.  By default,
-  #   Sequel uses Hash.new(:default).  You can use a hash with a default proc
-  #   that raises an error if you want to catch all cases where a nonexistent
-  #   server is used.
+  # :servers :: A hash of servers to use.  Keys should be symbols.  If not
+  #             present, will use a single :default server.
+  # :servers_hash :: The base hash to use for the servers.  By default,
+  #                  Sequel uses Hash.new(:default).  You can use a hash with a default proc
+  #                  that raises an error if you want to catch all cases where a nonexistent
+  #                  server is used.
   def initialize(db, opts = OPTS)
     super
     @available_connections = {}
@@ -84,8 +84,8 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # 
   # Once a connection is requested using #hold, the connection pool
   # creates new connections to the database. Options:
-  # * :server - Should be a symbol specifing the server to disconnect from,
-  #   or an array of symbols to specify multiple servers.
+  # :server :: Should be a symbol specifing the server to disconnect from,
+  #            or an array of symbols to specify multiple servers.
   def disconnect(opts=OPTS)
     sync do
       (opts[:server] ? Array(opts[:server]) : @servers.keys).each do |s|

data/lib/sequel/database/connecting.rb

@@ -244,7 +244,7 @@ module Sequel
       # server, instead of the :default server.
       #
       #   DB.synchronize do |conn|
-      #     ...
+      #     # ...
       #   end
       def synchronize(server=nil)
         @pool.hold(server || :default){|conn| yield conn}

data/lib/sequel/database/schema_generator.rb

@@ -462,6 +462,9 @@ module Sequel
       # Modify a column's default value in the DDL for the table.
       #
       #   set_column_default(:artist_name, 'a') # ALTER COLUMN artist_name SET DEFAULT 'a'
+      #
+      # On MySQL, make sure to use a symbol for the name of the column, as otherwise you
+      # can lose the type and NULL/NOT NULL setting for the column.
       def set_column_default(name, default)
         @operations << {:op => :set_column_default, :name => name, :default => default}
       end
@@ -473,6 +476,9 @@ module Sequel
       # PostgreSQL specific options:
       #
       # :using :: Add a USING clause that specifies how to convert existing values to new values.
+      #
+      # On MySQL, make sure to use a symbol for the name of the column, as otherwise you
+      # can lose the default and NULL/NOT NULL setting for the column.
       def set_column_type(name, type, opts=OPTS)
         @operations << {:op => :set_column_type, :name => name, :type => type}.merge(opts)
       end
@@ -480,6 +486,9 @@ module Sequel
       # Set a given column as allowing NULL values.
       #
       #   set_column_allow_null(:artist_name) # ALTER COLUMN artist_name DROP NOT NULL
+      #
+      # On MySQL, make sure to use a symbol for the name of the column, as otherwise you
+      # can lose the default and type for the column.
       def set_column_allow_null(name, allow_null=true)
         @operations << {:op => :set_column_null, :name => name, :null => allow_null}
       end
@@ -487,6 +496,9 @@ module Sequel
       # Set a given column as not allowing NULL values.
       #
       #   set_column_not_null(:artist_name) # ALTER COLUMN artist_name SET NOT NULL
+      #
+      # On MySQL, make sure to use a symbol for the name of the column, as otherwise you
+      # can lose the default and type for the column.
       def set_column_not_null(name)
         set_column_allow_null(name, false)
       end

data/lib/sequel/database/schema_methods.rb

@@ -792,13 +792,14 @@ module Sequel
     # SQL DDL ON DELETE fragment to use, based on the given action.
     # The following actions are recognized:
     # 
-    # * :cascade - Delete rows referencing this row.
-    # * :no_action (default) - Raise an error if other rows reference this
-    #   row, allow deferring of the integrity check.
-    # * :restrict - Raise an error if other rows reference this row,
-    #   but do not allow deferring the integrity check.
-    # * :set_default - Set columns referencing this row to their default value.
-    # * :set_null - Set columns referencing this row to NULL.
+    # :cascade :: Delete rows referencing this row.
+    # :no_action :: Raise an error if other rows reference this
+    #               row, allow deferring of the integrity check.
+    #               This is the default.
+    # :restrict :: Raise an error if other rows reference this row,
+    #              but do not allow deferring the integrity check.
+    # :set_default :: Set columns referencing this row to their default value.
+    # :set_null :: Set columns referencing this row to NULL.
     #
     # Any other object given is just converted to a string, with "_" converted to " " and upcased.
     def on_delete_clause(action)

data/lib/sequel/database/transactions.rb

@@ -128,8 +128,7 @@ module Sequel
       rescue Exception => e
         begin
           rollback_transaction(conn, opts)
-        rescue Exception => e3
-          raise_error(e3, :classes=>database_error_classes, :conn=>conn)
+        rescue Exception
         end
         transaction_error(e, :conn=>conn, :rollback=>rollback)
       ensure

data/lib/sequel/dataset/actions.rb

@@ -461,23 +461,23 @@ module Sequel
     #
     # Examples:
     #
-    #   DB[:table].order(:id).paged_each{|row| ...}
+    #   DB[:table].order(:id).paged_each{|row| }
     #   # SELECT * FROM table ORDER BY id LIMIT 1000
     #   # SELECT * FROM table ORDER BY id LIMIT 1000 OFFSET 1000
     #   # ...
     #
-    #   DB[:table].order(:id).paged_each(:rows_per_fetch=>100){|row| ...}
+    #   DB[:table].order(:id).paged_each(:rows_per_fetch=>100){|row| }
     #   # SELECT * FROM table ORDER BY id LIMIT 100
     #   # SELECT * FROM table ORDER BY id LIMIT 100 OFFSET 100
     #   # ...
     #
-    #   DB[:table].order(:id).paged_each(:strategy=>:filter){|row| ...}
+    #   DB[:table].order(:id).paged_each(:strategy=>:filter){|row| }
     #   # SELECT * FROM table ORDER BY id LIMIT 1000
     #   # SELECT * FROM table WHERE id > 1001 ORDER BY id LIMIT 1000
     #   # ...
     #
     #   DB[:table].order(:table__id).paged_each(:strategy=>:filter,
-    #     :filter_values=>proc{|row, exprs| [row[:id]]}){|row| ...}
+    #     :filter_values=>proc{|row, exprs| [row[:id]]}){|row| }
     #   # SELECT * FROM table ORDER BY id LIMIT 1000
     #   # SELECT * FROM table WHERE id > 1001 ORDER BY id LIMIT 1000
     #   # ...

data/lib/sequel/dataset/graph.rb

@@ -36,6 +36,7 @@ module Sequel
     #                     the receiver is wrapped in a from_self before graphing, and this option
     #                     determines the alias to use.
     # :implicit_qualifier :: The qualifier of implicit conditions, see #join_table.
+    # :join_only :: Only join the tables, do not change the selected columns.
     # :join_type :: The type of join to use (passed to +join_table+).  Defaults to :left_outer.
     # :qualify:: The type of qualification to do, see #join_table.
     # :select :: An array of columns to select.  When not used, selects
@@ -103,6 +104,9 @@ module Sequel
       
       # Join the table early in order to avoid cloning the dataset twice
       ds = ds.join_table(options[:join_type] || :left_outer, table, join_conditions, :table_alias=>table_alias_qualifier, :implicit_qualifier=>implicit_qualifier, :qualify=>options[:qualify], &block)
+
+      return ds if options[:join_only]
+
       opts = ds.opts
 
       # Whether to include the table in the result set

data/lib/sequel/dataset/query.rb

@@ -67,7 +67,7 @@ module Sequel
       where(*cond, &block)
     end
     
-    # Returns a new clone of the dataset with with the given options merged.
+    # Returns a new clone of the dataset with the given options merged.
     # If the options changed include options in COLUMN_CHANGE_OPTS, the cached
     # columns are deleted.  This method should generally not be called
     # directly by user code.
@@ -862,18 +862,18 @@ module Sequel
     # 
     # Accepts the following argument types:
     #
-    # * Hash - list of equality/inclusion expressions
-    # * Array - depends:
-    #   * If first member is a string, assumes the rest of the arguments
-    #     are parameters and interpolates them into the string.
-    #   * If all members are arrays of length two, treats the same way
-    #     as a hash, except it allows for duplicate keys to be
-    #     specified.
-    #   * Otherwise, treats each argument as a separate condition.
-    # * String - taken literally
-    # * Symbol - taken as a boolean column argument (e.g. WHERE active)
-    # * Sequel::SQL::BooleanExpression - an existing condition expression,
-    #   probably created using the Sequel expression filter DSL.
+    # Hash :: list of equality/inclusion expressions
+    # Array :: depends:
+    #          * If first member is a string, assumes the rest of the arguments
+    #            are parameters and interpolates them into the string.
+    #          * If all members are arrays of length two, treats the same way
+    #            as a hash, except it allows for duplicate keys to be
+    #            specified.
+    #          * Otherwise, treats each argument as a separate condition.
+    # String :: taken literally
+    # Symbol :: taken as a boolean column argument (e.g. WHERE active)
+    # Sequel::SQL::BooleanExpression :: an existing condition expression,
+    #                                   probably created using the Sequel expression filter DSL.
     #
     # where also accepts a block, which should return one of the above argument
     # types, and is treated the same way.  This block yields a virtual row object,
@@ -1046,11 +1046,13 @@ module Sequel
     # SQL expression object based on the expr type.  See +where+.
     def filter_expr(expr = nil, &block)
       expr = nil if expr == []
+
       if expr && block
         return SQL::BooleanExpression.new(:AND, filter_expr(expr), filter_expr(block))
       elsif block
         expr = block
       end
+
       case expr
       when Hash
         SQL::BooleanExpression.from_value_pairs(expr)
@@ -1064,10 +1066,8 @@ module Sequel
         end
       when Proc
         filter_expr(Sequel.virtual_row(&expr))
-      when SQL::NumericExpression, SQL::StringExpression
-        raise(Error, "Invalid SQL Expression type: #{expr.inspect}") 
-      when Symbol, SQL::Expression
-        expr
+      when Numeric, SQL::NumericExpression, SQL::StringExpression
+        raise(Error, "Invalid filter expression: #{expr.inspect}") 
       when TrueClass, FalseClass
         if supports_where_true?
           SQL::BooleanExpression.new(:NOOP, expr)
@@ -1081,7 +1081,7 @@ module Sequel
       when PlaceholderLiteralizer::Argument
         expr.transform{|v| filter_expr(v)}
       else
-        raise(Error, "Invalid filter argument: #{expr.inspect}")
+        expr
       end
     end
     

data/lib/sequel/dataset/sql.rb

@@ -517,11 +517,11 @@ module Sequel
 
     # Append literalization of delayed evaluation to SQL string,
     # causing the delayed evaluation proc to be evaluated.
-    def delayed_evaluation_sql_append(sql, callable)
+    def delayed_evaluation_sql_append(sql, delay)
       if recorder = @opts[:placeholder_literalizer]
-        recorder.use(sql, callable, nil)
+        recorder.use(sql, lambda{delay.call(self)}, nil)
       else
-        literal_append(sql, callable.call)
+        literal_append(sql, delay.call(self))
       end
     end
 

data/lib/sequel/extensions/_pretty_table.rb

@@ -6,6 +6,7 @@
 #
 #   Sequel.extension :_pretty_table
 
+#
 module Sequel
   module PrettyTable
     # Prints nice-looking plain-text tables via puts

data/lib/sequel/extensions/arbitrary_servers.rb

@@ -33,8 +33,8 @@
 #   DB.with_server(:host=>'...', :database=>'...') do
 #     DB.synchronize do
 #       # All of these use the host/database given to with_server
-#       DB[:table].insert(...)
-#       DB[:table].update(...)
+#       DB[:table].insert(:c=>1)
+#       DB[:table].update(:c=>2)
 #       DB.tables
 #       DB[:table].all
 #     end
@@ -53,6 +53,7 @@
 # to switch to the sharded threaded connection pool before using this
 # extension.
 
+#
 module Sequel
   module ArbitraryServers
     private

data/lib/sequel/extensions/columns_introspection.rb

@@ -15,6 +15,7 @@
 #
 #   DB.extension(:columns_introspection)
 
+#
 module Sequel
   module ColumnsIntrospection
     # Attempt to guess the columns that will be returned

data/lib/sequel/extensions/connection_validator.rb

@@ -43,6 +43,7 @@
 # you are currently using a single threaded pool and want to
 # use this extension, switch to using a threaded pool.
 
+#
 module Sequel
   module ConnectionValidator
     class Retry < Error; end

data/lib/sequel/extensions/constraint_validations.rb

@@ -122,6 +122,7 @@
 #   readd all constraints you want to use inside the alter table block,
 #   making no other changes inside the alter_table block.
 
+#
 module Sequel
   module ConstraintValidations
     # The default table name used for the validation metadata.

data/lib/sequel/extensions/current_datetime_timestamp.rb

@@ -21,6 +21,7 @@
 #
 #   DB.extension(:current_datetime_timestamp)
 
+#
 module Sequel
   module CurrentDateTimeTimestamp
     module DatasetMethods

data/lib/sequel/extensions/dataset_source_alias.rb

@@ -36,6 +36,7 @@
 #
 #   DB.extension(:dataset_source_alias)
 
+#
 module Sequel
   class Dataset
     module DatasetSourceAlias

data/lib/sequel/extensions/date_arithmetic.rb

@@ -24,6 +24,7 @@
 #
 #   DB[:table].select(add.as(:d)).where(sub > Sequel::CURRENT_TIMESTAMP)
 
+#
 module Sequel
   module SQL
     module Builders

data/lib/sequel/extensions/empty_array_ignore_nulls.rb

@@ -20,6 +20,7 @@
 #
 #   DB.extension(:empty_array_ignore_nulls)
 
+#
 module Sequel
   module EmptyArrayIgnoreNulls
     # Use a simple expression that is always true or false, never NULL.

data/lib/sequel/extensions/error_sql.rb

@@ -28,6 +28,7 @@
 #
 #   DB.extension :error_sql
 
+#
 module Sequel
   class DatabaseError
     # Get the SQL code that caused this error to be raised.

data/lib/sequel/extensions/eval_inspect.rb

@@ -12,6 +12,7 @@
 #
 #   Sequel.extension :eval_inspect
 
+#
 module Sequel
   module EvalInspect
     # Special case objects where inspect does not generally produce input

data/lib/sequel/extensions/filter_having.rb

@@ -14,6 +14,7 @@
 #
 #   DB.extension(:filter_having)
 
+#
 module Sequel
   module FilterHaving
     # Operate on HAVING clause if HAVING clause already present.

data/lib/sequel/extensions/from_block.rb

@@ -12,6 +12,7 @@
 #
 #   DB.extension :from_block
 
+#
 module Sequel
   module Database::FromBlock
     # If a block is given, make it affect the FROM clause:

data/lib/sequel/extensions/graph_each.rb

@@ -15,6 +15,7 @@
 #
 #   DB.extension(:graph_each)
 
+#
 module Sequel
   module GraphEach
     # Call graph_each for graphed datasets that are not being eager graphed.