sequel 0.0.20 → 0.1.0

data/CHANGELOG

@@ -1,3 +1,25 @@
+*0.1.0*
+
+* Changed Database#create_table to only accept a block. Nobody's gonna use the other way.
+
+* Removed Dataset#[]= method. Too confusing and not really useful.
+
+* Fixed ConnectionPool#hold to wrap exceptions only once.
+
+* Dataset#where_list Renamed Dataset#expression_list.
+
+* Added support for qualified fields in Proc expressions (e.g. filter {items.id == 1}.)
+
+* Added like? and in? Proc expression operators.
+
+* Added require 'date' in dataset.rb. Is this a 1.8.5 thing?
+
+* Refactored Dataset to use literal strings instead of format strings (slight performance improvement and better readability.)
+
+* Added support for literalizing Date objects.
+
+* Refactored literalization of Time objects.
+
 *0.0.20*
 
 * Refactored Dataset where clause construction to use expressions.

data/Rakefile

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

data/lib/sequel.rb

@@ -11,6 +11,15 @@ require File.join(dir, 'model')
 
 module Sequel #:nodoc:
   class << self
+    # call-seq:
+    #   Sequel::Database.connect(conn_string)
+    #   Sequel.connect(conn_string)
+    #   Sequel.open(conn_string)
+    #
+    # Creates a new database object based on the supplied connection string.
+    # The specified scheme determines the database class used, and the rest
+    # of the string specifies the connection options. For example:
+    #   DB = Sequel.open 'sqlite:///blog.db'
     def connect(url)
       Database.connect(url)
     end

data/lib/sequel/connection_pool.rb

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

data/lib/sequel/core_ext.rb

@@ -1,13 +1,3 @@
-# Time extensions.
-class Time
-  SQL_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S'".freeze
-  
-  # Formats the Time object as an SQL TIMESTAMP.
-  def to_sql_timestamp
-    strftime(SQL_FORMAT)
-  end
-end
-
 # Enumerable extensions.
 module Enumerable
   def send_each(sym, *args)

data/lib/sequel/database.rb

@@ -57,14 +57,10 @@ module Sequel
     #     column :content, :text
     #     index :title
     #   end
-    def create_table(name, columns = nil, indexes = nil, &block)
-      if block
-        schema = Schema.new
-        schema.create_table(name, &block)
-        schema.create(self)
-      else
-        execute Schema.create_table_sql(name, columns, indexes)
-      end
+    def create_table(name, &block)
+      schema = Schema.new
+      schema.create_table(name, &block)
+      schema.create(self)
     end
     
     # Drops a table.
@@ -150,11 +146,11 @@ module Sequel
     # Creates a new database object based on the supplied connection string.
     # The specified scheme determines the database class used, and the rest
     # of the string specifies the connection options. For example:
-    #   DB = Sequel.connect('sqlite:///blog.db')
+    #   DB = Sequel.open 'sqlite:///blog.db'
     def self.connect(conn_string)
       uri = URI.parse(conn_string)
       c = @@adapters[uri.scheme.to_sym]
-      raise "Invalid database scheme" unless c
+      raise SequelError, "Invalid database scheme" unless c
       c.new(c.uri_to_options(uri))
     end
   end

data/lib/sequel/dataset.rb

@@ -1,4 +1,5 @@
 require 'time'
+require 'date'
 
 module Sequel
   # A Dataset represents a view of a the data in a database, constrained by
@@ -67,13 +68,12 @@ module Sequel
     end
     
     QUALIFIED_REGEXP = /(.*)\.(.*)/.freeze
-    QUALIFIED_FORMAT = "%s.%s".freeze
 
     # Returns a qualified field name (including a table name) if the field
     # name isn't already qualified.
     def qualified_field_name(field, table)
       fn = field_name(field)
-      fn =~ QUALIFIED_REGEXP ? fn : QUALIFIED_FORMAT % [table, fn]
+      fn =~ QUALIFIED_REGEXP ? fn : "#{table}.#{fn}"
     end
     
     WILDCARD = '*'.freeze
@@ -96,7 +96,8 @@ module Sequel
     end
     
     NULL = "NULL".freeze
-    SUBQUERY = "(%s)".freeze
+    TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S'".freeze
+    DATE_FORMAT = "DATE '%Y-%m-%d'".freeze
     
     # Returns a literal representation of a value to be used as part
     # of an SQL expression. This method is overriden in descendants.
@@ -107,32 +108,30 @@ 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 Dataset: SUBQUERY % v.sql
+      when Time: v.strftime(TIMESTAMP_FORMAT)
+      when Date: v.strftime(DATE_FORMAT)
+      when Dataset: "(#{v.sql})"
       else
         raise SequelError, "can't express #{v.inspect}:#{v.class} as a SQL literal"
       end
     end
 
     AND_SEPARATOR = " AND ".freeze
-    EQUAL_EXPR = "(%s = %s)".freeze
-    IN_EXPR = "(%s IN (%s))".freeze
-    INCLUSIVE_RANGE_EXPR = "(%s >= %s AND %s <= %s)".freeze
-    EXCLUSIVE_RANGE_EXPR = "(%s >= %s AND %s < %s)".freeze
-    NULL_EXPR = "(%s IS NULL)".freeze
     
     def format_eq_expression(left, right)
       case right
       when Range:
-        (right.exclude_end? ? EXCLUSIVE_RANGE_EXPR : INCLUSIVE_RANGE_EXPR) %
-          [left, literal(right.begin), left, literal(right.end)]
+        right.exclude_end? ? \
+          "(#{left} >= #{right.begin} AND #{left} < #{right.end})" : \
+          "(#{left} >= #{right.begin} AND #{left} <= #{right.end})"
       when Array:
-        IN_EXPR % [left, literal(right)]
-      when NilClass:
-        NULL_EXPR % left
+        "(#{left} IN (#{literal(right)}))"
       when Dataset:
-        IN_EXPR % [left, right.sql]
+        "(#{left} IN #{literal(right)})"
+      when NilClass:
+        "(#{left} IS NULL)"
       else
-        EQUAL_EXPR % [left, literal(right)]
+        "(#{left} = #{literal(right)})"
       end
     end
     
@@ -151,12 +150,16 @@ module Sequel
         "(#{left} > #{literal(right)})"
       when :gte:
         "(#{left} >= #{literal(right)})"
+      when :like:
+        "(#{left} LIKE #{literal(right)})"
+      else
+        raise SequelError, "Invalid operator specified: #{op}"
       end
     end
     
     # 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)
+    def expression_list(where, parenthesize = false)
       case where
       when Hash:
         parenthesize = false if where.size == 1
@@ -177,9 +180,9 @@ module Sequel
     # Formats a join condition.
     def join_cond_list(cond, join_table)
       cond.map do |kv|
-        EQUAL_EXPR % [
-          qualified_field_name(kv[0], join_table), 
-          qualified_field_name(kv[1], @opts[:from])]
+        l = qualified_field_name(kv[0], join_table)
+        r = qualified_field_name(kv[1], @opts[:from])
+        "(#{l} = #{r})"
       end.join(AND_SEPARATOR)
     end
     
@@ -229,8 +232,6 @@ module Sequel
       dup_merge(:group => fields)
     end
 
-    AND_WHERE = "%s AND %s".freeze
-    
     # Returns a copy of the dataset with the given conditions imposed upon it.  
     # If the query has been grouped, then the conditions are imposed in the 
     # HAVING clause. If not, then they are imposed in the WHERE clause.
@@ -239,24 +240,24 @@ module Sequel
       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(block || cond, parenthesize)]
-        dup_merge(clause => cond)
+        l = expression_list(@opts[clause])
+        r = expression_list(block || cond, parenthesize)
+        dup_merge(clause => "#{l} AND #{r}")
       else
-        dup_merge(clause => where_list(block || cond))
+        dup_merge(clause => expression_list(block || cond))
       end
     end
 
-    NOT_WHERE = "NOT %s".freeze
-    AND_NOT_WHERE = "%s AND NOT %s".freeze
-    
     def exclude(*cond, &block)
       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(block || cond, parenthesize)]
+        l = expression_list(@opts[clause])
+        r = expression_list(block || cond, parenthesize)
+        cond = "#{l} AND NOT #{r}"
       else
-        cond = NOT_WHERE % where_list(block || cond, true)
+        cond = "NOT #{expression_list(block || cond, true)}"
       end
       dup_merge(clause => cond)
     end
@@ -286,9 +287,10 @@ module Sequel
     RIGHT_OUTER_JOIN = 'RIGHT OUTER JOIN'.freeze
     FULL_OUTER_JOIN = 'FULL OUTER JOIN'.freeze
         
-    def join(table, cond)
+    def join(table, expr)
+      expr = {expr => :id} unless expr.is_a?(Hash)
       dup_merge(:join_type => LEFT_OUTER_JOIN, :join_table => table,
-        :join_cond => cond)
+        :join_cond => expr)
     end
 
     alias_method :all, :to_a
@@ -323,16 +325,6 @@ module Sequel
       end
     end
 
-    SELECT = "SELECT %s FROM %s".freeze
-    SELECT_DISTINCT = "SELECT DISTINCT %s FROM %s".freeze
-    LIMIT = " LIMIT %s".freeze
-    OFFSET = " OFFSET %s".freeze
-    ORDER = " ORDER BY %s".freeze
-    WHERE = " WHERE %s".freeze
-    GROUP = " GROUP BY %s".freeze
-    HAVING = " HAVING %s".freeze
-    JOIN_CLAUSE = " %s %s ON %s".freeze
-    
     EMPTY = ''.freeze
     
     SPACE = ' '.freeze
@@ -343,34 +335,36 @@ module Sequel
       fields = opts[:select]
       select_fields = fields ? field_list(fields) : WILDCARD
       select_source = source_list(opts[:from])
-      sql = (opts[:distinct] ? SELECT_DISTINCT : SELECT) % [select_fields, select_source]
+      sql = opts[:distinct] ? \
+        "SELECT DISTINCT #{select_fields} FROM #{select_source}" : \
+        "SELECT #{select_fields} FROM #{select_source}"
       
       if join_type = opts[:join_type]
         join_table = opts[:join_table]
         join_cond = join_cond_list(opts[:join_cond], join_table)
-        sql << (JOIN_CLAUSE % [join_type, join_table, join_cond])
+        sql << " #{join_type} #{join_table} ON #{join_cond}"
       end
       
       if where = opts[:where]
-        sql << (WHERE % where)
+        sql << " WHERE #{where}"
       end
       
       if group = opts[:group]
-        sql << (GROUP % field_list(group))
+        sql << " GROUP BY #{field_list(group)}"
       end
 
       if order = opts[:order]
-        sql << (ORDER % field_list(order))
+        sql << " ORDER BY #{field_list(order)}"
       end
       
       if having = opts[:having]
-        sql << (HAVING % having)
+        sql << " HAVING #{having}"
       end
 
       if limit = opts[:limit]
-        sql << (LIMIT % limit)
+        sql << " LIMIT #{limit}"
         if offset = opts[:offset]
-          sql << (OFFSET % offset)
+          sql << " OFFSET #{offset}"
         end
       end
             
@@ -379,13 +373,9 @@ module Sequel
     
     alias_method :sql, :select_sql
     
-    INSERT = "INSERT INTO %s (%s) VALUES (%s)".freeze
-    INSERT_VALUES = "INSERT INTO %s VALUES (%s)".freeze
-    INSERT_EMPTY = "INSERT INTO %s DEFAULT VALUES".freeze
-    
     def insert_sql(*values)
       if values.empty?
-        INSERT_EMPTY % @opts[:from]
+        "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
       elsif (values.size == 1) && values[0].is_a?(Hash)
         field_list = []
         value_list = []
@@ -393,18 +383,14 @@ module Sequel
           field_list << k
           value_list << literal(v)
         end
-        INSERT % [
-          @opts[:from], 
-          field_list.join(COMMA_SEPARATOR), 
-          value_list.join(COMMA_SEPARATOR)]
+        fl = field_list.join(COMMA_SEPARATOR)
+        vl = value_list.join(COMMA_SEPARATOR)
+        "INSERT INTO #{@opts[:from]} (#{fl}) VALUES (#{vl})"
       else
-        INSERT_VALUES % [@opts[:from], literal(values)]
+        "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)})"
       end
     end
     
-    UPDATE = "UPDATE %s SET %s".freeze
-    SET_FORMAT = "%s = %s".freeze
-    
     def update_sql(values, opts = nil)
       opts = opts ? @opts.merge(opts) : @opts
       
@@ -414,19 +400,17 @@ module Sequel
         raise SequelError, "Can't update a joined dataset"
       end
 
-      set_list = values.map {|kv| SET_FORMAT % [kv[0], literal(kv[1])]}.
+      set_list = values.map {|kv| "#{kv[0]} = #{literal(kv[1])}"}.
         join(COMMA_SEPARATOR)
-      sql = UPDATE % [opts[:from], set_list]
+      sql = "UPDATE #{@opts[:from]} SET #{set_list}"
       
       if where = opts[:where]
-        sql << WHERE % where_list(where)
+        sql << " WHERE #{where}"
       end
 
       sql
     end
     
-    DELETE = "DELETE FROM %s".freeze
-    
     def delete_sql(opts = nil)
       opts = opts ? @opts.merge(opts) : @opts
 
@@ -436,10 +420,10 @@ module Sequel
         raise SequelError, "Can't delete from a joined dataset"
       end
 
-      sql = DELETE % opts[:from]
+      sql = "DELETE FROM #{opts[:from]}"
 
       if where = opts[:where]
-        sql << WHERE % where_list(where)
+        sql << " WHERE #{where}"
       end
 
       sql
@@ -456,7 +440,7 @@ module Sequel
       if opts.keys == [:from] && opts[:from].size == 1
         opts[:from].first.to_s
       else
-        SUBQUERY % sql
+        "(#{sql})"
       end
     end
     
@@ -477,10 +461,8 @@ module Sequel
       select(field.AVG).naked.first.values.first
     end
     
-    EXISTS_EXPR = "EXISTS (%s)".freeze
-    
     def exists(opts = nil)
-      EXISTS_EXPR % sql({:select => 1}.merge(opts || {}))
+      "EXISTS (#{sql({:select => [1]}.merge(opts || {}))})"
     end
     
     LIMIT_1 = {:limit => 1}.freeze
@@ -514,11 +496,6 @@ module Sequel
       where(*conditions).first
     end
     
-    # Updates all records matching the condition with the values specified.
-    def []=(condition, values)
-      where(condition).update(values)
-    end
-  
     def last(num = 1)
       raise SequelError, 'No order specified' unless 
         @opts[:order] || (opts && opts[:order])

data/lib/sequel/expressions.rb

@@ -7,6 +7,7 @@ module Sequel
       instance_methods.each { |m| undef_method m unless m =~ /^(__|instance_eval)/ }
     end
 
+    # An Expression is made of a left side, an operator, and a right side.
     class Expression < BlankSlate
       attr_reader :left, :right
       attr_accessor :op
@@ -17,14 +18,15 @@ module Sequel
 
       def method_missing(sym, *right)
         @op = case sym
-          when :==, :===, :in: :eql
-          when :=~: :like
-          when :"<=>": :not
-          when :<: :lt
-          when :<=: :lte
-          when :>: :gt
-          when :>=: :gte
-          else sym
+        when :==, :===, :in, :in?: :eql
+        when :=~, :like, :like?: :like
+        when :"<=>", :is_not: :not
+        when :<: :lt
+        when :<=: :lte
+        when :>: :gt
+        when :>=: :gte
+        else
+          @left = "#{left}.#{sym}"
         end
         @right = right.first
         self
@@ -37,28 +39,32 @@ module Sequel
       end
     end
 
+    # An ExpressionCompiler takes a Proc object and compiles it
+    # into an array of expressions using instance_eval magic.
     class ExpressionCompiler < BlankSlate
-      def initialize(&block)
+      def initialize(&block) #:nodoc:
         @block = block
         @expressions = []
       end
-
-      def method_missing(sym, *args)
-        expr = Expression.new(sym)
-        @expressions << expr
-        expr
-      end
-      
-      def SUM(sym)
-        expr = Expression.new(sym.SUM)
-        @expressions << expr
-        expr
-      end
       
+      # Converts the block into an array of expressions.
       def __to_a__
         instance_eval(&@block)
         @expressions
+      rescue => e
+        raise SequelError, e.message
       end
+
+      private
+        def __expr(sym) #:nodoc:
+          expr = Expression.new(sym)
+          @expressions << expr
+          expr
+        end
+
+        def method_missing(sym, *args); __expr(sym); end #:nodoc:
+        def test; __expr(:test); end #:nodoc:
+        def SUM(sym); __expr(sym.SUM); end #:nodoc:
     end
   end
 end

data/lib/sequel/postgres.rb

@@ -218,7 +218,6 @@ module Sequel
       def literal(v)
         case v
         when String, Fixnum, Float, TrueClass, FalseClass: PGconn.quote(v)
-        when Time: v.to_sql_timestamp
         else
           super
         end
@@ -237,11 +236,6 @@ module Sequel
         end
       end
       
-      def format_expression(left, op, right)
-        op = :eql if op == :like
-        super
-      end
-    
       def each(opts = nil, &block)
         query_each(select_sql(opts), true, &block)
         self

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.0.20
-date: 2007-04-18 00:00:00 +03:00
+  version: 0.1.0
+date: 2007-04-22 00:00:00 +03:00
 summary: Concise ORM for Ruby.
 require_paths: 
 - lib