sequel 2.12.0 → 3.0.0

data/lib/sequel/adapters/sqlite.rb

@@ -5,7 +5,7 @@ module Sequel
   # Top level module for holding all SQLite-related modules and classes
   # for Sequel.
   module SQLite
-    # Database class for PostgreSQL databases used with Sequel and the
+    # Database class for SQLite databases used with Sequel and the
     # ruby-sqlite3 driver.
     class Database < Sequel::Database
       UNIX_EPOCH_TIME_FORMAT = /\A\d+\z/.freeze
@@ -87,10 +87,6 @@ module Sequel
       # in progress on the connection, always yielding a connection inside a transaction
       # transaction.
       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
@@ -110,7 +106,7 @@ module Sequel
       private
       
       # Log the SQL and the arguments, and yield an available connection.  Rescue
-      # any SQLite3::Exceptions and turn the into DatabaseErrors.
+      # any SQLite3::Exceptions and turn them into DatabaseErrors.
       def _execute(sql, opts)
         begin
           log_info(sql, opts[:arguments])
@@ -120,7 +116,7 @@ module Sequel
         end
       end
       
-      # SQLite does not need the pool to convert exceptions.
+      # The SQLite adapter does not need the pool to convert exceptions.
       # Also, force the max connections to 1 if a memory database is being
       # used, as otherwise each connection gets a separate database.
       def connection_pool_default_options
@@ -230,6 +226,7 @@ module Sequel
       
       private
       
+      # Quote the string using the adapter class method.
       def literal_string(v)
         "'#{::SQLite3::Database.quote(v)}'"
       end

data/lib/sequel/adapters/utils/unsupported.rb

@@ -17,9 +17,9 @@ class Sequel::Dataset
     # Since EXCEPT and INTERSECT are not supported, and order shouldn't matter
     # when UNION is used, don't worry about parantheses.  This may potentially
     # give incorrect results if UNION ALL is used.
-    def select_compounds_sql(sql, opts)
-      return unless opts[:compounds]
-      opts[:compounds].each do |type, dataset, all|
+    def select_compounds_sql(sql)
+      return unless @opts[:compounds]
+      @opts[:compounds].each do |type, dataset, all|
         sql << " #{type.to_s.upcase}#{' ALL' if all} #{subselect_sql(dataset)}"
       end
     end

data/lib/sequel/connection_pool.rb

@@ -49,11 +49,9 @@ class Sequel::ConnectionPool
     @servers += opts[:servers].keys - @servers if opts[:servers] 
     @available_connections = Hash.new{|h,k| h[:default]}
     @allocated = Hash.new{|h,k| h[:default]}
-    @created_count = Hash.new{|h,k| h[:default]}
     @servers.each do |s|
       @available_connections[s] = []
       @allocated[s] = {}
-      @created_count[s] = 0
     end
     @timeout = opts[:pool_timeout] || 5
     @sleep_time = opts[:pool_sleep_time] || 0.001
@@ -75,7 +73,7 @@ class Sequel::ConnectionPool
   # The total number of connections opened for the given server, should
   # be equal to available_connections.length + allocated.length
   def created_count(server=:default)
-    @created_count[server]
+    @allocated[server].length + @available_connections[server].length
   end
   alias size created_count
   
@@ -102,20 +100,22 @@ class Sequel::ConnectionPool
       if conn = owned_connection(t, server)
         return yield(conn)
       end
-      until conn = acquire(t, server)
-        raise(::Sequel::PoolTimeout) if Time.new > timeout
-        sleep sleep_time
-      end
       begin
+        until conn = acquire(t, server)
+          raise(::Sequel::PoolTimeout) if Time.new > timeout
+          sleep sleep_time
+        end
         yield conn
       rescue Sequel::DatabaseDisconnectError => dde
-        remove(t, conn, server)
+        remove(t, conn, server) if conn
         raise
       ensure
-        release(t, conn, server) unless dde
+        @mutex.synchronize{release(t, server)} if conn && !dde
       end
+    rescue StandardError => e
+      raise e
     rescue Exception => e
-      raise(@convert_exceptions && !e.is_a?(StandardError) ? RuntimeError.new(e.message) : e)
+      raise(@convert_exceptions ? RuntimeError.new(e.message) : e)
     end
   end
   
@@ -130,7 +130,6 @@ class Sequel::ConnectionPool
       @available_connections.each do |server, conns|
         conns.each{|c| block.call(c)} if block
         conns.clear
-        set_created_count(server, allocated(server).length)
       end
     end
   end
@@ -156,7 +155,11 @@ class Sequel::ConnectionPool
   # Creates a new connection to the given server if the size of the pool for
   # the server is less than the maximum size of the pool.
   def make_new(server)
-    if @created_count[server] < @max_size
+    if (n = created_count(server)) >= @max_size
+      allocated(server).keys.reject{|t| t.alive?}.each{|t| release(t, server)}
+      n = nil
+    end
+    if (n || created_count(server)) < @max_size
       raise(Sequel::Error, "No connection proc specified") unless @connection_proc
       begin
         conn = @connection_proc.call(server)
@@ -166,7 +169,6 @@ class Sequel::ConnectionPool
         raise e
       end
       raise(Sequel::DatabaseConnectionError, "Connection parameters not valid") unless conn
-      set_created_count(server, @created_count[server] + 1)
       conn
     end
   end
@@ -178,27 +180,18 @@ class Sequel::ConnectionPool
   end
   
   # Releases the connection assigned to the supplied thread and server.
-  def release(thread, conn, server)
-    @mutex.synchronize do
-      allocated(server).delete(thread)
-      available_connections(server) << conn
-    end
+  # You must already have the mutex before you call this.
+  def release(thread, server)
+    available_connections(server) << allocated(server).delete(thread)
   end
 
   # Removes the currently allocated connection from the connection pool.
   def remove(thread, conn, server)
     @mutex.synchronize do
       allocated(server).delete(thread)
-      set_created_count(server, @created_count[server] - 1)
       @disconnection_proc.call(conn) if @disconnection_proc
     end
   end
-
-  # Set the created count for the given server type
-  def set_created_count(server, value)
-    server = :default unless @created_count.include?(server)
-    @created_count[server] = value
-  end
 end
 
 # A SingleThreadedPool acts as a replacement for a ConnectionPool for use

data/lib/sequel/core.rb

@@ -34,32 +34,13 @@
 #
 #   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
+  @virtual_row_instance_eval = true
   
   class << self
     attr_accessor :convert_tinyint_to_bool, :convert_two_digit_years, :datetime_class, :virtual_row_instance_eval
@@ -211,7 +192,7 @@ module Sequel
 
   private_class_method :adapter_method, :def_adapter_method
   
-  require(%w"metaprogramming sql connection_pool exceptions dataset database version deprecated")
+  require(%w"metaprogramming sql connection_pool exceptions dataset database version")
   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')

data/lib/sequel/database.rb

@@ -77,10 +77,6 @@ module Sequel
       @identifier_input_method = nil
       @identifier_output_method = nil
       @quote_identifiers = nil
-      if opts.include?(:upcase_identifiers)
-        Deprecation.deprecate('The :upcase_identifiers Database option', 'Use the :identifier_input_method => :upcase option instead')
-        @identifier_input_method = opts[:upcase_identifiers] ? :upcase : ""
-      end
       @pool = (@single_threaded ? SingleThreadedPool : ConnectionPool).new(connection_pool_default_options.merge(opts), &block)
       @pool.connection_proc = proc{|server| connect(server)} unless block
       @pool.disconnection_proc = proc{|conn| disconnect_connection(conn)} unless opts[:disconnection_proc]
@@ -225,8 +221,7 @@ module Sequel
 
     # Executes the supplied SQL statement string.
     def <<(sql)
-      Deprecation.deprecate('Passing an array argument to Database#<<', 'Use array.each{|x| database << x}') if Array === sql
-      execute_ddl((Array === sql) ? sql.to_sql : sql)
+      execute_ddl(sql)
     end
     
     # Returns a dataset from the database. If the first argument is a string,
@@ -249,11 +244,27 @@ module Sequel
       prepared_statements[ps_name].call(hash)
     end
     
+    # Cast the given type to a literal type
+    def cast_type_literal(type)
+      type_literal(:type=>type)
+    end
+
     # Connects to the database. This method should be overridden by descendants.
     def connect
       raise NotImplementedError, "#connect should be overridden by adapters"
     end
     
+    # The database type for this database object, the same as the adapter scheme
+    # by default.  Should be overridden in adapters (especially shared adapters)
+    # to be the correct type, so that even if two separate Database objects are
+    # using different adapters you can tell that they are using the same database
+    # type.  Even better, you can tell that two Database objects that are using
+    # the same adapter are connecting to different database types (think JDBC or
+    # DataObjects).
+    def database_type
+      self.class.adapter_scheme
+    end
+    
     # Returns a blank dataset for this database
     def dataset
       ds = Sequel::Dataset.new(self)
@@ -409,9 +420,9 @@ module Sequel
     end
     
     # Parse the schema from the database.
-    # If the table_name is not given, returns the schema for all tables as a hash.
-    # If the table_name is given, returns the schema for a single table as an
-    # array with all members being arrays of length 2.  Available options are:
+    # Returns the schema for the given table as an array with all members being arrays of length 2,
+    # the first member being the column name, and the second member being a hash of column information.
+    # Available options are:
     #
     # * :reload - Get fresh information from the database, instead of using
     #   cached information.  If table_name is blank, :reload should be used
@@ -420,46 +431,24 @@ module Sequel
     #   that have been requested explicitly.
     # * :schema - An explicit schema to use.  It may also be implicitly provided
     #   via the table name.
-    def schema(table = nil, opts={})
-      Deprecation.deprecate('Calling Database#schema without a table argument', 'Use database.tables.inject({}){|h, m| h[m] = database.schema(m); h}') unless table
+    def schema(table, opts={})
       raise(Error, 'schema parsing is not implemented on this database') unless respond_to?(:schema_parse_table, true)
 
-      if table
-        sch, table_name = schema_and_table(table)
-        quoted_name = quote_schema_table(table)
-      end
+      sch, table_name = schema_and_table(table)
+      quoted_name = quote_schema_table(table)
       opts = opts.merge(:schema=>sch) if sch && !opts.include?(:schema)
-      if opts[:reload] && @schemas
-        if table_name
-          @schemas.delete(quoted_name)
-        else
-          @schemas = nil
-        end
-      end
-
-      if @schemas
-        if table_name
-          return @schemas[quoted_name] if @schemas[quoted_name]
-        else
-          return @schemas
-        end
-      end
 
-      raise(Error, '#tables does not exist, you must provide a specific table to #schema') if table.nil? && !respond_to?(:tables, true)
+      @schemas.delete(quoted_name) if opts[:reload] && @schemas
+      return @schemas[quoted_name] if @schemas && @schemas[quoted_name]
 
       @schemas ||= Hash.new do |h,k|
         quote_name = quote_schema_table(k)
         h[quote_name] if h.include?(quote_name)
       end
 
-      if table_name
-        cols = schema_parse_table(table_name, opts)
-        raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty?
-        @schemas[quoted_name] = cols
-      else
-        tables.each{|t| @schemas[quote_schema_table(t)] = schema_parse_table(t.to_s, opts)}
-        @schemas
-      end
+      cols = schema_parse_table(table_name, opts)
+      raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty?
+      @schemas[quoted_name] = cols
     end
 
     # Returns true if the database is using a single-threaded connection pool.
@@ -500,10 +489,6 @@ module Sequel
     # current transaction. Should be overridden for databases that support nested 
     # transactions.
     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 @transactions.include?(Thread.current)
         log_info(begin_transaction_sql)
@@ -579,6 +564,7 @@ module Sequel
     # strings with all whitespace, and ones that respond
     # true to empty?
     def blank_object?(obj)
+      return obj.blank? if obj.respond_to?(:blank?)
       case obj
       when NilClass, FalseClass
         true
@@ -622,6 +608,31 @@ module Sequel
       :downcase
     end
     
+    # Return a Method object for the dataset's output_identifier_method.
+    # Used in metadata parsing to make sure the returned information is in the
+    # correct format.
+    def input_identifier_meth
+      dataset.method(:input_identifier)
+    end
+
+    # Return a dataset that uses the default identifier input and output methods
+    # for this database.  Used when parsing metadata so that column symbols are
+    # returned as expected.
+    def metadata_dataset
+      return @metadata_dataset if @metadata_dataset
+      ds = dataset
+      ds.identifier_input_method = identifier_input_method_default
+      ds.identifier_output_method = identifier_output_method_default
+      @metadata_dataset = ds
+    end
+
+    # Return a Method object for the dataset's output_identifier_method.
+    # Used in metadata parsing to make sure the returned information is in the
+    # correct format.
+    def output_identifier_meth
+      dataset.method(:output_identifier)
+    end
+
     # Whether to quote identifiers by default for this database, true
     # by default.
     def quote_identifiers_default
@@ -661,6 +672,11 @@ module Sequel
       schema_utility_dataset.schema_and_table(table_name)
     end
 
+    # Return true if the given column schema represents an autoincrementing primary key.
+    def schema_autoincrementing_primary_key?(schema)
+      !!schema[:primary_key]
+    end
+
     # Match the database's column type to a ruby type via a
     # regular expression.  The following ruby types are supported:
     # integer, string, date, datetime, boolean, and float.
@@ -684,7 +700,7 @@ module Sequel
         :boolean
       when /\A(real|float|double( precision)?)\z/io
         :float
-      when /\A(numeric(\(\d+,\d+\))?|decimal|money)\z/io
+      when /\A(((numeric|decimal)(\(\d+,\d+\))?)|money)\z/io
         :decimal
       when /bytea|blob/io
         :blob

data/lib/sequel/database/schema_generator.rb

@@ -17,14 +17,25 @@ module Sequel
       GENERIC_TYPES=[String, Integer, Fixnum, Bignum, Float, Numeric, BigDecimal,
       Date, DateTime, Time, File, TrueClass, FalseClass]
       
+      # Return the columns created by this generator
+      attr_reader :columns
+
+      # Return the constraints created by this generator
+      attr_reader :constraints
+
+      # Return the indexes created by this generator
+      attr_reader :indexes
+
       # Set the database in which to create the table, and evaluate the block
       # in the context of this object.
       def initialize(db, &block)
         @db = db
         @columns = []
         @indexes = []
+        @constraints = []
         @primary_key = nil
         instance_eval(&block) if block
+        @columns.unshift(@primary_key) if @primary_key && !has_column?(primary_key_name)
       end
       
       # Add a method for each of the given types that creates a column
@@ -33,7 +44,7 @@ module Sequel
       # as a constant/class.
       def self.add_type_method(*types)
         types.each do |type|
-          class_eval "def #{type}(name, opts={}); column(name, #{type}, opts); end"
+          class_eval("def #{type}(name, opts={}); column(name, #{type}, opts); end", __FILE__, __LINE__)
         end
       end
       
@@ -72,24 +83,16 @@ module Sequel
       # * :unsigned - Make the column type unsigned, only useful for integer
       #   columns.
       def column(name, type, opts = {})
-        @columns << {:name => name, :type => type}.merge(opts)
+        columns << {:name => name, :type => type}.merge(opts)
         index(name) if opts[:index]
       end
       
       # Adds a named constraint (or unnamed if name is nil) to the DDL,
       # with the given block or args.
       def constraint(name, *args, &block)
-        @columns << {:name => name, :type => :check, :check => block || args,
-                     :constraint_type => :check}
+        constraints << {:name => name, :type => :check, :check => block || args}
       end
       
-      # Return the DDL created by the generator as a array of two elements,
-      # the first being the columns and the second being the indexes.
-      def create_info
-        @columns.unshift(@primary_key) if @primary_key && !has_column?(primary_key_name)
-        [@columns, @indexes]
-      end
-
       # Add a foreign key in the table that references another table to the DDL. See column
       # for available options.
       def foreign_key(name, table=nil, opts = {})
@@ -106,7 +109,7 @@ module Sequel
         return composite_foreign_key(name, opts) if name.is_a?(Array)
         column(name, Integer, opts)
       end
-      
+
       # Add a full text index on the given columns to the DDL.
       def full_text_index(columns, opts = {})
         index(columns, opts.merge(:type => :full_text))
@@ -114,7 +117,7 @@ module Sequel
       
       # True if the DDL includes the creation of a column with the given name.
       def has_column?(name)
-        @columns.any?{|c| c[:name] == name}
+        columns.any?{|c| c[:name] == name}
       end
       
       # Add an index on the given column(s) with the given options to the DDL.
@@ -124,7 +127,7 @@ module Sequel
       # * :unique - Make the index unique, so duplicate values are not allowed.
       # * :where - Create a partial index (only supported by some databases)
       def index(columns, opts = {})
-        @indexes << {:columns => Array(columns)}.merge(opts)
+        indexes << {:columns => Array(columns)}.merge(opts)
       end
       
       # Add a column with the given type, name, and opts to the DDL.  See column for available
@@ -171,8 +174,7 @@ module Sequel
 
       # Add a unique constraint on the given columns to the DDL.
       def unique(columns, opts = {})
-        @columns << {:type => :check, :constraint_type => :unique,
-                     :name => nil, :columns => Array(columns)}.merge(opts)
+        constraints << {:type => :unique, :columns => Array(columns)}.merge(opts)
       end
 
       private
@@ -180,14 +182,12 @@ module Sequel
       # Add a composite primary key constraint
       def composite_primary_key(columns, *args)
         opts = args.pop || {}
-        @columns << {:type => :check, :constraint_type => :primary_key,
-                     :name => nil, :columns => columns}.merge(opts)
+        constraints << {:type => :primary_key, :columns => columns}.merge(opts)
       end
 
       # Add a composite foreign key constraint
       def composite_foreign_key(columns, opts)
-        @columns << {:type => :check, :constraint_type => :foreign_key,
-                     :name => nil, :columns => columns }.merge(opts)
+        constraints << {:type => :foreign_key, :columns => columns}.merge(opts)
       end
       
       add_type_method(*GENERIC_TYPES)
@@ -220,13 +220,11 @@ module Sequel
       # Add a constraint with the given name and args to the DDL for the table.
       # See Generator#constraint.
       def add_constraint(name, *args, &block)
-        @operations << {:op => :add_constraint, :name => name, :type => :check, \
-          :constraint_type => :check, :check => block || args}
+        @operations << {:op => :add_constraint, :name => name, :type => :check, :check => block || args}
       end
 
       def add_unique_constraint(columns, opts = {})
-        @operations << {:op => :add_constraint, :type => :check,
-          :constraint_type => :unique, :columns => Array(columns)}.merge(opts)
+        @operations << {:op => :add_constraint, :type => :unique, :columns => Array(columns)}.merge(opts)
       end
 
       # Add a foreign key with the given name and referencing the given table
@@ -280,8 +278,8 @@ module Sequel
       end
       
       # Remove an index from the DDL for the table.
-      def drop_index(columns)
-        @operations << {:op => :drop_index, :columns => Array(columns)}
+      def drop_index(columns, options={})
+        @operations << {:op => :drop_index, :columns => Array(columns)}.merge(options)
       end
 
       # Modify a column's name in the DDL for the table.
@@ -308,15 +306,12 @@ module Sequel
 
       # Add a composite primary key constraint
       def add_composite_primary_key(columns, opts)
-        @operations << {:op => :add_constraint, :type => :check,
-          :constraint_type => :primary_key, :columns => columns}.merge(opts)
+        @operations << {:op => :add_constraint, :type => :primary_key, :columns => columns}.merge(opts)
       end
 
       # Add a composite foreign key constraint
       def add_composite_foreign_key(columns, table, opts)
-        @operations << {:op => :add_constraint, :type => :check,
-          :constraint_type => :foreign_key, :columns => columns,
-          :table => table}.merge(opts)
+        @operations << {:op => :add_constraint, :type => :foreign_key, :columns => columns, :table => table}.merge(opts)
       end
     end
   end