sequel 0.1.6 → 0.1.7

data/CHANGELOG

@@ -1,3 +1,25 @@
+*0.1.7*
+
+* Removed db.synchronize wrapping calls in sqlite adapter.
+
+* Implemented Model.join method to restrict returned columns to the model table (thanks Pedro Gutierrez).
+
+* Implemented Dataset#paginate method.
+
+* Fixed after_destroy hook.
+
+* Improved Dataset#first and #last to accept a filter hash.
+
+* Added Dataset#[]= method.
+
+* Added Sequel() convenience method.
+
+* Fixed Dataset#first to include a LIMIT clause for a single record.
+
+* Small fix to Postgres driver to return a primary_key value for the inserted record if it is specified in the insertion values (thanks Florian Aßmann and Pedro Gutierrez).
+
+* Fixed Symbol#DESC to support qualified notation (thanks Pedro Gutierrez).
+
 *0.1.6*
 
 * Fixed Model#method_missing to raise for an invalid attribute.

data/Rakefile

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

data/lib/sequel.rb

@@ -27,3 +27,9 @@ module Sequel #:nodoc:
     alias_method :open, :connect
   end
 end
+
+class Object
+  def Sequel(uri)
+    Sequel.connect(uri)
+  end
+end

data/lib/sequel/core_ext.rb

@@ -39,3 +39,35 @@ class String
     Sequel::ExpressionString.new(self)
   end
 end
+
+# Symbol extensions
+class Symbol
+  def DESC
+    "#{to_field_name} DESC"
+  end
+  
+  def AS(target)
+    "#{to_field_name} AS #{target}"
+  end
+  
+  AS_REGEXP = /(.*)___(.*)/.freeze
+  DOUBLE_UNDERSCORE = '__'.freeze
+  PERIOD = '.'.freeze
+  
+  def to_field_name
+    s = to_s
+    if s =~ AS_REGEXP
+      s = "#{$1} AS #{$2}"
+    end
+    s.split(DOUBLE_UNDERSCORE).join(PERIOD)
+  end
+  
+  def ALL
+    "#{to_s}.*"
+  end
+
+  def MIN; "min(#{to_field_name})"; end
+  def MAX; "max(#{to_field_name})"; end
+  def SUM; "sum(#{to_field_name})"; end
+  def AVG; "avg(#{to_field_name})"; end
+end

data/lib/sequel/dataset.rb

@@ -294,12 +294,17 @@ module Sequel
       clause = (@opts[:group] ? :having : :where)
       cond = cond.first if cond.size == 1
       parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
+      filter = cond.is_a?(Hash) && cond
       if @opts[clause]
+        if filter && cond.is_a?(Hash)
+          filter
+        end
+        filter = 
         l = expression_list(@opts[clause])
         r = expression_list(block || cond, parenthesize)
         dup_merge(clause => "#{l} AND #{r}")
       else
-        dup_merge(clause => expression_list(block || cond))
+        dup_merge(:filter => cond, clause => expression_list(block || cond))
       end
     end
     
@@ -606,6 +611,30 @@ module Sequel
     end
     alias size count
     
+    # returns a paginated dataset. The resulting dataset also provides the
+    # total number of pages (Dataset#page_count) and the current page number
+    # (Dataset#current_page), as well as Dataset#prev_page and Dataset#next_page
+    # for implementing pagination controls.
+    def paginate(page_no, page_size)
+      total_pages = (count / page_size.to_f).ceil
+      paginated = limit(page_size, (page_no - 1) * page_size)
+      paginated.current_page = page_no
+      paginated.page_count = total_pages
+      paginated
+    end
+    
+    attr_accessor :page_count, :current_page
+    
+    # Returns the previous page number or nil if the current page is the first
+    def prev_page
+      current_page > 1 ? (current_page - 1) : nil
+    end
+    
+    # Returns the next page number or nil if the current page is the last page
+    def next_page
+      current_page < page_count ? (current_page + 1) : nil
+    end
+    
     # 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.
@@ -660,35 +689,47 @@ module Sequel
     
     # Returns the first record in the dataset. If the num argument is specified,
     # an array is returned with the first <i>num</i> records.
-    def first(num = 1)
-      if num == 1
-        single_record
+    def first(*args)
+      args = args.empty? ? 1 : (args.size == 1) ? args.first : args
+      case args
+      when 1: single_record(:limit => 1)
+      when Fixnum: limit(args).all
       else
-        limit(num).all
+        filter(args).single_record(:limit => 1)
       end
     end
     
     # Returns the first record matching the condition.
     def [](*conditions)
-      where(*conditions).first
+      first(*conditions)
+    end
+    
+    def []=(conditions, values)
+      filter(conditions).update(values)
     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)
+    def last(*args)
       raise SequelError, 'No order specified' unless 
         @opts[:order] || (opts && opts[:order])
       
-      l = {:limit => num}
-      opts = {:order => invert_order(@opts[:order])}.
-        merge(opts ? opts.merge(l) : l)
-
-      if num == 1
-        single_record(opts)
+      args = args.empty? ? 1 : (args.size == 1) ? args.first : args
+      
+      case args
+      when Fixnum:
+        l = {:limit => args}
+        opts = {:order => invert_order(@opts[:order])}. \
+          merge(opts ? opts.merge(l) : l)
+        if args == 1
+          single_record(opts)
+        else
+          dup_merge(opts).all
+        end
       else
-        dup_merge(opts).all
+        filter(args).last(1)
       end
     end
     
@@ -709,33 +750,3 @@ module Sequel
   end
 end
 
-class Symbol
-  def DESC
-    "#{to_s} DESC"
-  end
-  
-  def AS(target)
-    "#{to_field_name} AS #{target}"
-  end
-  
-  def MIN; "min(#{to_field_name})"; end
-  def MAX; "max(#{to_field_name})"; end
-  def SUM; "sum(#{to_field_name})"; end
-  def AVG; "avg(#{to_field_name})"; end
-
-  AS_REGEXP = /(.*)___(.*)/.freeze
-  DOUBLE_UNDERSCORE = '__'.freeze
-  PERIOD = '.'.freeze
-  
-  def to_field_name
-    s = to_s
-    if s =~ AS_REGEXP
-      s = "#{$1} AS #{$2}"
-    end
-    s.split(DOUBLE_UNDERSCORE).join(PERIOD)
-  end
-  
-  def ALL
-    "#{to_s}.*"
-  end
-end

data/lib/sequel/model.rb

@@ -154,7 +154,7 @@ module Sequel
     end
     
     def self.after_destroy(&block)
-      get_hooks(:after_destroy).unshift(block)
+      get_hooks(:after_destroy) << block
     end
     
     def self.find(cond)
@@ -194,17 +194,6 @@ module Sequel
       self
     end
     
-    # def self.each(&block); dataset.each(&block); end
-    # def self.all; dataset.all; end
-    # def self.filter(*arg, &block); dataset.filter(*arg, &block); end
-    # def self.exclude(*arg, &block); dataset.exclude(*arg, &block); end
-    # def self.order(*arg); dataset.order(*arg); end
-    # def self.first(*arg); dataset.first(*arg); end
-    # def self.count; dataset.count; end
-    # def self.map(*arg, &block); dataset.map(*arg, &block); end
-    # def self.hash_column(column); dataset.hash_column(primary_key, column); end
-    # def self.join(*args); dataset.join(*args); end
-    # def self.lock(mode, &block); dataset.lock(mode, &block); end
     def self.destroy_all
       has_hooks?(:before_destroy) ? dataset.destroy : dataset.delete
     end
@@ -222,6 +211,7 @@ module Sequel
       db.transaction do
         run_hooks(:before_destroy)
         delete
+        run_hooks(:after_destroy)
       end
     end
     
@@ -252,6 +242,11 @@ module Sequel
       respond_to?(m) ? send(m, *args, &block) : super(m, *args)
     end
     
+    def self.join(*args)
+      table_name = dataset.opts[:from].first
+      dataset.join(*args).select(table_name.to_sym.ALL)
+    end
+    
     def db; self.class.db; end
     
     def [](field); @values[field]; end

data/lib/sequel/postgres.rb

@@ -41,9 +41,17 @@ class PGconn
       
   def last_insert_id(table)
     @table_sequences ||= {}
-    seq = @table_sequences[table] ||= pkey_and_sequence(table)[1]
-    r = async_query(SELECT_CURRVAL % seq)
-    r[0][0].to_i unless r.nil? || r.empty?
+    if !@table_sequences.include?(table)
+      pkey_and_seq = pkey_and_sequence(table)
+      if pkey_and_seq
+        @table_sequences[table] = pkey_and_seq[1]
+      end
+    end
+    if seq = @table_sequences[table]
+      r = async_query(SELECT_CURRVAL % seq)
+      return r[0][0].to_i unless r.nil? || r.empty?
+    end
+    nil # primary key sequence not found
   end
       
   # Shamelessly appropriated from ActiveRecord's Postgresql adapter.
@@ -74,13 +82,31 @@ class PGconn
       AND cons.contype = 'p'
       AND def.adsrc ~* 'nextval'
   end_sql
+
+  SELECT_PK = <<-end_sql
+    SELECT pg_attribute.attname
+    FROM pg_class, pg_attribute, pg_index
+    WHERE pg_class.oid = pg_attribute.attrelid AND
+      pg_class.oid = pg_index.indrelid AND
+      pg_index.indkey[0] = pg_attribute.attnum AND
+      pg_index.indisprimary = 't' AND
+      pg_class.relname = '%s'
+  end_sql
   
   def pkey_and_sequence(table)
     r = async_query(SELECT_PK_AND_SERIAL_SEQUENCE % table)
     return [r[0].first, r[0].last] unless r.nil? or r.empty?
 
     r = async_query(SELECT_PK_AND_CUSTOM_SEQUENCE % table)
-    return [r.first, r.last] unless r.nil? or r.empty?
+    return [r[0].first, r[0].last] unless r.nil? or r.empty?
+  rescue
+    nil
+  end
+  
+  def primary_key(table)
+    r = async_query(SELECT_PK % table)
+    pkey = r[0].first unless r.nil? or r.empty?
+    return pkey.to_sym if pkey
   rescue
     nil
   end
@@ -164,11 +190,42 @@ module Sequel
         raise e
       end
       
-      def execute_insert(sql, table)
+      def primary_key_for_table(conn, table)
+        @primary_keys ||= {}
+        @primary_keys[table] ||= conn.primary_key(table)
+      end
+      
+      RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session/.freeze
+      
+      def insert_result(conn, table, values)
+        begin
+          result = conn.last_insert_id(table)
+          return result if result
+        rescue PGError => e
+          # An error could occur if the inserted values include a primary key
+          # value, while the primary key is serial.
+          if e.message =~ RE_CURRVAL_ERROR
+            raise SequelError, "Could not return primary key value for the inserted record. Are you specifying a primary key value for a serial primary key?"
+          else
+            raise e
+          end
+        end
+        
+        case values
+        when Hash:
+          values[primary_key_for_table(conn, table)]
+        when Array:
+          values.first
+        else
+          nil
+        end
+      end
+      
+      def execute_insert(sql, table, values)
         @logger.info(sql) if @logger
         @pool.hold do |conn|
           conn.execute(sql).clear
-          conn.last_insert_id(table)
+          insert_result(conn, table, values)
         end
       rescue => e
         @logger.error(e.message) if @logger
@@ -314,7 +371,8 @@ module Sequel
       end
   
       def insert(*values)
-        @db.execute_insert(insert_sql(*values), @opts[:from])
+        @db.execute_insert(insert_sql(*values), @opts[:from],
+          values.size == 1 ? values.first : values)
       end
     
       def update(values, opts = nil)

data/lib/sequel/sqlite.rb

@@ -75,22 +75,16 @@ module Sequel
       end
     
       def insert(*values)
-        @db.synchronize do
-          @db.execute_insert insert_sql(*values)
-        end
+        @db.execute_insert insert_sql(*values)
       end
     
       def update(values, opts = nil)
-        @db.synchronize do
-          @db.execute update_sql(values, opts)
-        end
+        @db.execute update_sql(values, opts)
         self
       end
     
       def delete(opts = nil)
-        @db.synchronize do
-          @db.execute delete_sql(opts)
-        end
+        @db.execute delete_sql(opts)
         self
       end
       

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.1.6
-date: 2007-06-01 00:00:00 +03:00
+  version: 0.1.7
+date: 2007-06-30 00:00:00 +03:00
 summary: Concise ORM for Ruby.
 require_paths: 
 - lib