sequel 0.4.4.1 → 0.4.4.2

data/lib/sequel/connection_pool.rb

@@ -107,7 +107,7 @@ module Sequel
         if @created_count < @max_size
           @created_count += 1
           @connection_proc ? @connection_proc.call : \
-            (raise SequelError, "No connection proc specified")
+            (raise Error, "No connection proc specified")
         end
       end
       

data/lib/sequel/core_sql.rb

@@ -47,7 +47,12 @@ class String
   
   # Converts a string into a Time object.
   def to_time
-    Time.parse(self)
+    begin
+      Time.parse(self)
+    rescue Exception => e
+      raise Error::InvalidValue, "Invalid time value '#{self}' (#{e.message})"
+    end
+     # Why does Time.parse('0000-00-00') bork and not return nil or some such?
   end
 end
 
@@ -163,10 +168,14 @@ class Symbol
   #
   def to_column_ref(ds)
     case s = to_s
-    when COLUMN_REF_RE1: "#{$1}.#{ds.quote_column_ref($2)} AS #{ds.quote_column_ref($3)}"
-    when COLUMN_REF_RE2: "#{ds.quote_column_ref($1)} AS #{ds.quote_column_ref($2)}"
-    when COLUMN_REF_RE3: "#{$1}.#{ds.quote_column_ref($2)}"
-    else                 ds.quote_column_ref(s)
+    when COLUMN_REF_RE1
+      "#{$1}.#{ds.quote_column_ref($2)} AS #{ds.quote_column_ref($3)}"
+    when COLUMN_REF_RE2
+      "#{ds.quote_column_ref($1)} AS #{ds.quote_column_ref($2)}"
+    when COLUMN_REF_RE3
+      "#{$1}.#{ds.quote_column_ref($2)}"
+    else
+      ds.quote_column_ref(s)
     end
   end
   

data/lib/sequel/database.rb

@@ -135,9 +135,9 @@ module Sequel
       (String === args.first) ? fetch(*args) : from(*args)
     end
 
-    # Raises a NotImplementedError. This method is overriden in descendants.
+    # Raises a Sequel::Error::NotImplemented. This method is overriden in descendants.
     def execute(sql)
-      raise NotImplementedError
+      raise NotImplementedError, "#execute should be overriden by adapters"
     end
     
     # Executes the supplied SQL statement. The SQL can be supplied as a string
@@ -272,7 +272,7 @@ module Sequel
           result
         rescue => e
           conn.execute(SQL_ROLLBACK)
-          raise e unless SequelRollbackError === e
+          raise e unless Error::Rollback === e
         ensure
           @transactions.delete(Thread.current)
         end
@@ -318,7 +318,7 @@ module Sequel
         require File.join(File.dirname(__FILE__), "adapters/#{scheme}")
         c = @@adapters[scheme.to_sym]
       end
-      raise SequelError, "Invalid database scheme" unless c
+      raise Error::InvalidDatabaseScheme, "Invalid database scheme" unless c
       c
     end
         

data/lib/sequel/dataset.rb

@@ -226,28 +226,28 @@ module Sequel
     def set_model(key, *args)
       # pattern matching
       case key
-      when nil: # set_model(nil) => no
+      when nil # set_model(nil) => no
         # no argument provided, so the dataset is denuded
         @opts.merge!(:naked => true, :models => nil, :polymorphic_key => nil)
         remove_row_proc
         # extend_with_stock_each
-      when Class:
+      when Class
         # isomorphic model
         @opts.merge!(:naked => nil, :models => {nil => key}, :polymorphic_key => nil)
         set_row_proc {|h| key.new(h, *args)}
         extend_with_destroy
-      when Symbol:
+      when Symbol
         # polymorphic model
-        hash = args.shift || raise(SequelError, "No class hash supplied for polymorphic model")
+        hash = args.shift || raise(ArgumentError, "No class hash supplied for polymorphic model")
         @opts.merge!(:naked => true, :models => hash, :polymorphic_key => key)
         set_row_proc do |h|
           c = hash[h[key]] || hash[nil] || \
-            raise(SequelError, "No matching model class for record (#{polymorphic_key} => #{h[polymorphic_key].inspect})")
+            raise(Error, "No matching model class for record (#{polymorphic_key} => #{h[polymorphic_key].inspect})")
           c.new(h, *args)
         end
         extend_with_destroy
       else
-        raise SequelError, "Invalid parameters specified"
+        raise ArgumentError, "Invalid model specified"
       end
       self
     end
@@ -300,13 +300,13 @@ module Sequel
       @transform = t
       t.each do |k, v|
         case v
-        when Array:
+        when Array
           if (v.size != 2) || !v.first.is_a?(Proc) && !v.last.is_a?(Proc)
-            raise SequelError, "Invalid transform specified"
+            raise Error::InvalidTransform, "Invalid transform specified"
           end
         else
           unless v = STOCK_TRANSFORMS[v]
-            raise SequelError, "Invalid transform specified"
+            raise Error::InvalidTransform, "Invalid transform specified"
           else
             t[k] = v
           end
@@ -384,7 +384,9 @@ module Sequel
     def extend_with_destroy
       unless respond_to?(:destroy)
         meta_def(:destroy) do
-          raise SequelError, 'Dataset not associated with model' unless @opts[:models]
+          unless @opts[:models]
+            raise Error, "No model associated with this dataset"
+          end
           count = 0
           @db.transaction {each {|r| count += 1; r.destroy}}
           count

data/lib/sequel/dataset/convenience.rb

@@ -38,8 +38,10 @@ module Sequel
         end
         args = args.empty? ? 1 : (args.size == 1) ? args.first : args
         case args
-        when 1: single_record(:limit => 1)
-        when Fixnum: limit(args).all
+        when 1
+          single_record(:limit => 1)
+        when Fixnum
+          limit(args).all
         else
           filter(args, &block).single_record(:limit => 1)
         end
@@ -59,13 +61,13 @@ module Sequel
       # record is returned. Otherwise an array is returned with the last 
       # <i>num</i> records.
       def last(*args)
-        raise SequelError, 'No order specified' unless 
+        raise Error, 'No order specified' unless 
           @opts[:order] || (opts && opts[:order])
 
         args = args.empty? ? 1 : (args.size == 1) ? args.first : args
 
         case args
-        when Fixnum:
+        when Fixnum
           l = {:limit => args}
           opts = {:order => invert_order(@opts[:order])}. \
             merge(opts ? opts.merge(l) : l)
@@ -238,10 +240,10 @@ module Sequel
       end
       
       module QueryBlockCopy #:nodoc:
-        def each(*args); raise SequelError, "#each cannot be invoked inside a query block."; end
-        def insert(*args); raise SequelError, "#insert cannot be invoked inside a query block."; end
-        def update(*args); raise SequelError, "#update cannot be invoked inside a query block."; end
-        def delete(*args); raise SequelError, "#delete cannot be invoked inside a query block."; end
+        def each(*args); raise Error, "#each cannot be invoked inside a query block."; end
+        def insert(*args); raise Error, "#insert cannot be invoked inside a query block."; end
+        def update(*args); raise Error, "#update cannot be invoked inside a query block."; end
+        def delete(*args); raise Error, "#delete cannot be invoked inside a query block."; end
         
         def clone_merge(opts)
           @opts.merge!(opts)

data/lib/sequel/dataset/sequelizer.rb

@@ -38,17 +38,17 @@ class Sequel::Dataset
     #     "(id = 3)"
     def compare_expr(l, r)
       case r
-      when Range:
+      when Range
         r.exclude_end? ? \
           "(#{literal(l)} >= #{literal(r.begin)} AND #{literal(l)} < #{literal(r.end)})" : \
           "(#{literal(l)} >= #{literal(r.begin)} AND #{literal(l)} <= #{literal(r.end)})"
-      when Array:
+      when Array
         "(#{literal(l)} IN (#{literal(r)}))"
-      when Sequel::Dataset:
+      when Sequel::Dataset
         "(#{literal(l)} IN (#{r.sql}))"
-      when NilClass:
+      when NilClass
         "(#{literal(l)} IS NULL)"
-      when Regexp:
+      when Regexp
         match_expr(l, r)
       else
         "(#{literal(l)} = #{literal(r)})"
@@ -60,10 +60,10 @@ class Sequel::Dataset
     # can override this method to provide support for regular expressions.
     def match_expr(l, r)
       case r
-      when String:
+      when String
         "(#{literal(l)} LIKE #{literal(r)})"
       else
-        raise SequelError, "Unsupported match pattern class (#{r.class})."
+        raise Sequel::Error, "Unsupported match pattern class (#{r.class})."
       end
     end
 
@@ -250,9 +250,9 @@ class Sequel::Dataset
         vcall_expr(e, b, opts)
       when :ivar, :cvar, :dvar, :const, :gvar # local ref
         eval(e[1].to_s, b)
-      when :nth_ref:
+      when :nth_ref
         eval("$#{e[1]}", b)
-      when :lvar: # local context
+      when :lvar # local context
         if e[1] == :block
           pr = eval(e[1].to_s, b)
           "#{proc_to_sql(pr)}"
@@ -267,9 +267,12 @@ class Sequel::Dataset
         eval_expr(e[1], b, opts)...eval_expr(e[2], b, opts)
       when :colon2 # qualified constant ref
         eval_expr(e[1], b, opts).const_get(e[2])
-      when :false: false
-      when :true: true
-      when :nil: nil
+      when :false
+        false
+      when :true
+        true
+      when :nil
+        nil
       when :array
         # array
         e[1..-1].map {|i| eval_expr(i, b, opts)}
@@ -284,11 +287,11 @@ class Sequel::Dataset
         # assignment
         l = e[1]
         r = eval_expr(e[2], b, opts)
-        raise SequelError, "Invalid expression #{l} = #{r}. Did you mean :#{l} == #{r}?"
+        raise Sequel::Error::InvalidExpression, "#{l} = #{r}. Did you mean :#{l} == #{r}?"
       when :if, :dstr
         ext_expr(e, b, opts)
       else
-        raise SequelError, "Invalid expression tree: #{e.inspect}"
+        raise Sequel::Error::InvalidExpression, "Invalid expression tree: #{e.inspect}"
       end
     end
     
@@ -338,7 +341,7 @@ begin
 rescue Exception
   module Sequel::Dataset::Sequelizer
     def proc_to_sql(proc)
-      raise SequelError, "You must have the ParseTree gem installed in order to use block filters."
+      raise Sequel::Error, "You must have the ParseTree gem installed in order to use block filters."
     end
   end
 end
@@ -348,7 +351,7 @@ begin
 rescue Exception
   module Sequel::Dataset::Sequelizer
     def ext_expr(e)
-      raise SequelError, "You must have the Ruby2Ruby gem installed in order to use this block filter."
+      raise Sequel::Error, "You must have the Ruby2Ruby gem installed in order to use this block filter."
     end
   end
 end

data/lib/sequel/dataset/sql.rb

@@ -45,15 +45,15 @@ module Sequel
       # Converts an array of sources names into into a comma separated list.
       def source_list(source)
         if source.nil? || source.empty?
-          raise SequelError, 'No source specified for query'
+          raise Error, 'No source specified for query'
         end
         auto_alias_count = 0
         m = source.map do |i|
           case i
-          when Dataset:
+          when Dataset
             auto_alias_count += 1
             i.to_table_reference(auto_alias_count)
-          when Hash:
+          when Hash
             i.map {|k, v| "#{k.is_a?(Dataset) ? k.to_table_reference : k} #{v}"}.
               join(COMMA_SEPARATOR)
           else
@@ -84,21 +84,34 @@ module Sequel
       # If an unsupported object is given, an exception is raised.
       def literal(v)
         case v
-        when LiteralString: v
-        when String: "'#{v.gsub(/'/, "''")}'"
-        when Integer, Float: v.to_s
-        when BigDecimal: v.to_s("F")
-        when NilClass: NULL
-        when TrueClass: TRUE
-        when FalseClass: FALSE
-        when Symbol: v.to_column_ref(self)
-        when Sequel::SQL::Expression: v.to_s(self)
-        when Array: v.empty? ? NULL : v.map {|i| literal(i)}.join(COMMA_SEPARATOR)
-        when Time: v.strftime(TIMESTAMP_FORMAT)
-        when Date: v.strftime(DATE_FORMAT)
-        when Dataset: "(#{v.sql})"
+        when LiteralString
+          v
+        when String
+          "'#{v.gsub(/'/, "''")}'"
+        when Integer, Float
+          v.to_s
+        when BigDecimal
+          v.to_s("F")
+        when NilClass
+          NULL
+        when TrueClass
+          TRUE
+        when FalseClass
+          FALSE
+        when Symbol
+          v.to_column_ref(self)
+        when Sequel::SQL::Expression
+          v.to_s(self)
+        when Array
+          v.empty? ? NULL : v.map {|i| literal(i)}.join(COMMA_SEPARATOR)
+        when Time
+          v.strftime(TIMESTAMP_FORMAT)
+        when Date
+          v.strftime(DATE_FORMAT)
+        when Dataset
+          "(#{v.sql})"
         else
-          raise SequelError, "can't express #{v.inspect} as a SQL literal"
+          raise Error, "can't express #{v.inspect} as a SQL literal"
         end
       end
 
@@ -109,12 +122,12 @@ module Sequel
       # generated clause will be enclosed in a set of parentheses.
       def expression_list(expr, parenthesize = false)
         case expr
-        when Hash:
+        when Hash
           parenthesize = false if expr.size == 1
           fmt = expr.map {|i| compare_expr(i[0], i[1])}.join(AND_SEPARATOR)
-        when Array:
+        when Array
           fmt = expr.shift.gsub(QUESTION_MARK) {literal(expr.shift)}
-        when Proc:
+        when Proc
           fmt = proc_to_sql(expr)
         else
           # if the expression is compound, it should be parenthesized in order for 
@@ -204,7 +217,7 @@ module Sequel
         clause = (@opts[:group] ? :having : :where)
         cond = cond.first if cond.size == 1
         if cond === true || cond === false
-          raise SequelError, "Invalid filter specified. Did you mean to supply a block?"
+          raise Error::InvalidFilter, "Invalid filter specified. Did you mean to supply a block?"
         end
         parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
         filter = cond.is_a?(Hash) && cond
@@ -228,7 +241,7 @@ module Sequel
           r = expression_list(block || cond, parenthesize)
           clone_merge(clause => "#{l} OR #{r}")
         else
-          raise SequelError, "No existing filter found."
+          raise Error::NoExistingFilter, "No existing filter found."
         end
       end
 
@@ -238,7 +251,7 @@ module Sequel
       def and(*cond, &block)
         clause = (@opts[:group] ? :having : :where)
         unless @opts[clause]
-          raise SequelError, "No existing filter found."
+          raise Error::NoExistingFilter, "No existing filter found."
         end
         filter(*cond, &block)
       end
@@ -265,7 +278,7 @@ module Sequel
       # if the dataset has been grouped. See also #filter.
       def where(*cond, &block)
         if @opts[:group]
-          raise SequelError, "Can't specify a WHERE clause once the dataset has been grouped"
+          raise Error, "Can't specify a WHERE clause once the dataset has been grouped"
         else
           filter(*cond, &block)
         end
@@ -275,7 +288,7 @@ module Sequel
       # if the dataset has not been grouped. See also #filter
       def having(*cond, &block)
         unless @opts[:group]
-          raise SequelError, "Can only specify a HAVING clause on a grouped dataset"
+          raise Error, "Can only specify a HAVING clause on a grouped dataset"
         else
           filter(*cond, &block)
         end
@@ -310,7 +323,7 @@ module Sequel
       def join_expr(type, table, expr)
         join_type = JOIN_TYPES[type || :inner]
         unless join_type
-          raise SequelError, "Invalid join type: #{type}"
+          raise Error::InvalidJoinType, "Invalid join type: #{type}"
         end
 
         join_conditions = {}
@@ -471,9 +484,9 @@ module Sequel
         opts = opts ? @opts.merge(opts) : @opts
 
         if opts[:group]
-          raise SequelError, "Can't update a grouped dataset" 
+          raise Error::InvalidOperation, "A grouped dataset cannot be updated"
         elsif (opts[:from].size > 1) or opts[:join]
-          raise SequelError, "Can't update a joined dataset"
+          raise Error::InvalidOperation, "A joined dataset cannot be updated"
         end
         
         sql = "UPDATE #{@opts[:from]} SET "
@@ -507,9 +520,9 @@ module Sequel
         opts = opts ? @opts.merge(opts) : @opts
 
         if opts[:group]
-          raise SequelError, "Can't delete from a grouped dataset"
+          raise Error::InvalidOperation, "Grouped datasets cannot be deleted from"
         elsif opts[:from].is_a?(Array) && opts[:from].size > 1
-          raise SequelError, "Can't delete from a joined dataset"
+          raise Error::InvalidOperation, "Joined datasets cannot be deleted from"
         end
 
         sql = "DELETE FROM #{opts[:from]}"

data/lib/sequel/exceptions.rb

@@ -0,0 +1,45 @@
+module Sequel
+  # Represents an error raised in Sequel code.
+  class Error < StandardError
+
+    # Rollback is a special error used to rollback a transactions.
+    # A transaction block will catch this error and wont pass further up the stack.
+    class Rollback < Error ; end
+
+    class InvalidDatabaseScheme < Error; end
+    
+    # Represents an invalid value stored in the database.
+    class InvalidValue < Error ; end
+                                       
+    # Represents an Invalid transform.
+    class InvalidTransform < Error ; end
+                                       
+    # Represents an Invalid filter.    
+    class InvalidFilter < Error ; end
+    
+    class InvalidExpression < Error; end
+                                       
+    # Represents an attempt to performing filter operations when no filter has been specified yet.
+    class NoExistingFilter < Error ; end
+                                       
+    # Represents an invalid join type.
+    class InvalidJoinType < Error ; end
+                                       
+    class WorkerStop < RuntimeError ; end
+
+  end  
+end
+
+# Object extensions
+class Object
+  # Cancels the current transaction without an error:
+  #
+  #   DB.tranaction do
+  #     ...
+  #     rollback! if failed_to_contact_client
+  #     ...
+  #   end
+  def rollback!
+    raise Sequel::Error::Rollback
+  end
+end