sequel 2.11.0 → 2.12.0

data/lib/{sequel_core → sequel}/adapters/shared/progress.rb

@@ -1,5 +1,4 @@
-require 'sequel_core/adapters/utils/date_format'
-require 'sequel_core/adapters/utils/unsupported'
+Sequel.require %w'date_format unsupported', 'adapters/utils'
 
 module Sequel
   module Progress

data/lib/{sequel_core → sequel}/adapters/shared/sqlite.rb

@@ -1,13 +1,13 @@
-require 'sequel_core/adapters/utils/unsupported'
+Sequel.require 'adapters/utils/unsupported'
 
 module Sequel
   module SQLite
     module DatabaseMethods
-      AUTO_VACUUM = {'0' => :none, '1' => :full, '2' => :incremental}.freeze
-      SYNCHRONOUS = {'0' => :off, '1' => :normal, '2' => :full}.freeze
+      AUTO_VACUUM = [:none, :full, :incremental].freeze
+      SYNCHRONOUS = [:off, :normal, :full].freeze
       TABLES_FILTER = "type = 'table' AND NOT name = 'sqlite_sequence'"
-      TEMP_STORE = {'0' => :default, '1' => :file, '2' => :memory}.freeze
-      TYPES = Sequel::Schema::SQL::TYPES.merge(Bignum=>'integer')
+      TEMP_STORE = [:default, :file, :memory].freeze
+      TYPES = Sequel::Database::TYPES.merge(Bignum=>'integer')
       
       # Run all alter_table commands in a transaction.  This is technically only
       # needed for drop column.
@@ -15,6 +15,64 @@ module Sequel
         transaction{super}
       end
 
+      # A symbol signifying the value of the auto_vacuum PRAGMA.
+      def auto_vacuum
+        AUTO_VACUUM[pragma_get(:auto_vacuum).to_i]
+      end
+      
+      # Set the auto_vacuum PRAGMA using the given symbol (:none, :full, or
+      # :incremental).
+      def auto_vacuum=(value)
+        value = AUTO_VACUUM.index(value) || (raise Error, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
+        pragma_set(:auto_vacuum, value)
+      end
+      
+      # Get the value of the given PRAGMA.
+      def pragma_get(name)
+        self["PRAGMA #{name}"].single_value
+      end
+      
+      # Set the value of the given PRAGMA to value.
+      def pragma_set(name, value)
+        execute_ddl("PRAGMA #{name} = #{value}")
+      end
+      
+      # A symbol signifying the value of the synchronous PRAGMA.
+      def synchronous
+        SYNCHRONOUS[pragma_get(:synchronous).to_i]
+      end
+      
+      # Set the synchronous PRAGMA using the given symbol (:off, :normal, or :full).
+      def synchronous=(value)
+        value = SYNCHRONOUS.index(value) || (raise Error, "Invalid value for synchronous option. Please specify one of :off, :normal, :full.")
+        pragma_set(:synchronous, value)
+      end
+      
+      # Array of symbols specifying the table names in the current database.
+      #
+      # Options:
+      # * :server - Set the server to use.
+      def tables(opts={})
+        ds = self[:sqlite_master].server(opts[:server]).filter(TABLES_FILTER)
+        ds.identifier_output_method = nil
+        ds.identifier_input_method = nil
+        ds2 = dataset
+        ds.map{|r| ds2.send(:output_identifier, r[:name])}
+      end
+      
+      # A symbol signifying the value of the temp_store PRAGMA.
+      def temp_store
+        TEMP_STORE[pragma_get(:temp_store).to_i]
+      end
+      
+      # Set the temp_store PRAGMA using the given symbol (:default, :file, or :memory).
+      def temp_store=(value)
+        value = TEMP_STORE.index(value) || (raise Error, "Invalid value for temp_store option. Please specify one of :default, :file, :memory.")
+        pragma_set(:temp_store, value)
+      end
+      
+      private
+
       # SQLite supports limited table modification.  You can add a column
       # or an index.  Dropping columns is supported by copying the table into
       # a temporary table, dropping the table, and creating a new table without
@@ -68,64 +126,6 @@ module Sequel
         end
       end
       
-      # A symbol signifying the value of the auto_vacuum PRAGMA.
-      def auto_vacuum
-        AUTO_VACUUM[pragma_get(:auto_vacuum).to_s]
-      end
-      
-      # Set the auto_vacuum PRAGMA using the given symbol (:none, :full, or
-      # :incremental).
-      def auto_vacuum=(value)
-        value = AUTO_VACUUM.key(value) || (raise Error, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
-        pragma_set(:auto_vacuum, value)
-      end
-      
-      # Get the value of the given PRAGMA.
-      def pragma_get(name)
-        self["PRAGMA #{name}"].single_value
-      end
-      
-      # Set the value of the given PRAGMA to value.
-      def pragma_set(name, value)
-        execute_ddl("PRAGMA #{name} = #{value}")
-      end
-      
-      # A symbol signifying the value of the synchronous PRAGMA.
-      def synchronous
-        SYNCHRONOUS[pragma_get(:synchronous).to_s]
-      end
-      
-      # Set the synchronous PRAGMA using the given symbol (:off, :normal, or :full).
-      def synchronous=(value)
-        value = SYNCHRONOUS.key(value) || (raise Error, "Invalid value for synchronous option. Please specify one of :off, :normal, :full.")
-        pragma_set(:synchronous, value)
-      end
-      
-      # Array of symbols specifying the table names in the current database.
-      #
-      # Options:
-      # * :server - Set the server to use.
-      def tables(opts={})
-        ds = self[:sqlite_master].server(opts[:server]).filter(TABLES_FILTER)
-        ds.identifier_output_method = nil
-        ds.identifier_input_method = nil
-        ds2 = dataset
-        ds.map{|r| ds2.send(:output_identifier, r[:name])}
-      end
-      
-      # A symbol signifying the value of the temp_store PRAGMA.
-      def temp_store
-        TEMP_STORE[pragma_get(:temp_store).to_s]
-      end
-      
-      # Set the temp_store PRAGMA using the given symbol (:default, :file, or :memory).
-      def temp_store=(value)
-        value = TEMP_STORE.key(value) || (raise Error, "Invalid value for temp_store option. Please specify one of :default, :file, :memory.")
-        pragma_set(:temp_store, value)
-      end
-      
-      private
-
       # The array of column symbols in the table, except for ones given in opts[:except]
       def backup_table_name(table, opts={})
         (opts[:times]||1000).times do |i|
@@ -172,7 +172,7 @@ module Sequel
           row[:allow_null] = row.delete(:notnull).to_i == 0
           row[:default] = row.delete(:dflt_value)
           row[:primary_key] = row.delete(:pk).to_i == 1
-          row[:default] = nil if row[:default].blank?
+          row[:default] = nil if blank_object?(row[:default])
           row[:db_type] = row.delete(:type)
           row[:type] = schema_column_type(row[:db_type])
           row
@@ -197,6 +197,7 @@ module Sequel
     # Instance methods for datasets that connect to an SQLite database
     module DatasetMethods
       include Dataset::UnsupportedIntersectExceptAll
+      include Dataset::UnsupportedIsTrue
 
       # SQLite does not support pattern matching via regular expressions.
       # SQLite is case insensitive (depending on pragma), so use LIKE for
@@ -216,10 +217,14 @@ module Sequel
       # SQLite performs a TRUNCATE style DELETE if no filter is specified.
       # Since we want to always return the count of records, add a condition
       # that is always true and then delete.
-      def delete(opts = {})
+      def delete(opts = (defarg=true;{}))
         # check if no filter is specified
-        opts = @opts.merge(opts)
-        super(opts[:where] ? opts : opts.merge(:where=>{1=>1}))
+        if defarg
+          @opts[:where] ? super() : filter(1=>1).delete
+        else
+          opts = @opts.merge(opts)
+          super(opts[:where] ? opts : opts.merge(:where=>{1=>1}))
+        end
       end
       
       # Insert the values into the database.

data/lib/{sequel_core → sequel}/adapters/sqlite.rb

@@ -1,5 +1,5 @@
 require 'sqlite3'
-require 'sequel_core/adapters/shared/sqlite'
+Sequel.require 'adapters/shared/sqlite'
 
 module Sequel
   # Top level module for holding all SQLite-related modules and classes
@@ -27,7 +27,7 @@ module Sequel
       # be available if it is locked, given in milliseconds (default is 5000).
       def connect(server)
         opts = server_opts(server)
-        opts[:database] = ':memory:' if opts[:database].blank?
+        opts[:database] = ':memory:' if blank_object?(opts[:database])
         db = ::SQLite3::Database.new(opts[:database])
         db.busy_timeout(opts.fetch(:timeout, 5000))
         db.type_translation = true
@@ -35,7 +35,7 @@ module Sequel
         # Handle datetime's with Sequel.datetime_class
         prok = proc do |t,v|
           v = Time.at(v.to_i).iso8601 if UNIX_EPOCH_TIME_FORMAT.match(v)
-          v.to_sequel_time
+          Sequel.string_to_datetime(v)
         end
         db.translator.add_translator("timestamp", &prok)
         db.translator.add_translator("datetime", &prok)
@@ -86,8 +86,12 @@ module Sequel
       # Use the native driver transaction method if there isn't already a transaction
       # in progress on the connection, always yielding a connection inside a transaction
       # transaction.
-      def transaction(server=nil, &block)
-        synchronize(server) do |conn|
+      def transaction(opts={})
+        unless opts.is_a?(Hash)
+          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
+          opts = {:server=>opts}
+        end
+        synchronize(opts[:server]) do |conn|
           return yield(conn) if conn.transaction_active?
           begin
             result = nil
@@ -106,7 +110,7 @@ module Sequel
       private
       
       # Log the SQL and the arguments, and yield an available connection.  Rescue
-      # any SQLite3::Exceptions and turn the into Error::InvalidStatements.
+      # any SQLite3::Exceptions and turn the into DatabaseErrors.
       def _execute(sql, opts)
         begin
           log_info(sql, opts[:arguments])
@@ -123,7 +127,7 @@ module Sequel
         o = super.merge(:pool_convert_exceptions=>false)
         # Default to only a single connection if a memory database is used,
         # because otherwise each connection will get a separate database
-        o[:max_connections] = 1 if @opts[:database] == ':memory:' || @opts[:database].blank?
+        o[:max_connections] = 1 if @opts[:database] == ':memory:' || blank_object?(@opts[:database])
         o
       end
 

data/lib/{sequel_core → sequel}/adapters/utils/unsupported.rb

@@ -40,4 +40,23 @@ class Sequel::Dataset
       super(ds)
     end
   end
+
+  # This module should be included in the dataset class for all databases that
+  # don't support IS [NOT] (TRUE|FALSE)
+  module UnsupportedIsTrue
+    # Use an = construct instead of IS and an != OR IS NULL construct instead of IS NOT.
+    def complex_expression_sql(op, args)
+      case op
+      when :IS, :'IS NOT'
+        isnot = op != :IS
+        return super if (v1 = args.at(1)).nil?
+        v0 = literal(args.at(0))
+        s = "(#{v0} #{'!' if isnot}= #{literal(v1)})"
+        s = "(#{s} OR (#{v0} IS NULL))" if isnot
+        s
+      else
+        super(op, args)
+      end
+    end
+  end
 end

data/lib/{sequel_core → sequel}/connection_pool.rb

@@ -28,6 +28,7 @@ class Sequel::ConnectionPool
   #
   # The connection pool takes the following options:
   #
+  # * :disconnection_proc - The proc called when removing connections from the pool.
   # * :max_connections - The maximum number of connections the connection pool
   #   will open (default 4)
   # * :pool_convert_exceptions - Whether to convert non-StandardError based exceptions
@@ -90,7 +91,7 @@ class Sequel::ConnectionPool
   # If no connection is immediately available and the pool is already using the maximum
   # number of connections, Pool#hold will block until a connection
   # is available or the timeout expires.  If the timeout expires before a
-  # connection can be acquired, a Sequel::Error::PoolTimeoutError is 
+  # connection can be acquired, a Sequel::PoolTimeout is 
   # raised.
   def hold(server=:default)
     begin
@@ -102,7 +103,7 @@ class Sequel::ConnectionPool
         return yield(conn)
       end
       until conn = acquire(t, server)
-        raise(::Sequel::Error::PoolTimeoutError) if Time.new > timeout
+        raise(::Sequel::PoolTimeout) if Time.new > timeout
         sleep sleep_time
       end
       begin
@@ -203,9 +204,6 @@ end
 # A SingleThreadedPool acts as a replacement for a ConnectionPool for use
 # in single-threaded applications. ConnectionPool imposes a substantial
 # performance penalty, so SingleThreadedPool is used to gain some speed.
-#
-# Note that using a single threaded pool with some adapters can cause
-# errors in certain cases, see Sequel.single_threaded=.
 class Sequel::SingleThreadedPool
   # The proc used to create a new database connection
   attr_writer :connection_proc
@@ -217,8 +215,12 @@ class Sequel::SingleThreadedPool
   #
   # The single threaded pool takes the following options:
   #
+  # * :disconnection_proc - The proc called when removing connections from the pool.
   # * :pool_convert_exceptions - Whether to convert non-StandardError based exceptions
   #   to RuntimeError exceptions (default true)
+  # * :servers - A hash of servers to use.  Keys should be symbols.  If not
+  #   present, will use a single :default server.  The server name symbol will
+  #   be passed to the connection_proc.
   def initialize(opts={}, &block)
     @connection_proc = block
     @disconnection_proc = opts[:disconnection_proc]

data/lib/sequel/core.rb

@@ -0,0 +1,221 @@
+%w'bigdecimal date thread time uri'.each{|f| require f}
+
+# Top level module for Sequel
+#
+# There are some class methods that are added via metaprogramming, one for
+# each supported adapter.  For example:
+#
+#   DB = Sequel.sqlite # Memory database
+#   DB = Sequel.sqlite('blog.db')
+#   DB = Sequel.postgres('database_name', :user=>'user', 
+#          :password=>'password', :host=>'host', :port=>5432, 
+#          :max_connections=>10)
+#
+# If a block is given to these methods, it is passed the opened Database
+# object, which is closed (disconnected) when the block exits, just
+# like a block passed to connect.  For example:
+#
+#   Sequel.sqlite('blog.db'){|db| puts db[:users].count}  
+#
+# Sequel converts the column type tinyint to a boolean by default,
+# you can override the conversion to use tinyint as an integer:
+#
+#   Sequel.convert_tinyint_to_bool = false
+#
+# Sequel converts two digit years in Dates and DateTimes by default,
+# so 01/02/03 is interpreted at January 2nd, 2003, and 12/13/99 is interpreted
+# as December 13, 1999. You can override this to treat those dates as
+# January 2nd, 0003 and December 13, 0099, respectively, by setting: 
+#
+#   Sequel.convert_two_digit_years = false
+#
+# Sequel can use either Time or DateTime for times returned from the
+# database.  It defaults to Time.  To change it to DateTime, use:
+#
+#   Sequel.datetime_class = DateTime
+#
+# Sequel currently does not use instance_eval for virtual row blocks by default
+# (e.g. the block passed to Dataset#filter, #select, #order and other similar
+# methods).  If you want to use instance_eval for these blocks, don't have any
+# block arguments, and set:
+#
+#   Sequel.virtual_row_instance_eval = true
+#
+# When this is set, you can do:
+#
+#   dataset.filter{|o| o.column > 0} # no instance_eval
+#   dataset.filter{column > 0}       # instance eval
+#
+# When the virtual_row_instance_eval is false, using a virtual row block without a block
+# argument will generate a deprecation message.
+#
+# The option to not use instance_eval for a block with no arguments will be removed in Sequel 3.0.
+# If you have any virtual row blocks that you don't want to use instance_eval for,
+# make sure the blocks have block arguments.
+#
+# You can set the SEQUEL_NO_CORE_EXTENSIONS constant or environment variable to have
+# Sequel not extend the core classes.
+module Sequel
+  @convert_tinyint_to_bool = true
+  @convert_two_digit_years = true
+  @datetime_class = Time
+  @virtual_row_instance_eval = false
+  
+  class << self
+    attr_accessor :convert_tinyint_to_bool, :convert_two_digit_years, :datetime_class, :virtual_row_instance_eval
+  end
+
+  # Returns true if the passed object could be a specifier of conditions, false otherwise.
+  # Currently, Sequel considers hashes and arrays of all two pairs as
+  # condition specifiers.
+  def self.condition_specifier?(obj)
+    case obj
+    when Hash
+      true
+    when Array
+      !obj.empty? && obj.all?{|i| (Array === i) && (i.length == 2)}
+    else
+      false
+    end
+  end
+
+  # Creates a new database object based on the supplied connection string
+  # and optional arguments.  The specified scheme determines the database
+  # class used, and the rest of the string specifies the connection options.
+  # For example:
+  #
+  #   DB = Sequel.connect('sqlite:/') # Memory database
+  #   DB = Sequel.connect('sqlite://blog.db') # ./blog.db
+  #   DB = Sequel.connect('sqlite:///blog.db') # /blog.db
+  #   DB = Sequel.connect('postgres://user:password@host:port/database_name')
+  #   DB = Sequel.connect('sqlite:///blog.db', :max_connections=>10)
+  #
+  # If a block is given, it is passed the opened Database object, which is
+  # closed when the block exits.  For example:
+  #
+  #   Sequel.connect('sqlite://blog.db'){|db| puts db[:users].count}  
+  def self.connect(*args, &block)
+    Database.connect(*args, &block)
+  end
+  
+  # Set the method to call on identifiers going into the database.  This affects
+  # the literalization of identifiers by calling this method on them before they are input.
+  # Sequel upcases identifiers in all SQL strings for most databases, so to turn that off:
+  #
+  #   Sequel.identifier_input_method = nil
+  # 
+  # to downcase instead:
+  #
+  #   Sequel.identifier_input_method = :downcase
+  #
+  # Other String instance methods work as well.
+  def self.identifier_input_method=(value)
+    Database.identifier_input_method = value
+  end
+  
+  # Set the method to call on identifiers coming out of the database.  This affects
+  # the literalization of identifiers by calling this method on them when they are
+  # retrieved from the database.  Sequel downcases identifiers retrieved for most
+  # databases, so to turn that off:
+  #
+  #   Sequel.identifier_output_method = nil
+  # 
+  # to upcase instead:
+  #
+  #   Sequel.identifier_output_method = :upcase
+  #
+  # Other String instance methods work as well.
+  def self.identifier_output_method=(value)
+    Database.identifier_output_method = value
+  end
+  
+  # Set whether to quote identifiers for all databases by default. By default,
+  # Sequel quotes identifiers in all SQL strings, so to turn that off:
+  #
+  #   Sequel.quote_identifiers = false
+  def self.quote_identifiers=(value)
+    Database.quote_identifiers = value
+  end
+
+  # Require all given files which should be in the same or a subdirectory of
+  # this file.  If a subdir is given, assume all files are in that subdir.
+  def self.require(files, subdir=nil)
+    Array(files).each{|f| super("#{File.dirname(__FILE__)}/#{"#{subdir}/" if subdir}#{f}")}
+  end
+  
+  # Set whether to set the single threaded mode for all databases by default. By default,
+  # Sequel uses a threadsafe connection pool, which isn't as fast as the
+  # single threaded connection pool.  If your program will only have one thread,
+  # and speed is a priority, you may want to set this to true:
+  #
+  #   Sequel.single_threaded = true
+  def self.single_threaded=(value)
+    Database.single_threaded = value
+  end
+
+  # Converts the given string into a Date object.
+  def self.string_to_date(s)
+    begin
+      Date.parse(s, Sequel.convert_two_digit_years)
+    rescue => e
+      raise InvalidValue, "Invalid Date value '#{self}' (#{e.message})"
+    end
+  end
+
+  # Converts the given string into a Time or DateTime object, depending on the
+  # value of Sequel.datetime_class.
+  def self.string_to_datetime(s)
+    begin
+      if datetime_class == DateTime
+        DateTime.parse(s, convert_two_digit_years)
+      else
+        datetime_class.parse(s)
+      end
+    rescue => e
+      raise InvalidValue, "Invalid #{datetime_class} value '#{self}' (#{e.message})"
+    end
+  end
+
+  # Converts the given string into a Time object.
+  def self.string_to_time(s)
+    begin
+      Time.parse(s)
+    rescue => e
+      raise InvalidValue, "Invalid Time value '#{self}' (#{e.message})"
+    end
+  end
+
+  ### Private Class Methods ###
+
+  # Helper method that the database adapter class methods that are added to Sequel via
+  # metaprogramming use to parse arguments.
+  def self.adapter_method(adapter, *args, &block) # :nodoc:
+    raise(::Sequel::Error, "Wrong number of arguments, 0-2 arguments valid") if args.length > 2
+    opts = {:adapter=>adapter.to_sym}
+    opts[:database] = args.shift if args.length >= 1 && !(args[0].is_a?(Hash))
+    if Hash === (arg = args[0])
+      opts.merge!(arg)
+    elsif !arg.nil?
+      raise ::Sequel::Error, "Wrong format of arguments, either use (), (String), (Hash), or (String, Hash)"
+    end
+    connect(opts, &block)
+  end
+
+  # Method that adds a database adapter class method to Sequel that calls
+  # Sequel.adapter_method.
+  def self.def_adapter_method(*adapters) # :nodoc:
+    adapters.each do |adapter|
+      instance_eval("def #{adapter}(*args, &block); adapter_method('#{adapter}', *args, &block) end")
+    end
+  end
+
+  private_class_method :adapter_method, :def_adapter_method
+  
+  require(%w"metaprogramming sql connection_pool exceptions dataset database version deprecated")
+  require(%w"schema_generator schema_methods schema_sql", 'database')
+  require(%w"convenience graph prepared_statements 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
+  def_adapter_method(*Database::ADAPTERS)
+end