sequel 0.1.0 → 0.1.1

data/CHANGELOG

@@ -1,3 +1,19 @@
+*0.1.1*
+
+* More documentation for Dataset.
+
+* Added Dataset#size as alias to Dataset#count.
+
+* Changed Database#<< to call execute (instead of being an alias). Thus it will work for descendants as well.
+
+* Fixed Sequel.open to accept variable arity.
+
+* Refactored Model#refresh, Model.create. Removed Model#reload.
+
+* Refactored Model hooks.
+
+* Cleaned up Dataset API.
+
 *0.1.0*
 
 * Changed Database#create_table to only accept a block. Nobody's gonna use the other way.

data/Rakefile

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

data/lib/sequel.rb

@@ -20,8 +20,8 @@ module Sequel #:nodoc:
     # 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)
+    def connect(*args)
+      Database.connect(*args)
     end
     
     alias_method :open, :connect

data/lib/sequel/database.rb

@@ -36,7 +36,8 @@ module Sequel
     def execute(sql)
       raise NotImplementedError
     end
-    alias_method :<<, :execute
+    
+    def <<(sql); execute(sql); end
     
     # Acquires a database connection, yielding it to the passed block.
     def synchronize(&block)
@@ -147,11 +148,11 @@ module Sequel
     # 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 self.connect(conn_string)
+    def self.connect(conn_string, more_opts = nil)
       uri = URI.parse(conn_string)
       c = @@adapters[uri.scheme.to_sym]
       raise SequelError, "Invalid database scheme" unless c
-      c.new(c.uri_to_options(uri))
+      c.new(c.uri_to_options(uri).merge(more_opts || {}))
     end
   end
 end

data/lib/sequel/dataset.rb

@@ -26,7 +26,7 @@ module Sequel
     include Enumerable
     
     attr_reader :db, :opts
-    attr_accessor :record_class
+    attr_accessor :model_class
   
     # Constructs a new instance of a dataset with a database instance, initial
     # options and an optional record class. Datasets are usually constructed by
@@ -37,29 +37,24 @@ module Sequel
     #
     # Sequel::Dataset is an abstract class that is not useful by itself. Each
     # database adaptor should provide a descendant class of Sequel::Dataset.
-    def initialize(db, opts = nil, record_class = nil)
+    def initialize(db, opts = nil, model_class = nil)
       @db = db
       @opts = opts || {}
-      @record_class = record_class
+      @model_class = model_class
     end
     
-    # Returns a new instance of the dataset with its options
+    # Returns a new instance of the dataset with with the give options merged.
     def dup_merge(opts)
-      self.class.new(@db, @opts.merge(opts), @record_class)
+      self.class.new(@db, @opts.merge(opts), @model_class)
     end
     
     # Returns a dataset that fetches records as hashes (instead of model 
     # objects). If no record class is defined for the dataset, self is
     # returned.
     def naked
-      @record_class ? self.class.new(@db, @opts.dup) : self
+      @model_class ? self.class.new(@db, opts || @opts.dup) : self
     end
     
-    AS_REGEXP = /(.*)___(.*)/.freeze
-    AS_FORMAT = "%s AS %s".freeze
-    DOUBLE_UNDERSCORE = '__'.freeze
-    PERIOD = '.'.freeze
-    
     # Returns a valid SQL fieldname as a string. Field names specified as 
     # symbols can include double underscores to denote a dot separator, e.g.
     # :posts__id will be converted into posts.id.
@@ -79,7 +74,8 @@ module Sequel
     WILDCARD = '*'.freeze
     COMMA_SEPARATOR = ", ".freeze
     
-    # Converts a field list into a comma seperated string of field names.
+    # Converts an array of field names into a comma seperated string of 
+    # field names. If the array is empty, a wildcard (*) is returned.
     def field_list(fields)
       if fields.empty?
         WILDCARD
@@ -88,9 +84,11 @@ module Sequel
       end
     end
     
-    # Converts an array of sources into a comma separated list.
+    # Converts an array of sources names into into a comma separated list.
     def source_list(source)
-      raise SequelError, 'No source specified for query' unless source
+      if source.nil? || source.empty?
+        raise SequelError, 'No source specified for query'
+      end
       source.map {|i| i.is_a?(Dataset) ? i.to_table_reference : i}.
         join(COMMA_SEPARATOR)
     end
@@ -100,10 +98,21 @@ module Sequel
     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.
+    # of an SQL expression. The stock implementation supports literalization 
+    # of String (with proper escaping to prevent SQL injections), numbers,
+    # Symbol (as field references), Array (as a list of literalized values),
+    # Time (as an SQL TIMESTAMP), Date (as an SQL DATE), Dataset (as a 
+    # subquery) and nil (AS NULL).
+    # 
+    #   dataset.literal("abc'def") #=> "'abc''def'"
+    #   dataset.literal(:items__id) #=> "items.id"
+    #   dataset.literal([1, 2, 3]) => "(1, 2, 3)"
+    #   dataset.literal(DB[:items]) => "(SELECT * FROM items)"
+    #
+    # If an unsupported object is given, an exception is raised.
     def literal(v)
       case v
-      when String: "'%s'" % v.gsub(/'/, "''")
+      when String: "'#{v.gsub(/'/, "''")}'"
       when Integer, Float: v.to_s
       when NilClass: NULL
       when Symbol: v.to_field_name
@@ -112,12 +121,28 @@ module Sequel
       when Date: v.strftime(DATE_FORMAT)
       when Dataset: "(#{v.sql})"
       else
-        raise SequelError, "can't express #{v.inspect}:#{v.class} as a SQL literal"
+        raise SequelError, "can't express #{v.inspect} as a SQL literal"
       end
     end
 
     AND_SEPARATOR = " AND ".freeze
     
+    # Formats an equality expression involving a left value and a right value.
+    # Equality expressions differ according to the class of the right value.
+    # The stock implementation supports Range (inclusive and exclusive), Array
+    # (as a list of values to compare against), Dataset (as a subquery to
+    # compare against), or a regular value.
+    #
+    #   dataset.format_eq_expression('id', 1..20) #=>
+    #     "(id >= 1 AND id <= 20)"
+    #   dataset.format_eq_expression('id', [3,6,10]) #=>
+    #     "(id IN (3, 6, 10))"
+    #   dataset.format_eq_expression('id', DB[:items].select(:id)) #=>
+    #     "(id IN (SELECT id FROM items))"
+    #   dataset.format_eq_expression('id', nil) #=>
+    #     "(id IS NULL)"
+    #   dataset.format_eq_expression('id', 3) #=>
+    #     "(id = 3)"
     def format_eq_expression(left, right)
       case right
       when Range:
@@ -127,7 +152,7 @@ module Sequel
       when Array:
         "(#{left} IN (#{literal(right)}))"
       when Dataset:
-        "(#{left} IN #{literal(right)})"
+        "(#{left} IN (#{right.sql}))"
       when NilClass:
         "(#{left} IS NULL)"
       else
@@ -135,6 +160,16 @@ module Sequel
       end
     end
     
+    # Formats an expression comprising a left value, a binary operator and a
+    # right value. The supported operators are :eql (=), :not (!=), :lt (<),
+    # :lte (<=), :gt (>), :gte (>=) and :like (LIKE operator). Examples:
+    #
+    #   dataset.format_expression('price', :gte, 100) #=> "(price >= 100)"
+    #   dataset.format_expression('id', :not, 30) #=> "NOT (id = 30)"
+    #   dataset.format_expression('name', :like, 'abc%') #=>
+    #     "(name LIKE 'abc%')"
+    #
+    # If an unsupported operator is given, an exception is raised.
     def format_expression(left, op, right)
       left = field_name(left)
       case op
@@ -157,6 +192,8 @@ module Sequel
       end
     end
     
+    QUESTION_MARK = '?'.freeze
+    
     # Formats a where clause. If parenthesize is true, then the whole 
     # generated clause will be enclosed in a set of parentheses.
     def expression_list(where, parenthesize = false)
@@ -166,8 +203,7 @@ module Sequel
         fmt = where.map {|i| format_expression(i[0], :eql, i[1])}.
           join(AND_SEPARATOR)
       when Array:
-        fmt = where.shift
-        fmt.gsub!('?') {|i| literal(where.shift)}
+        fmt = where.shift.gsub(QUESTION_MARK) {literal(where.shift)}
       when Proc:
         fmt = where.to_expressions.map {|e| format_expression(e.left, e.op, e.right)}.
           join(AND_SEPARATOR)
@@ -215,6 +251,12 @@ module Sequel
     
     DESC_ORDER_REGEXP = /(.*)\sDESC/.freeze
     
+    # Inverts the given order by breaking it into a list of field references
+    # and inverting them.
+    #
+    #   dataset.invert_order('id DESC') #=> "id"
+    #   dataset.invert_order('category, price DESC') #=>
+    #     "category DESC, price"
     def invert_order(order)
       new_order = []
       order.each do |f|
@@ -234,7 +276,25 @@ module Sequel
 
     # 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.
+    # HAVING clause. If not, then they are imposed in the WHERE clause. Filter
+    # accepts a Hash (formated into a list of equality expressions), an Array
+    # (formatted ala ActiveRecord conditions), a String (taken literally), or
+    # a block that is converted into expressions.
+    #
+    #   dataset.filter(:id => 3).sql #=>
+    #     "SELECT * FROM items WHERE (id = 3)"
+    #   dataset.filter('price < ?', 100).sql #=>
+    #     "SELECT * FROM items WHERE price < 100"
+    #   dataset.filter('price < 100').sql #=>
+    #     "SELECT * FROM items WHERE price < 100"
+    #   dataset.filter {price < 100}.sql #=>
+    #     "SELECT * FROM items WHERE (price < 100)"
+    # 
+    # Multiple filter calls can be chained for scoping:
+    #
+    #   software = dataset.filter(:category => 'software')
+    #   software.filter {price < 100}.sql #=>
+    #     "SELECT * FROM items WHERE (category = 'software') AND (price < 100)"
     def filter(*cond, &block)
       clause = (@opts[:group] ? :having : :where)
       cond = cond.first if cond.size == 1
@@ -248,6 +308,10 @@ module Sequel
       end
     end
 
+    # Performs the inverse of Dataset#filter.
+    #
+    #   dataset.exclude(:category => 'software').sql #=>
+    #     "SELECT * FROM items WHERE NOT (category = 'software')"
     def exclude(*cond, &block)
       clause = (@opts[:group] ? :having : :where)
       cond = cond.first if cond.size == 1
@@ -263,7 +327,7 @@ module Sequel
     end
     
     # Returns a copy of the dataset with the where conditions changed. Raises 
-    # if the dataset has been grouped. See also #filter
+    # 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"
@@ -286,26 +350,27 @@ module Sequel
     INNER_JOIN = 'INNER JOIN'.freeze
     RIGHT_OUTER_JOIN = 'RIGHT OUTER JOIN'.freeze
     FULL_OUTER_JOIN = 'FULL OUTER JOIN'.freeze
-        
+    
+    # Returns a joined dataset.
     def join(table, expr)
       expr = {expr => :id} unless expr.is_a?(Hash)
       dup_merge(:join_type => LEFT_OUTER_JOIN, :join_table => table,
         :join_cond => expr)
     end
 
-    alias_method :all, :to_a
+    alias all to_a
     
-    alias_method :enum_map, :map
+    # Maps field values for each record in the dataset (if a field name is
+    # given), or performs the stock mapping functionality of Enumerable.
     def map(field_name = nil, &block)
-      if block
-        enum_map(&block)
-      elsif field_name
-        enum_map {|r| r[field_name]}
+      if field_name
+        super() {|r| r[field_name]}
       else
-        []
+        super(&block)
       end
     end
     
+    # Returns a hash with one column used as key and another used as value.
     def hash_column(key_column, value_column)
       inject({}) do |m, r|
         m[r[key_column]] = r[value_column]
@@ -313,10 +378,13 @@ module Sequel
       end
     end
     
+    # Inserts the given values into the table.
     def <<(values)
       insert(values)
     end
     
+    # Inserts multiple values. If a block is given it is invoked for each
+    # item in the given array before inserting it.
     def insert_multiple(array, &block)
       if block
         array.each {|i| insert(block[i])}
@@ -326,9 +394,10 @@ module Sequel
     end
 
     EMPTY = ''.freeze
-    
     SPACE = ' '.freeze
     
+    # Formats a SELECT statement using the given options and the dataset
+    # options.
     def select_sql(opts = nil)
       opts = opts ? @opts.merge(opts) : @opts
 
@@ -367,12 +436,19 @@ module Sequel
           sql << " OFFSET #{offset}"
         end
       end
-            
+      
       sql
     end
-    
-    alias_method :sql, :select_sql
-    
+    alias sql select_sql
+
+    # Formats an INSERT statement using the given values. If a hash is given,
+    # the resulting statement includes field names. If no values are given, 
+    # the resulting statement includes a DEFAULT VALUES clause.
+    #
+    #   dataset.insert_sql() #=> 'INSERT INTO items DEFAULT VALUES'
+    #   dataset.insert_sql(1,2,3) #=> 'INSERT INTO items VALUES (1, 2, 3)'
+    #   dataset.insert_sql(:a => 1, :b => 2) #=>
+    #     'INSERT INTO items (a, b) VALUES (1, 2)'
     def insert_sql(*values)
       if values.empty?
         "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
@@ -391,6 +467,10 @@ module Sequel
       end
     end
     
+    # Formats an UPDATE statement using the given values.
+    #
+    #   dataset.update_sql(:price => 100, :category => 'software') #=>
+    #     "UPDATE items SET price = 100, category = 'software'"
     def update_sql(values, opts = nil)
       opts = opts ? @opts.merge(opts) : @opts
       
@@ -400,7 +480,7 @@ module Sequel
         raise SequelError, "Can't update a joined dataset"
       end
 
-      set_list = values.map {|kv| "#{kv[0]} = #{literal(kv[1])}"}.
+      set_list = values.map {|k, v| "#{k} = #{literal(v)}"}.
         join(COMMA_SEPARATOR)
       sql = "UPDATE #{@opts[:from]} SET #{set_list}"
       
@@ -411,11 +491,15 @@ module Sequel
       sql
     end
     
+    # Formats a DELETE statement using the given options and dataset options.
+    # 
+    #   dataset.filter {price >= 100}.delete_sql #=>
+    #     "DELETE FROM items WHERE (price >= 100)"
     def delete_sql(opts = nil)
       opts = opts ? @opts.merge(opts) : @opts
 
       if opts[:group]
-        raise SequelError, "Can't delete from a grouped dataset" 
+        raise SequelError, "Can't delete from a grouped dataset"
       elsif opts[:from].is_a?(Array) && opts[:from].size > 1
         raise SequelError, "Can't delete from a joined dataset"
       end
@@ -429,13 +513,27 @@ module Sequel
       sql
     end
     
-    COUNT = "COUNT(*)".freeze
-    SELECT_COUNT = {:select => COUNT, :order => nil}.freeze
+    # Returns the first record in the dataset.
+    def single_record(opts = nil)
+      each(opts) {|r| return r}
+    end
+    
+    # Returns the first value of the first reecord in the dataset.
+    def single_value(opts = nil)
+      naked.each(opts) {|r| return r.values.first}
+    end
+    
+    SELECT_COUNT = {:select => ["COUNT(*)"], :order => nil}.freeze
     
-    def count_sql(opts = nil)
-      select_sql(opts ? opts.merge(SELECT_COUNT) : SELECT_COUNT)
+    # Returns the number of records in the dataset.
+    def count
+      single_value(SELECT_COUNT).to_i
     end
-
+    alias size count
+    
+    # Returns a table reference for use in the FROM clause. If the dataset has
+    # only a :from option refering to a single table, only the table name is 
+    # returned. Otherwise a subquery is returned.
     def to_table_reference
       if opts.keys == [:from] && opts[:from].size == 1
         opts[:from].first.to_s
@@ -444,29 +542,33 @@ module Sequel
       end
     end
     
-    # aggregates
+    # Returns the minimum value for the given field.
     def min(field)
-      select(field.MIN).naked.first.values.first
+      single_value(:select => [field.MIN])
     end
     
+    # Returns the maximum value for the given field.
     def max(field)
-      select(field.MAX).naked.first.values.first
+      single_value(:select => [field.MAX])
     end
 
+    # Returns the sum for the given field.
     def sum(field)
-      select(field.SUM).naked.first.values.first
+      single_value(:select => [field.SUM])
     end
     
+    # Returns the average value for the given field.
     def avg(field)
-      select(field.AVG).naked.first.values.first
+      single_value(:select => [field.AVG])
     end
     
+    # Returns an EXISTS clause for the dataset.
+    #
+    #   dataset.exists #=> "EXISTS (SELECT 1 FROM items)"
     def exists(opts = nil)
       "EXISTS (#{sql({:select => [1]}.merge(opts || {}))})"
     end
     
-    LIMIT_1 = {:limit => 1}.freeze
-    
     # If given an integer, the dataset will contain only the first l results.
     # If given a range, it will contain only those at offsets within that
     # range. If a second argument is given, it is used as an offset.
@@ -485,7 +587,7 @@ module Sequel
     # an array is returned with the first <i>num</i> records.
     def first(num = 1)
       if num == 1
-        first_record
+        single_record
       else
         limit(num).all
       end
@@ -496,6 +598,10 @@ module Sequel
       where(*conditions).first
     end
     
+    # Returns the last records in the dataset by inverting the order. If no
+    # order is given, an exception is raised. If num is not given, the last
+    # record is returned. Otherwise an array is returned with the last 
+    # <i>num</i> records.
     def last(num = 1)
       raise SequelError, 'No order specified' unless 
         @opts[:order] || (opts && opts[:order])
@@ -505,7 +611,7 @@ module Sequel
         merge(opts ? opts.merge(l) : l)
 
       if num == 1
-        first_record(opts)
+        single_record(opts)
       else
         dup_merge(opts).all
       end
@@ -514,7 +620,7 @@ module Sequel
     # Deletes all records in the dataset one at a time by invoking the destroy
     # method of the associated model class.
     def destroy
-      raise SequelError, 'Dataset not associated with model' unless @record_class
+      raise SequelError, 'Dataset not associated with model' unless @model_class
       
       count = 0
       @db.transaction {each {|r| count += 1; r.destroy}}
@@ -543,14 +649,13 @@ class Symbol
   def AVG; "avg(#{to_field_name})"; end
 
   AS_REGEXP = /(.*)___(.*)/.freeze
-  AS_FORMAT = "%s AS %s".freeze
   DOUBLE_UNDERSCORE = '__'.freeze
   PERIOD = '.'.freeze
   
   def to_field_name
     s = to_s
     if s =~ AS_REGEXP
-      s = AS_FORMAT % [$1, $2]
+      s = "#{$1} AS #{$2}"
     end
     s.split(DOUBLE_UNDERSCORE).join(PERIOD)
   end

data/lib/sequel/model.rb

@@ -1,3 +1,4 @@
+require 'rubygems'
 require 'metaid'
 
 module Sequel
@@ -22,14 +23,14 @@ module Sequel
         raise RuntimeError, "No database connected."
       end
       @dataset = db[table_name]
-      @dataset.record_class = self
+      @dataset.model_class = self
       @dataset
     end
 
     def self.set_dataset(ds)
       @db = ds.db
       @dataset = ds
-      @dataset.record_class = self
+      @dataset.model_class = self
     end
     
     def self.cache_by(column, expiration)
@@ -124,11 +125,19 @@ module Sequel
     def run_hooks(key)
       self.class.get_hooks(key).each {|h| instance_eval(&h)}
     end
-
+    
+    def self.before_create(&block)
+      get_hooks(:before_create).unshift(block)
+    end
+    
     def self.before_destroy(&block)
       get_hooks(:before_destroy).unshift(block)
     end
     
+    def self.after_destroy(&block)
+      get_hooks(:after_destroy).unshift(block)
+    end
+    
     def self.after_create(&block)
       get_hooks(:after_create) << block
     end
@@ -161,8 +170,7 @@ module Sequel
     end
     
     def refresh
-      record = self.class.find(primary_key => @pkey)
-      record ? (@values = record.values) : 
+      @values = self.class.dataset.naked[primary_key => @pkey] ||
         (raise RuntimeError, "Record not found")
       self
     end
@@ -185,8 +193,8 @@ module Sequel
     
     def self.create(values = nil)
       db.transaction do
-        obj = find(primary_key => dataset.insert(values))
-        obj.run_hooks(:after_create)
+        obj = new(values || {})
+        obj.save
         obj
       end
     end
@@ -225,11 +233,6 @@ module Sequel
     
     def db; self.class.db; end
     
-    def reload
-      temp = self.class[@pkey]
-      @values = self.class.dataset.naked[primary_key => @pkey]
-    end
-    
     def [](field); @values[field]; end
     
     def []=(field, value); @values[field] = value; end
@@ -247,12 +250,18 @@ module Sequel
     def id; @values[:id]; end
     
     def save
+      run_hooks(:before_save)
       if @pkey
+        # run_hooks(:before_update)
         model.dataset.filter(primary_key => @pkey).update(@values)
+        # run_hooks(:after_update)
       else
+        # run_hooks(:before_create)
         @pkey = model.dataset.insert(@values)
-        reload
+        refresh
+        # run_hooks(:after_create)
       end
+      run_hooks(:after_save)
     end
     
     def ==(obj)

data/lib/sequel/mysql.rb

@@ -56,10 +56,6 @@ module Sequel
         self
       end
       
-      def first_record(opts = nil)
-        query_first(select_sql(opts), true)
-      end
-    
       def count(opts = nil)
         query_single_value(count_sql(opts)).to_i
       end
@@ -76,12 +72,12 @@ module Sequel
         @db.execute_affected(delete_sql(opts))
       end
       
-      def query_each(sql, use_record_class = false)
+      def query_each(sql, use_model_class = false)
         @db.synchronize do
           result = @db.execute(sql)
           begin
-            if use_record_class && @record_class
-              result.each_hash {|r| yield @record_class.new(r)}
+            if use_model_class && @model_class
+              result.each_hash {|r| yield @model_class.new(r)}
             else
               result.each_hash {|r| yield r}
             end
@@ -92,12 +88,20 @@ module Sequel
         self
       end
       
-      def query_first(sql, use_record_class = false)
+      def single_record(opts = nil)
+        query_single(select_sql(opts), true)
+      end
+      
+      def single_value(opts = nil)
+        query_single_value(select_sql(opts))
+      end
+      
+      def query_single(sql, use_model_class = false)
         @db.synchronize do
           result = @db.execute(sql)
           begin
-            if use_record_class && @record_class
-              @record_class.new(result.fetch_hash)
+            if use_model_class && @model_class
+              @model_class.new(result.fetch_hash)
             else
               result.fetch_hash
             end

data/lib/sequel/postgres.rb

@@ -129,11 +129,12 @@ class String
   TIME_REGEXP = /(\d{4})-(\d{2})-(\d{2})\s(\d{2}):(\d{2}):(\d{2})/
   
   def postgres_to_time
-    if self =~ TIME_REGEXP
-      Time.local($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i)
-    else
-      nil
-    end
+    Time.parse(self)
+    # if self =~ TIME_REGEXP
+    #   Time.local($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i)
+    # else
+    #   nil
+    # end
   end
 end
 
@@ -215,8 +216,24 @@ module Sequel
     end
   
     class Dataset < Sequel::Dataset
+      TRUE = "'t'".freeze
+      FALSE = "'f'".freeze
+      
       def literal(v)
         case v
+        # when String: "'%s'" % v.gsub(/'/, "''")
+        # when Integer, Float: v.to_s
+        # when NilClass: NULL
+        # when Symbol: v.to_field_name
+        # 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 true: TRUE
+        # when false: FALSE
+        # else
+        #   raise SequelError, "can't express #{v.inspect}:#{v.class} as a SQL literal"
+        # end
         when String, Fixnum, Float, TrueClass, FalseClass: PGconn.quote(v)
         else
           super
@@ -241,10 +258,6 @@ module Sequel
         self
       end
       
-      def first_record(opts = nil)
-        query_first(select_sql(opts), true)
-      end
-    
       FOR_UPDATE = ' FOR UPDATE'.freeze
       FOR_SHARE = ' FOR SHARE'.freeze
     
@@ -301,10 +314,6 @@ module Sequel
         end
       end
   
-      def count(opts = nil)
-        query_single_value(count_sql(opts)).to_i
-      end
-    
       def insert(*values)
         @db.execute_insert(insert_sql(*values), @opts[:from])
       end
@@ -333,25 +342,20 @@ module Sequel
         end
       end
       
-      def query_all(sql, use_record_class = false)
-        @db.synchronize do
-          result = @db.execute(sql)
-          begin
-            conv = row_converter(result, use_record_class)
-            all = []
-            result.each {|r| all << conv[r]}
-          ensure
-            result.clear
-          end
-          all
-        end
+      def single_record(opts = nil)
+        query_single(select_sql(opts), true)
       end
-    
-      def query_each(sql, use_record_class = false)
+      
+      def single_value(opts = nil)
+        query_single_value(select_sql(opts))
+      end
+      
+      def query_each(sql, use_model_class = false, &block)
         @db.synchronize do
           result = @db.execute(sql)
           begin
-            conv = row_converter(result, use_record_class)
+            # each_row(result, use_model_class, &block)
+            conv = row_converter(result, use_model_class)
             result.each {|r| yield conv[r]}
           ensure
             result.clear
@@ -359,12 +363,13 @@ module Sequel
         end
       end
       
-      def query_first(sql, use_record_class = false)
+      def query_single(sql, use_model_class = false)
         @db.synchronize do
           result = @db.execute(sql)
           begin
             row = nil
-            conv = row_converter(result, use_record_class)
+            # each_row(result, use_model_class) {|r| row = r}
+            conv = row_converter(result, use_model_class)
             result.each {|r| row = conv.call(r)}
           ensure
             result.clear
@@ -378,22 +383,42 @@ module Sequel
           result = @db.execute(sql)
           begin
             value = result.getvalue(0, 0)
+            if value
+              value = value.send(PG_TYPES[result.type(0)])
+            end
           ensure
             result.clear
           end
           value
         end
       end
+      
+      def each_row(result, use_model_class)
+        fields = result.fields.map {|s| s.to_sym}
+        types = (0..(result.num_fields - 1)).map {|idx| PG_TYPES[result.type(idx)]}
+        m_klass = use_model_class && @model_class
+        result.each do |row|
+          hashed_row = {}
+          row.each_index do |cel_index|
+            column = row[cel_index]
+            if column && types[cel_index]
+              column = column.send(types[cel_index])
+            end
+            hashed_row[fields[cel_index]] = column
+          end
+          yield m_klass ? m_klass.new(hashed_row) : hashed_row
+        end
+      end
     
       COMMA = ','.freeze
     
       @@converters_mutex = Mutex.new
       @@converters = {}
 
-      def row_converter(result, use_record_class)
+      def row_converter(result, use_model_class)
         fields = result.fields.map {|s| s.to_sym}
         types = (0..(result.num_fields - 1)).map {|idx| result.type(idx)}
-        klass = use_record_class ? @record_class : nil
+        klass = use_model_class ? @model_class : nil
         
         # create result signature and memoize the converter
         sig = fields.join(COMMA) + types.join(COMMA) + klass.to_s
@@ -403,7 +428,7 @@ module Sequel
       end
     
       CONVERT = "lambda {|r| {%s}}".freeze
-      CONVERT_RECORD_CLASS = "lambda {|r| %2$s.new(%1$s)}".freeze
+      CONVERT_MODEL_CLASS = "lambda {|r| %2$s.new(%1$s)}".freeze
     
       CONVERT_FIELD = '%s => r[%d]'.freeze
       CONVERT_FIELD_TRANSLATE = '%s => ((t = r[%d]) ? t.%s : nil)'.freeze
@@ -419,7 +444,7 @@ module Sequel
           kvs << (translate_fn ? CONVERT_FIELD_TRANSLATE : CONVERT_FIELD) %
             [field.inspect, idx, translate_fn]
         end
-        s = (klass ? CONVERT_RECORD_CLASS : CONVERT) %
+        s = (klass ? CONVERT_MODEL_CLASS : CONVERT) %
           [kvs.join(COMMA), klass]
         eval(s)
       end

data/lib/sequel/sqlite.rb

@@ -43,7 +43,7 @@ module Sequel
         @pool.hold {|conn| conn.get_first_value(sql)}
       end
       
-      def result_set(sql, record_class, &block)
+      def result_set(sql, model_class, &block)
         @pool.hold do |conn|
           conn.query(sql) do |result|
             columns = result.columns
@@ -51,7 +51,7 @@ module Sequel
             result.each do |values|
               row = {}
               column_count.times {|i| row[columns[i].to_sym] = values[i]}
-              block.call(record_class ? record_class.new(row) : row)
+              block.call(model_class ? model_class.new(row) : row)
             end
           end
         end
@@ -68,20 +68,10 @@ module Sequel
       end
 
       def each(opts = nil, &block)
-        @db.result_set(select_sql(opts), @record_class, &block)
+        @db.result_set(select_sql(opts), @model_class, &block)
         self
       end
     
-      LIMIT_1 = {:limit => 1}.freeze
-    
-      def first_record(opts = nil)
-        @db.result_set(select_sql(opts), @record_class) {|r| return r}
-      end
-    
-      def count(opts = nil)
-        @db.single_value(count_sql(opts)).to_i
-      end
-    
       def insert(*values)
         @db.synchronize do
           @db.execute_insert insert_sql(*values)

metadata

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