sequel 3.1.0 → 3.2.0

data/lib/sequel/adapters/sqlite.rb

@@ -189,11 +189,12 @@ module Sequel
       # Yield a hash for each row in the dataset.
       def fetch_rows(sql)
         execute(sql) do |result|
-          @columns = result.columns.map{|c| output_identifier(c)}
-          column_count = @columns.size
+          i = -1
+          cols = result.columns.map{|c| [output_identifier(c), i+=1]}
+          @columns = cols.map{|c| c.first}
           result.each do |values|
             row = {}
-            column_count.times {|i| row[@columns[i]] = values[i]}
+            cols.each{|n,i| row[n] = values[i]}
             yield row
           end
         end

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

@@ -7,9 +7,24 @@ module Sequel
       # The name of the stored procedure to call
       attr_accessor :sproc_name
       
-      # Call the prepared statement
+      # The name of the stored procedure to call
+      attr_writer :sproc_args
+      
+      # Call the stored procedure with the given args
       def call(*args, &block)
-        @sproc_args = args
+        sp = clone
+        sp.sproc_args = args
+        sp.run(&block)
+      end
+
+      # Programmer friendly string showing this is a stored procedure,
+      # showing the name of the procedure.
+      def inspect
+        "<#{self.class.name}/StoredProcedure name=#{@sproc_name}>"
+      end
+      
+      # Run the stored procedure with the current args on the database
+      def run(&block)
         case @sproc_type
         when :select, :all
           all(&block)
@@ -24,13 +39,7 @@ module Sequel
         end
       end
       
-      # Programmer friendly string showing this is a stored procedure,
-      # showing the name of the procedure.
-      def inspect
-        "<#{self.class.name}/StoredProcedure name=#{@sproc_name}>"
-      end
-      
-      # Set the type of the sproc and override the corresponding _sql
+      # Set the type of the stored procedure and override the corresponding _sql
       # method to return the empty string (since the result will be
       # ignored anyway).
       def sproc_type=(type)

data/lib/sequel/connection_pool.rb

@@ -41,7 +41,8 @@ class Sequel::ConnectionPool
   #   present, will use a single :default server.  The server name symbol will
   #   be passed to the connection_proc.
   def initialize(opts = {}, &block)
-    @max_size = opts[:max_connections] || 4
+    @max_size = Integer(opts[:max_connections] || 4)
+    raise(Sequel::Error, ':max_connections must be positive') if @max_size < 1
     @mutex = Mutex.new
     @connection_proc = block
     @disconnection_proc = opts[:disconnection_proc]
@@ -53,8 +54,8 @@ class Sequel::ConnectionPool
       @available_connections[s] = []
       @allocated[s] = {}
     end
-    @timeout = opts[:pool_timeout] || 5
-    @sleep_time = opts[:pool_sleep_time] || 0.001
+    @timeout = Integer(opts[:pool_timeout] || 5)
+    @sleep_time = Float(opts[:pool_sleep_time] || 0.001)
     @convert_exceptions = opts.include?(:pool_convert_exceptions) ? opts[:pool_convert_exceptions] : true
   end
   

data/lib/sequel/database.rb

@@ -21,11 +21,18 @@ module Sequel
 
     SQL_BEGIN = 'BEGIN'.freeze
     SQL_COMMIT = 'COMMIT'.freeze
+    SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
     SQL_ROLLBACK = 'ROLLBACK'.freeze
+    SQL_ROLLBACK_TO_SAVEPOINT = 'ROLLBACK TO SAVEPOINT autopoint_%d'.freeze
+    SQL_SAVEPOINT = 'SAVEPOINT autopoint_%d'.freeze
     
     TRANSACTION_BEGIN = 'Transaction.begin'.freeze
     TRANSACTION_COMMIT = 'Transaction.commit'.freeze
     TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
+    
+    POSTGRES_DEFAULT_RE = /\A(?:B?('.*')::[^']+|\((-?\d+(?:\.\d+)?)\))\z/
+    MYSQL_TIMESTAMP_RE = /\ACURRENT_(?:DATE|TIMESTAMP)?\z/
+    STRING_DEFAULT_RE = /\A'(.*)'\z/
 
     # The identifier input method to use by default
     @@identifier_input_method = nil
@@ -73,7 +80,7 @@ module Sequel
     def initialize(opts = {}, &block)
       @opts ||= opts
       
-      @single_threaded = opts.include?(:single_threaded) ? opts[:single_threaded] : @@single_threaded
+      @single_threaded = opts.include?(:single_threaded) ? typecast_value_boolean(opts[:single_threaded]) : @@single_threaded
       @schemas = {}
       @default_schema = opts.include?(:default_schema) ? opts[:default_schema] : default_schema_default
       @prepared_statements = {}
@@ -120,7 +127,8 @@ module Sequel
     
     # Connects to a database.  See Sequel.connect.
     def self.connect(conn_string, opts = {}, &block)
-      if conn_string.is_a?(String)
+      case conn_string
+      when String
         if match = /\A(jdbc|do):/o.match(conn_string)
           c = adapter_class(match[1].to_sym)
           opts = {:uri=>conn_string}.merge(opts)
@@ -133,9 +141,11 @@ module Sequel
           uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v} unless uri.query.to_s.strip.empty?
           opts = c.send(:uri_to_options, uri).merge(uri_options).merge(opts)
         end
-      else
+      when Hash
         opts = conn_string.merge(opts)
         c = adapter_class(opts[:adapter] || opts['adapter'])
+      else
+        raise Error, "Sequel::Database.connect takes either a Hash or a String, given: #{conn_string.inspect}"
       end
       # process opts a bit
       opts = opts.inject({}) do |m, kv| k, v = *kv
@@ -447,6 +457,7 @@ module Sequel
 
       cols = schema_parse_table(table_name, opts)
       raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty?
+      cols.each{|_,c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
       @schemas[quoted_name] = cols
     end
 
@@ -460,7 +471,7 @@ module Sequel
       @pool.hold(server || :default, &block)
     end
     
-    # Whether the database and adapter support savepoints
+    # Whether the database and adapter support savepoints, false by default
     def supports_savepoints?
       false
     end
@@ -571,17 +582,38 @@ module Sequel
     
     # Add the current thread to the list of active transactions
     def add_transaction
-      @transactions << Thread.current
+      th = Thread.current
+      if supports_savepoints?
+        unless @transactions.include?(th)
+          th[:sequel_transaction_depth] = 0
+          @transactions << th
+        end
+      else
+        @transactions << th
+      end
     end    
 
     # Whether the current thread/connection is already inside a transaction
     def already_in_transaction?(conn, opts)
-      @transactions.include?(Thread.current)
+      @transactions.include?(Thread.current) && (!supports_savepoints? || !opts[:savepoint])
     end
     
+    # SQL to start a new savepoint
+    def begin_savepoint_sql(depth)
+      SQL_SAVEPOINT % depth
+    end
+
     # Start a new database transaction on the given connection.
     def begin_transaction(conn)
-      log_connection_execute(conn, begin_transaction_sql)
+      if supports_savepoints?
+        th = Thread.current
+        depth = th[:sequel_transaction_depth]
+        conn = transaction_statement_object(conn) if respond_to?(:transaction_statement_object, true)
+        log_connection_execute(conn, depth > 0 ? begin_savepoint_sql(depth) : begin_transaction_sql)
+        th[:sequel_transaction_depth] += 1
+      else
+        log_connection_execute(conn, begin_transaction_sql)
+      end
       conn
     end
     
@@ -608,9 +640,66 @@ module Sequel
       end
     end
     
+    # Convert the given default, which should be a database specific string, into
+    # a ruby object.
+    def column_schema_to_ruby_default(default, type)
+      return if default.nil?
+      orig_default = default
+      if database_type == :postgres and m = POSTGRES_DEFAULT_RE.match(default)
+        default = m[1] || m[2]
+      end
+      if [:string, :blob, :date, :datetime, :time].include?(type)
+        if database_type == :mysql
+          return if [:date, :datetime, :time].include?(type) && MYSQL_TIMESTAMP_RE.match(default)
+          orig_default = default = "'#{default.gsub("'", "''").gsub('\\', '\\\\')}'" 
+        end
+        return unless m = STRING_DEFAULT_RE.match(default)
+        default = m[1].gsub("''", "'")
+      end
+      res = begin
+        case type
+        when :boolean
+          case default 
+          when /[f0]/i
+            false
+          when /[t1]/i
+            true
+          end
+        when :string
+          default
+        when :blob
+          Sequel::SQL::Blob.new(default)
+        when :integer
+          Integer(default)
+        when :float
+          Float(default)
+        when :date
+          Sequel.string_to_date(default)
+        when :datetime
+          DateTime.parse(default)
+        when :time
+          Sequel.string_to_time(default)
+        when :decimal
+          BigDecimal.new(default)
+        end
+      rescue
+        nil
+      end
+    end
+   
+    # SQL to commit a savepoint
+    def commit_savepoint_sql(depth)
+      SQL_RELEASE_SAVEPOINT % depth
+    end
+
     # Commit the active transaction on the connection
     def commit_transaction(conn)
-      log_connection_execute(conn, commit_transaction_sql)
+      if supports_savepoints?
+        depth = Thread.current[:sequel_transaction_depth]
+        log_connection_execute(conn, depth > 1 ? commit_savepoint_sql(depth-1) : commit_transaction_sql)
+      else
+        log_connection_execute(conn, commit_transaction_sql)
+      end
     end
 
     # SQL to COMMIT a transaction.
@@ -717,7 +806,8 @@ module Sequel
     
     # Remove the current thread from the list of active transactions
     def remove_transaction(conn)
-      @transactions.delete(Thread.current)
+      th = Thread.current
+      @transactions.delete(th) if !supports_savepoints? || ((th[:sequel_transaction_depth] -= 1) <= 0)
     end
 
     # Remove the cached schema_utility_dataset, because the identifier
@@ -726,9 +816,19 @@ module Sequel
       @schema_utility_dataset = nil
     end
     
+    # SQL to rollback to a savepoint
+    def rollback_savepoint_sql(depth)
+      SQL_ROLLBACK_TO_SAVEPOINT % depth
+    end
+
     # Rollback the active transaction on the connection
     def rollback_transaction(conn)
-      log_connection_execute(conn, rollback_transaction_sql)
+      if supports_savepoints?
+        depth = Thread.current[:sequel_transaction_depth]
+        log_connection_execute(conn, depth > 1 ? rollback_savepoint_sql(depth-1) : rollback_transaction_sql)
+      else
+        log_connection_execute(conn, rollback_transaction_sql)
+      end
     end
 
     # Split the schema information from the table

data/lib/sequel/database/schema_sql.rb

@@ -74,7 +74,7 @@ module Sequel
       sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
       sql << PRIMARY_KEY if column[:primary_key]
       sql << " #{auto_increment_sql}" if column[:auto_increment]
-      sql << column_references_sql(column) if column[:table]
+      sql << column_references_column_constraint_sql(column) if column[:table]
       sql
     end
     
@@ -84,6 +84,11 @@ module Sequel
       (generator.columns.map{|c| column_definition_sql(c)} + generator.constraints.map{|c| constraint_definition_sql(c)}).join(COMMA_SEPARATOR)
     end
 
+    # SQL DDL fragment for column foreign key references (column constraints)
+    def column_references_column_constraint_sql(column)
+      column_references_sql(column)
+    end
+
     # SQL DDL fragment for column foreign key references
     def column_references_sql(column)
       sql = " REFERENCES #{quote_schema_table(column[:table])}"
@@ -93,6 +98,11 @@ module Sequel
       sql
     end
   
+    # SQL DDL fragment for table foreign key references (table constraints)
+    def column_references_table_constraint_sql(constraint)
+      "FOREIGN KEY #{literal(constraint[:columns])}#{column_references_sql(constraint)}"
+    end
+
     # SQL DDL fragment specifying a constraint on a table.
     def constraint_definition_sql(constraint)
       sql = constraint[:name] ? "CONSTRAINT #{quote_identifier(constraint[:name])} " : ""
@@ -103,8 +113,7 @@ module Sequel
       when :primary_key
         sql << "PRIMARY KEY #{literal(constraint[:columns])}"
       when :foreign_key
-        sql << "FOREIGN KEY #{literal(constraint[:columns])}"
-        sql << column_references_sql(constraint)
+        sql << column_references_table_constraint_sql(constraint)
       when :unique
         sql << "UNIQUE #{literal(constraint[:columns])}"
       else

data/lib/sequel/dataset.rb

@@ -45,12 +45,13 @@ module Sequel
     MUTATION_METHODS = %w'add_graph_aliases and distinct exclude exists
     filter from from_self full_outer_join graph
     group group_and_count group_by having inner_join intersect invert join
-    left_outer_join limit naked or order order_by order_more paginate query reject
+    left_outer_join limit naked or order order_by order_more paginate qualify query reject
     reverse reverse_order right_outer_join select select_all select_more
     set_defaults set_graph_aliases set_overrides sort sort_by
-    unfiltered union unordered where with_sql'.collect{|x| x.to_sym}
+    unfiltered ungraphed union unordered where with with_sql'.collect{|x| x.to_sym}
 
     NOTIMPL_MSG = "This method must be overridden in Sequel adapters".freeze
+    WITH_SUPPORTED='with'.freeze
 
     # The database that corresponds to this dataset
     attr_accessor :db
@@ -218,6 +219,12 @@ module Sequel
       @quote_identifiers
     end
     
+    # Whether the dataset requires SQL standard datetimes (false by default,
+    # as most allow strings with ISO 8601 format.
+    def requires_sql_standard_datetimes?
+      false
+    end
+
     # Set the server for this dataset to use.  Used to pick a specific database
     # shard to run a query against, or to override the default (which is SELECT uses
     # :read_only database and all other queries use the :default database).
@@ -242,6 +249,36 @@ module Sequel
     def set_overrides(hash)
       clone(:overrides=>hash.merge(@opts[:overrides]||{}))
     end
+    
+    # Whether the dataset supports common table expressions (the WITH clause).
+    def supports_cte?
+      select_clause_order.include?(WITH_SUPPORTED)
+    end
+
+    # Whether the dataset supports the DISTINCT ON clause, true by default.
+    def supports_distinct_on?
+      true
+    end
+
+    # Whether the dataset supports the INTERSECT and EXCEPT compound operations, true by default.
+    def supports_intersect_except?
+      true
+    end
+
+    # Whether the dataset supports the INTERSECT ALL and EXCEPT ALL compound operations, true by default.
+    def supports_intersect_except_all?
+      true
+    end
+
+    # Whether the dataset supports the IS TRUE syntax.
+    def supports_is_true?
+      true
+    end
+    
+    # Whether the dataset supports window functions.
+    def supports_window_functions?
+      false
+    end
 
     # Updates values for the dataset.  The returned value is generally the
     # number of rows updated, but that is adapter dependent.
@@ -262,7 +299,7 @@ module Sequel
     # Whether this dataset is a simple SELECT * FROM table.
     def simple_select_all?
       o = @opts.reject{|k,v| v.nil?}
-      o.length == 1 && o[:from] && o[:from].length == 1
+      o.length == 1 && (f = o[:from]) && f.length == 1 && f.first.is_a?(Symbol)
     end
 
     private

data/lib/sequel/dataset/convenience.rb

@@ -210,17 +210,6 @@ module Sequel
       get{|o| o.sum(column)}
     end
 
-    # Returns true if the table exists.  Will raise an error
-    # if the dataset has fixed SQL or selects from another dataset
-    # or more than one table.
-    def table_exists?
-      raise(Sequel::Error, "this dataset has fixed SQL") if @opts[:sql]
-      raise(Sequel::Error, "this dataset selects from multiple sources") if @opts[:from].size != 1
-      t = @opts[:from].first
-      raise(Sequel::Error, "this dataset selects from a sub query") if t.is_a?(Dataset)
-      @db.table_exists?(t)
-    end
-
     # Returns a string in CSV format containing the dataset records. By 
     # default the CSV representation includes the column titles in the
     # first line. You can turn that off by passing false as the 

data/lib/sequel/dataset/graph.rb

@@ -1,5 +1,14 @@
 module Sequel
   class Dataset
+    # Adds the given graph aliases to the list of graph aliases to use,
+    # unlike #set_graph_aliases, which replaces the list.  See
+    # #set_graph_aliases.
+    def add_graph_aliases(graph_aliases)
+      ds = select_more(*graph_alias_columns(graph_aliases))
+      ds.opts[:graph_aliases] = (ds.opts[:graph_aliases] || ds.opts[:graph][:column_aliases] || {}).merge(graph_aliases)
+      ds
+    end
+
     # Allows you to join multiple datasets/tables and have the result set
     # split into component tables.
     #
@@ -48,12 +57,20 @@ module Sequel
       # Allow the use of a model, dataset, or symbol as the first argument
       # Find the table name/dataset based on the argument
       dataset = dataset.dataset if dataset.respond_to?(:dataset)
+      table_alias = options[:table_alias]
       case dataset
       when Symbol
         table = dataset
         dataset = @db[dataset]
+        table_alias ||= table
       when ::Sequel::Dataset
-        table = dataset.first_source
+        if dataset.simple_select_all?
+          table = dataset.opts[:from].first
+          table_alias ||= table
+        else
+          table = dataset
+          table_alias ||= dataset_alias((@opts[:num_dataset_sources] || 0)+1)
+        end
       else
         raise Error, "The dataset argument should be a symbol, dataset, or model"
       end
@@ -65,11 +82,10 @@ module Sequel
       end
 
       # Only allow table aliases that haven't been used
-      table_alias = options[:table_alias] || table
       raise_alias_error.call if @opts[:graph] && @opts[:graph][:table_aliases] && @opts[:graph][:table_aliases].include?(table_alias)
 
       # Join the table early in order to avoid cloning the dataset twice
-      ds = join_table(options[:join_type] || :left_outer, dataset.simple_select_all? ? table : dataset, join_conditions, :table_alias=>table_alias, :implicit_qualifier=>options[:implicit_qualifier], &block)
+      ds = join_table(options[:join_type] || :left_outer, table, join_conditions, :table_alias=>table_alias, :implicit_qualifier=>options[:implicit_qualifier], &block)
       opts = ds.opts
 
       # Whether to include the table in the result set
@@ -79,7 +95,7 @@ module Sequel
 
       # Setup the initial graph data structure if it doesn't exist
       unless graph = opts[:graph]
-        master = ds.first_source
+        master = ds.first_source_alias
         raise_alias_error.call if master == table_alias
         # Master hash storing all .graph related information
         graph = opts[:graph] = {}
@@ -162,13 +178,11 @@ module Sequel
       ds
     end
 
-    # Adds the give graph aliases to the list of graph aliases to use,
-    # unlike #set_graph_aliases, which replaces the list.  See
-    # #set_graph_aliases.
-    def add_graph_aliases(graph_aliases)
-      ds = select_more(*graph_alias_columns(graph_aliases))
-      ds.opts[:graph_aliases] = (ds.opts[:graph_aliases] || ds.opts[:graph][:column_aliases] || {}).merge(graph_aliases)
-      ds
+    # Remove the splitting of results into subhashes.  Also removes
+    # metadata related to graphing, so you should not call graph
+    # any tables to this dataset after calling this method.
+    def ungraphed
+      clone(:graph=>nil)
     end
 
     private