sequel 0.0.17 → 0.0.18

data/CHANGELOG

@@ -1,5 +1,17 @@
+*0.0.18*
+
+* Implemented SequelError and SequelConnectionError classes. ConnectionPool#hold now catches any connection errors and reraises them SequelConnectionError.
+
+* Removed duplication in Database#[].
+
+* :from and :select options are now always arrays (patch by Alex Bradbury.)
+
+* Fixed Dataset#exclude to work correctly (patch and specs by Alex Bradbury.)
+
 *0.0.17*
 
+* Fixed Postgres::Database#tables to return table names as symbols (caused problem when using Database#table_exists?).
+
 * Fixed Dataset#from to have variable arity, like Dataset#select and Dataset#where (patch by Alex Bradbury.)
 
 * Added support for GROUP BY and HAVING clauses (patches by Alex Bradbury.) Refactored Dataset#filter.

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.0.17"
+VERS = "0.0.18"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",

data/lib/sequel.rb

@@ -1,5 +1,6 @@
 dir = File.join(File.dirname(__FILE__), 'sequel')
 require File.join(dir, 'core_ext')
+require File.join(dir, 'error')
 require File.join(dir, 'database')
 require File.join(dir, 'connection_pool')
 require File.join(dir, 'schema')

data/lib/sequel/connection_pool.rb

@@ -33,6 +33,8 @@ module Sequel
       ensure
         release(t)
       end
+    rescue Exception => e
+      raise SequelConnectionError.new(e)
     end
     
     def owned_connection(thread)

data/lib/sequel/database.rb

@@ -30,13 +30,9 @@ module Sequel
     
     # Returns a new dataset with the select method invoked.
     def select(*args); dataset.select(*args); end
-
-    # Returns a new dataset with the from parameter set. For example,
-    #   db[:posts].each {|p| puts p[:title]}
-    def [](table)
-      dataset.from(table)
-    end
     
+    alias_method :[], :from
+
     def execute(sql)
       raise RuntimeError
     end

data/lib/sequel/dataset.rb

@@ -81,26 +81,18 @@ module Sequel
     
     # Converts a field list into a comma seperated string of field names.
     def field_list(fields)
-      case fields
-      when Array:
-        if fields.empty?
-          WILDCARD
-        else
-          fields.map {|i| field_name(i)}.join(COMMA_SEPARATOR)
-        end
-      when Symbol:
-        fields.to_field_name
+      if fields.empty?
+        WILDCARD
       else
-        fields
+        fields.map {|i| field_name(i)}.join(COMMA_SEPARATOR)
       end
     end
     
     # Converts an array of sources into a comma separated list.
     def source_list(source)
-      case source
-      when Array: source.join(COMMA_SEPARATOR)
-      else source
-      end
+      raise 'No source specified for query' unless source
+      source.map {|i| i.is_a?(Dataset) ? i.to_table_reference : i}.
+        join(COMMA_SEPARATOR)
     end
     
     NULL = "NULL".freeze
@@ -115,7 +107,7 @@ module Sequel
       when NilClass: NULL
       when Symbol: v.to_field_name
       when Array: v.empty? ? NULL : v.map {|i| literal(i)}.join(COMMA_SEPARATOR)
-      when self.class: SUBQUERY % v.sql
+      when Dataset: SUBQUERY % v.sql
       else
         raise "can't express #{v.inspect}:#{v.class} as a SQL literal"
       end
@@ -141,24 +133,27 @@ module Sequel
         IN_EXPR % [left, literal(right)]
       when NilClass:
         NULL_EXPR % left
-      when self.class:
+      when Dataset:
         IN_EXPR % [left, right.sql]
       else
         EQUAL_COND % [left, literal(right)]
       end
     end
     
-    # Formats a where clause.
+    # Formats a where clause. If parenthesize is true, then the whole 
+    # generated clause will be enclosed in a set of parentheses.
     def where_list(where, parenthesize = false)
       case where
       when Hash:
-        where.map {|kv| where_condition(*kv)}.join(AND_SEPARATOR)
+        parenthesize = false if where.size == 1
+        fmt = where.map {|kv| where_condition(*kv)}.join(AND_SEPARATOR)
       when Array:
         fmt = where.shift
-        fmt.gsub('?') {|i| literal(where.shift)}
+        fmt.gsub!('?') {|i| literal(where.shift)}
       else
-        parenthesize ? "(#{where})" : where
+        fmt = where
       end
+      parenthesize ? "(#{fmt})" : fmt
     end
     
     # Formats a join condition.
@@ -172,13 +167,11 @@ module Sequel
     
     # Returns a copy of the dataset with the source changed.
     def from(*source)
-      source = source.first if source.size == 1
       dup_merge(:from => source)
     end
     
     # Returns a copy of the dataset with the selected fields changed.
     def select(*fields)
-      fields = fields.first if fields.size == 1
       dup_merge(:select => fields)
     end
 
@@ -221,12 +214,28 @@ module Sequel
     def filter(*cond)
       clause = (@opts[:group] ? :having : :where)
       cond = cond.first if cond.size == 1
+      parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
       if @opts[clause]
-        cond = AND_WHERE % [where_list(@opts[clause]), where_list(cond, true)]
+        cond = AND_WHERE % [where_list(@opts[clause]), where_list(cond, parenthesize)]
       end
       dup_merge(clause => where_list(cond))
     end
 
+    NOT_WHERE = "NOT %s".freeze
+    AND_NOT_WHERE = "%s AND NOT %s".freeze
+    
+    def exclude(*cond)
+      clause = (@opts[:group] ? :having : :where)
+      cond = cond.first if cond.size == 1
+      parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
+      if @opts[clause]
+        cond = AND_NOT_WHERE % [where_list(@opts[clause]), where_list(cond, parenthesize)]
+      else
+        cond = NOT_WHERE % where_list(cond, true)
+      end
+      dup_merge(clause => cond)
+    end
+    
     # Returns a copy of the dataset with the where conditions changed. Raises 
     # if the dataset has been grouped. See also #filter
     def where(*cond)
@@ -247,13 +256,6 @@ module Sequel
        end
      end
     
-    NOT_WHERE = "NOT %s".freeze
-    
-    def exclude(*cond)
-      cond = cond.first if cond.size == 1
-      filter(NOT_WHERE % where_list(cond))
-    end
-    
     LEFT_OUTER_JOIN = 'LEFT OUTER JOIN'.freeze
     INNER_JOIN = 'INNER JOIN'.freeze
     RIGHT_OUTER_JOIN = 'RIGHT OUTER JOIN'.freeze
@@ -383,8 +385,8 @@ module Sequel
       
       if opts[:group]
         raise "Can't update a grouped dataset" 
-      elsif opts[:from].is_a?(Array) && opts[:from].size > 1
-        raise "Can't update in a joined dataset"
+      elsif (opts[:from].size > 1) or opts[:join_type]
+        raise "Can't update a joined dataset"
       end
 
       set_list = values.map {|kv| SET_FORMAT % [kv[0], literal(kv[1])]}.
@@ -424,6 +426,14 @@ module Sequel
     def count_sql(opts = nil)
       select_sql(opts ? opts.merge(SELECT_COUNT) : SELECT_COUNT)
     end
+
+    def to_table_reference
+      if opts.keys == [:from] && opts[:from].size == 1
+        opts[:from].first.to_s
+      else
+        SUBQUERY % sql
+      end
+    end
     
     # aggregates
     def min(field)
@@ -475,8 +485,8 @@ module Sequel
     end
     
     # Returns the first record matching the condition.
-    def [](condition)
-      where(condition).first
+    def [](*conditions)
+      where(*conditions).first
     end
     
     # Updates all records matching the condition with the values specified.

data/lib/sequel/error.rb

@@ -0,0 +1,20 @@
+class SequelError < StandardError
+end
+
+# This error class is used to wrap exceptions occuring inside calls to
+# ConnectionPool#hold. Sequel wraps any exception raised by the database
+# connection and provides it as a SequelConnectionError. The original
+# exception is provided through SequelConnectionError#original_exception.
+class SequelConnectionError < SequelError
+  attr_reader :original_error
+
+  def initialize(original_error)
+    @original_error = original_error
+  end
+  
+  def message
+    "#{@original_error.class}: #{@original_error.message}"
+  end
+  
+  alias_method :to_s, :message
+end

data/lib/sequel/postgres.rb

@@ -178,7 +178,7 @@ module Sequel
     
     
       def tables
-        dataset(RELATION_QUERY).filter(RELATION_FILTER).map(:relname)
+        dataset(RELATION_QUERY).filter(RELATION_FILTER).map {|r| r[:relname].to_sym}
       end
       
       def locks

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.0.17
-date: 2007-04-10 00:00:00 +03:00
+  version: 0.0.18
+date: 2007-04-13 00:00:00 +03:00
 summary: Concise ORM for Ruby.
 require_paths: 
 - lib
@@ -40,6 +40,7 @@ files:
 - lib/sequel/core_ext.rb
 - lib/sequel/database.rb
 - lib/sequel/dataset.rb
+- lib/sequel/error.rb
 - lib/sequel/model.rb
 - lib/sequel/mysql.rb
 - lib/sequel/postgres.rb