sequel 3.21.0 → 3.41.0

data/lib/sequel/dataset.rb

@@ -26,6 +26,14 @@ module Sequel
     extend Metaprogramming
     include Metaprogramming
     include Enumerable
+    include SQL::AliasMethods
+    include SQL::BooleanMethods
+    include SQL::CastMethods
+    include SQL::ComplexExpressionMethods
+    include SQL::InequalityMethods
+    include SQL::NumericMethods
+    include SQL::OrderMethods
+    include SQL::StringMethods
   end
   
   require(%w"query actions features graph prepared_statements misc mutation sql", 'dataset')

data/lib/sequel/exceptions.rb

@@ -44,6 +44,10 @@ module Sequel
   # and won't reraise it.
   class Rollback < Error ; end
 
+  # Exception that occurs when unbinding a dataset that has multiple different values
+  # for a given variable.
+  class UnbindDuplicate < Error; end
+
   class Error
     AdapterNotFound = Sequel::AdapterNotFound
     InvalidOperation = Sequel::InvalidOperation

data/lib/sequel/extensions/_pretty_table.rb

@@ -0,0 +1,83 @@
+# This _pretty_table extension is only for internal use.
+# It adds the Sequel::PrettyTable class without modifying 
+# Sequel::Dataset.
+#
+# To load the extension:
+#
+#   Sequel.extension :_pretty_table
+
+module Sequel
+  module PrettyTable
+    # Prints nice-looking plain-text tables via puts
+    # 
+    #   +--+-------+
+    #   |id|name   |
+    #   |--+-------|
+    #   |1 |fasdfas|
+    #   |2 |test   |
+    #   +--+-------+
+    def self.print(records, columns=nil)
+      puts string(records, columns)
+    end
+
+    # Return the string that #print will print via puts.
+    def self.string(records, columns = nil) # records is an array of hashes
+      columns ||= records.first.keys.sort_by{|x|x.to_s}
+      sizes = column_sizes(records, columns)
+      sep_line = separator_line(columns, sizes)
+
+      array = [sep_line, header_line(columns, sizes), sep_line]
+      records.each {|r| array << data_line(columns, sizes, r)}
+      array << sep_line
+      array.join("\n")
+    end
+
+    ### Private Module Methods ###
+
+    # Hash of the maximum size of the value for each column 
+    def self.column_sizes(records, columns) # :nodoc:
+      sizes = Hash.new {0}
+      columns.each do |c|
+        s = c.to_s.size
+        sizes[c.to_sym] = s if s > sizes[c.to_sym]
+      end
+      records.each do |r|
+        columns.each do |c|
+          s = r[c].to_s.size
+          sizes[c.to_sym] = s if s > sizes[c.to_sym]
+        end
+      end
+      sizes
+    end
+    
+    # String for each data line
+    def self.data_line(columns, sizes, record) # :nodoc:
+      '|' << columns.map {|c| format_cell(sizes[c], record[c])}.join('|') << '|'
+    end
+    
+    # Format the value so it takes up exactly size characters
+    def self.format_cell(size, v) # :nodoc:
+      case v
+      when Bignum, Fixnum
+        "%#{size}d" % v
+      when Float
+        "%#{size}g" % v
+      else
+        "%-#{size}s" % v.to_s
+      end
+    end
+    
+    # String for header line
+    def self.header_line(columns, sizes) # :nodoc:
+      '|' << columns.map {|c| "%-#{sizes[c]}s" % c.to_s}.join('|') << '|'
+    end
+
+    # String for separtor line
+    def self.separator_line(columns, sizes) # :nodoc:
+      '+' << columns.map {|c| '-' * sizes[c]}.join('+') << '+'
+    end
+
+    private_class_method :column_sizes, :data_line, :format_cell, :header_line, :separator_line
+  end
+end
+

data/lib/sequel/extensions/arbitrary_servers.rb

@@ -0,0 +1,109 @@
+# The arbitrary_servers extension allows you to connect to arbitrary
+# servers/shards that were not defined when you created the database.
+# To use it, you first load the extension into the Database object:
+#
+#   DB.extension :arbitrary_servers
+#
+# Then you can pass arbitrary connection options for the server/shard
+# to use as a hash:
+#
+#   DB[:table].server(:host=>'...', :database=>'...').all
+#
+# Because Sequel can never be sure that the connection will be reused,
+# arbitrary connections are disconnected as soon as the outermost block
+# that uses them exits.  So this example uses the same connection:
+#
+#   DB.transaction(:server=>{:host=>'...', :database=>'...'}) do |c|
+#     DB.transaction(:server=>{:host=>'...', :database=>'...'}) do |c2|
+#       # c == c2
+#     end
+#   end
+#
+# But this example does not:
+#
+#   DB.transaction(:server=>{:host=>'...', :database=>'...'}) do |c|
+#   end
+#   DB.transaction(:server=>{:host=>'...', :database=>'...'}) do |c2|
+#     # c != c2
+#   end
+#
+# You can use this extension in conjunction with the server_block
+# extension:
+#
+#   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.tables
+#       DB[:table].all
+#     end
+#   end
+#
+# Anyone using this extension in conjunction with the server_block
+# extension may want to do the following to so that you don't need
+# to call synchronize separately:
+#
+#   def DB.with_server(*)
+#     super{synchronize{yield}}
+#   end
+#
+# Note that this extension only works with the sharded threaded connection
+# pool.  If you are using the sharded single connection pool, you need
+# to switch to the sharded threaded connection pool before using this
+# extension.
+
+module Sequel
+  module ArbitraryServers
+    private
+
+    # If server is a hash, create a new connection for
+    # it, and cache it first by thread and then server.
+    def acquire(thread, server)
+      if server.is_a?(Hash)
+        sync{@allocated[thread] ||= {}}[server] = make_new(server)
+      else
+        super
+      end
+    end
+    
+    # If server is a hash, the entry for it probably doesn't
+    # exist in the @allocated hash, so check for existence to
+    # avoid calling nil.[]
+    def owned_connection(thread, server)
+      if server.is_a?(Hash)
+        if a = sync{@allocated[thread]}
+          a[server]
+        end
+      else
+        super
+      end
+    end
+
+    # If server is a hash, return it directly.
+    def pick_server(server)
+      if server.is_a?(Hash)
+        server
+      else
+        super
+      end
+    end
+
+    # If server is a hash, delete the thread from the allocated
+    # connections for that server.  Additionally, if this was the last thread
+    # using that server, delete the server from the @allocated hash.
+    def release(thread, conn, server)
+      if server.is_a?(Hash)
+        a = @allocated[thread]
+        a.delete(server)
+        @allocated.delete(thread) if a.empty?
+        db.disconnect_connection(conn)
+      else  
+        super
+      end
+    end
+  end
+
+  Database.register_extension(:arbitrary_servers){|db| db.pool.extend(ArbitraryServers)}
+end
+

data/lib/sequel/extensions/blank.rb

@@ -1,4 +1,8 @@
 # The blank extension adds the blank? method to all objects (e.g. Object#blank?).
+#
+# To load the extension:
+#
+#   Sequel.extension :blank
 
 class FalseClass
   # false is always blank

data/lib/sequel/extensions/columns_introspection.rb

@@ -0,0 +1,72 @@
+# The columns_introspection extension attempts to introspect the
+# selected columns for a dataset before issuing a query.  If it
+# thinks it can guess correctly at the columns the query will use,
+# it will return the columns without issuing a database query.
+# This method is not fool-proof, it's possible that some databases
+# will use column names that Sequel does not expect.
+#
+# To attempt to introspect columns for a single dataset:
+#
+#   ds.extension(:columns_introspection)
+#
+# To attempt to introspect columns for all datasets on a single database:
+#
+#   DB.extension(:columns_introspection)
+#
+# To attempt to introspect columns for all datasets on all databases:
+#
+#   Sequel.extension :columns_introspection
+#   Sequel::Dataset.introspect_all_columns
+
+module Sequel
+  module ColumnsIntrospection
+    # Attempt to guess the columns that will be returned
+    # if there are columns selected, in order to skip a database
+    # query to retrieve the columns.  This should work with
+    # Symbols, SQL::Identifiers, SQL::QualifiedIdentifiers, and
+    # SQL::AliasedExpressions.
+    def columns
+      return @columns if @columns
+      return columns_without_introspection unless cols = opts[:select] and !cols.empty?
+      probable_columns = cols.map{|c| probable_column_name(c)}
+      if probable_columns.all?
+        @columns = probable_columns
+      else
+        columns_without_introspection
+      end
+    end
+
+    private
+
+    # Return the probable name of the column, or nil if one
+    # cannot be determined.
+    def probable_column_name(c)
+      case c
+      when Symbol
+        _, c, a = split_symbol(c)
+        (a || c).to_sym
+      when SQL::Identifier
+        c.value.to_sym
+      when SQL::QualifiedIdentifier
+        col = c.column
+        col.is_a?(SQL::Identifier) ? col.value.to_sym : col.to_sym
+      when SQL::AliasedExpression
+        a = c.aliaz
+        a.is_a?(SQL::Identifier) ? a.value.to_sym : a.to_sym
+      end
+    end
+  end
+
+  class Dataset
+    alias columns_without_introspection columns
+
+    # Enable column introspection for every dataset.
+    def self.introspect_all_columns
+      include ColumnsIntrospection
+      remove_method(:columns) if instance_methods(false).map{|x| x.to_s}.include?('columns')
+    end
+  end
+
+  Dataset.register_extension(:columns_introspection, Sequel::ColumnsIntrospection)
+end
+

data/lib/sequel/extensions/connection_validator.rb

@@ -0,0 +1,109 @@
+# The connection_validator extension modifies a database's
+# connection pool to validate that connections checked out
+# from the pool are still valid, before yielding them for
+# use.  If it detects an invalid connection, it removes it
+# from the pool and tries the next available connection,
+# creating a new connection if no available connection is
+# valid.  Example of use:
+#
+#   DB.extension(:connection_validator)
+#
+# As checking connections for validity involves issuing a
+# query, which is potentially an expensive operation,
+# the validation checks are only run if the connection has
+# been idle for longer than a certain threshold. By default,
+# that threshold is 3600 seconds (1 hour), but it can be
+# modified by the user, set to -1 to always validate
+# connections on checkout:
+#
+#   DB.pool.connection_validation_timeout = -1
+#
+# Note that if you set the timeout to validate connections
+# on every checkout, you should probably manually control
+# connection checkouts on a coarse basis, using
+# Database#synchonrize.  In a web application, the optimal
+# place for that would be a rack middleware.  Validating
+# connections on every checkout without setting up coarse
+# connection checkouts will hurt performance, in some cases
+# significantly.  Note that setting up coarse connection
+# checkouts reduces the concurrency level acheivable.  For
+# example, in a web application, using Database#synchronize
+# in a rack middleware will limit the number of concurrent
+# web requests to the number to connections in the database
+# connection pool.
+#
+# Note that this extension only affects the default threaded
+# and the sharded threaded connection pool.  The single
+# threaded and sharded single threaded connection pools are
+# not affected.  As the only reason to use the single threaded
+# pools is for speed, and this extension makes the connection
+# pool slower, there's not much point in modifying this
+# extension to work with the single threaded pools.  The
+# threaded pools work fine even in single threaded code, so if
+# 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
+
+    # The number of seconds that need to pass since
+    # connection checkin before attempting to validate
+    # the connection when checking it out from the pool.
+    # Defaults to 3600 seconds (1 hour).
+    attr_accessor :connection_validation_timeout
+
+    # Initialize the data structures used by this extension.
+    def self.extended(pool)
+      pool.instance_eval do
+        @connection_timestamps ||= {}
+        @connection_validation_timeout = 3600
+      end
+
+      # Make sure the valid connection SQL query is precached,
+      # otherwise it's possible it will happen at runtime. While
+      # it should work correctly at runtime, it's better to avoid
+      # the possibility of failure altogether.
+      pool.db.send(:valid_connection_sql)
+    end
+
+    private
+
+    # Record the time the connection was checked back into the pool.
+    def checkin_connection(*)
+      conn = super
+      @connection_timestamps[conn] = Time.now
+      conn
+    end
+
+    # When acquiring a connection, if it has been
+    # idle for longer than the connection validation timeout,
+    # test the connection for validity.  If it is not valid,
+    # disconnect the connection, and retry with a new connection.
+    def acquire(*a)
+      begin
+        if (conn = super) &&
+           (t = sync{@connection_timestamps.delete(conn)}) &&
+           Time.now - t > @connection_validation_timeout &&
+           !db.valid_connection?(conn)
+
+          if pool_type == :sharded_threaded
+            sync{allocated(a.last).delete(Thread.current)}
+          else
+            sync{@allocated.delete(Thread.current)}
+          end
+
+          db.disconnect_connection(conn)
+          raise Retry
+        end
+      rescue Retry
+        retry
+      end
+
+      conn
+    end
+  end
+
+  Database.register_extension(:connection_validator){|db| db.pool.extend(ConnectionValidator)}
+end
+