sequel 3.21.0 → 3.39.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?
+        @disconnection_proc.call(conn) if @disconnection_proc
+      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
+