sequel 0.2.1.1 → 0.3.0

data/lib/sequel/dataset.rb

@@ -147,6 +147,7 @@ module Sequel
       @columns || []
     end
     
+    # Inserts the supplied values into the associated table.
     def <<(*args)
       insert(*args)
     end
@@ -263,6 +264,11 @@ module Sequel
       update_each_method
     end
     
+    STOCK_TRANSFORMS = {
+      :marshal => [proc {|v| Marshal.load(v)}, proc {|v| Marshal.dump(v)}],
+      :yaml => [proc {|v| YAML.load v if v}, proc {|v| v.to_yaml}]
+    }
+    
     # Sets a value transform which is used to convert values loaded and saved
     # to/from the database. The transform should be supplied as a hash. Each
     # value in the hash should be an array containing two proc objects - one
@@ -277,36 +283,51 @@ module Sequel
     #
     #   dataset.insert_sql(:obj => 1234) #=>
     #   "INSERT INTO items (obj) VALUES ('\004\bi\002\322\004')"
-    #   
+    #
+    # Another form of using transform is by specifying stock transforms:
+    # 
+    #   dataset.transform(:obj => :marshal)
+    #
+    # The currently supported stock transforms are :marshal and :yaml.
     def transform(t)
       @transform = t
+      t.each do |k, v|
+        case v
+        when Array:
+          if (v.size != 2) || !v.first.is_a?(Proc) && !v.last.is_a?(Proc)
+            raise SequelError, "Invalid transform specified"
+          end
+        else
+          unless v = STOCK_TRANSFORMS[v]
+            raise SequelError, "Invalid transform specified"
+          else
+            t[k] = v
+          end
+        end
+      end
       update_each_method
     end
     
     # Applies the value transform for data loaded from the database.
     def transform_load(r)
-      r.inject({}) do |m, kv|
-        k, v = kv[0], kv[1]
-        m[k] = (tt = @transform[k]) ? tt[0][v] : v
-        m
+      @transform.each do |k, tt|
+        if r.has_key?(k)
+          r[k] = tt[0][r[k]]
+        end
       end
-      # 
-      # @transform.each do |k, tt|
-      #   r[k] = tt[0][r[k]]
-      # end
-      # r
+      r
     end
     
     # Applies the value transform for data saved to the database.
     def transform_save(r)
-      r.inject({}) do |m, kv|
-        k, v = kv[0], kv[1]
-        m[k] = (tt = @transform[k]) ? tt[1][v] : v
-        m
+      @transform.each do |k, tt|
+        if r.has_key?(k)
+          r[k] = tt[1][r[k]]
+        end
       end
+      r
     end
     
-    private
     # Updates the each method according to whether @row_proc and @transform are
     # set or not.
     def update_each_method
@@ -358,6 +379,16 @@ module Sequel
         end
       end
     end
+
+    @@dataset_classes = []
+
+    def self.dataset_classes
+      @@dataset_classes
+    end
+
+    def self.inherited(c)
+      @@dataset_classes << c
+    end
   end
 end
 

data/lib/sequel/dataset/convenience.rb

@@ -3,6 +3,12 @@ require 'enumerator'
 module Sequel
   class Dataset
     module Convenience
+      # Iterates through each record, converting it into a hash.
+      def each_hash(&block)
+        each {|a| block[a.to_hash]}
+      end
+      
+      # Returns true if the record count is 0
       def empty?
         count == 0
       end
@@ -24,13 +30,16 @@ 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(*args)
+      def first(*args, &block)
+        if block
+          return filter(&block).single_record(:limit => 1)
+        end
         args = args.empty? ? 1 : (args.size == 1) ? args.first : args
         case args
         when 1: single_record(:limit => 1)
         when Fixnum: limit(args).all
         else
-          filter(args).single_record(:limit => 1)
+          filter(args, &block).single_record(:limit => 1)
         end
       end
 
@@ -168,6 +177,22 @@ module Sequel
         Sequel::PrettyTable.print(naked.all, cols.empty? ? columns : cols)
       end
       
+      COMMA_SEPARATOR = ', '.freeze
+      
+      # Returns a string in CSV format containing the dataset records. By 
+      # default the CSV representation includes the column titles in the
+      # first line. You can turn that off by passing false as the 
+      # include_column_titles argument.
+      def to_csv(include_column_titles = true)
+        records = naked.to_a
+        csv = ''
+        if include_column_titles
+          csv << "#{@columns.join(COMMA_SEPARATOR)}\r\n"
+        end
+        records.each {|r| csv << "#{r.join(COMMA_SEPARATOR)}\r\n"}
+        csv
+      end
+
       # Inserts multiple records into the associated table. This method can be
       # to efficiently insert a large amounts of records into a table. Inserts
       # are automatically wrapped in a transaction. If the :commit_every 

data/lib/sequel/dataset/sequelizer.rb

@@ -40,8 +40,8 @@ class Sequel::Dataset
       case r
       when Range:
         r.exclude_end? ? \
-          "(#{l} >= #{literal(r.begin)} AND #{l} < #{literal(r.end)})" : \
-          "(#{l} >= #{literal(r.begin)} AND #{l} <= #{literal(r.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:
         "(#{literal(l)} IN (#{literal(r)}))"
       when Sequel::Dataset:

data/lib/sequel/dataset/sql.rb

@@ -52,7 +52,9 @@ module Sequel
         if fields.empty?
           WILDCARD
         else
-          fields.map {|i| field_name(i)}.join(COMMA_SEPARATOR)
+          fields.map do |i|
+            i.is_a?(Hash) ? i.map {|kv| "#{literal(kv[0])} AS #{kv[1]}"} : literal(i)
+          end.join(COMMA_SEPARATOR)
         end
       end
 
@@ -61,8 +63,19 @@ module Sequel
         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)
+        auto_alias_count = 0
+        source.map do |i|
+          case i
+          when Dataset:
+            auto_alias_count += 1
+            i.to_table_reference(auto_alias_count)
+          when Hash:
+            i.map {|k, v| "#{k.is_a?(Dataset) ? k.to_table_reference : k} #{v}"}.
+              join(COMMA_SEPARATOR)
+          else
+            i
+          end
+        end.join(COMMA_SEPARATOR)
       end
 
       NULL = "NULL".freeze
@@ -92,7 +105,7 @@ module Sequel
         when NilClass: NULL
         when TrueClass: TRUE
         when FalseClass: FALSE
-        when Symbol: v.to_field_name
+        when Symbol: quoted_field_name(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)
@@ -111,7 +124,10 @@ module Sequel
         case expr
         when Hash:
           parenthesize = false if expr.size == 1
-          fmt = expr.map {|i| compare_expr(i[0], i[1])}.join(AND_SEPARATOR)
+          # fmt = expr.map {|i| compare_expr(i[0], i[1])}.join(AND_SEPARATOR)
+          # N.B.: We convert this to an array and sort it in order to have a fixed order for testability.
+          # Hash in Ruby 1.8 has no order, so Hash#map is indeterminate, which makes it hard to test.
+          fmt = expr.to_a.sort_by { |k, v| k.to_s }.map {|i| compare_expr(i[0], i[1])}.join(AND_SEPARATOR)
         when Array:
           fmt = expr.shift.gsub(QUESTION_MARK) {literal(expr.shift)}
         when Proc:
@@ -154,7 +170,7 @@ module Sequel
         order(*invert_order(order.empty? ? @opts[:order] : order))
       end
 
-      DESC_ORDER_REGEXP = /(.*)\sDESC/.freeze
+      DESC_ORDER_REGEXP = /(.*)\sDESC/i.freeze
 
       # Inverts the given order by breaking it into a list of field references
       # and inverting them.
@@ -167,7 +183,7 @@ module Sequel
         order.each do |f|
           f.to_s.split(',').map do |p|
             p.strip!
-            new_order << (p =~ DESC_ORDER_REGEXP ? $1 : p.to_sym.DESC)
+            new_order << ((p =~ DESC_ORDER_REGEXP ? $1 : p.to_sym.DESC).lit)
           end
         end
         new_order
@@ -312,13 +328,13 @@ module Sequel
           raise SequelError, "Invalid join type: #{type}"
         end
 
-        join_expr = expr.map do |k, v|
-          l = qualified_field_name(k, table)
-          r = qualified_field_name(v, @opts[:last_joined_table] || @opts[:from].first)
-          "(#{l} = #{r})"
-        end.join(AND_SEPARATOR)
-
-        " #{join_type} #{table} ON #{join_expr}"
+        join_conditions = {}
+        expr.each do |k, v|
+          k = qualified_field_name(k, table).intern if k.is_a?(Symbol)
+          v = qualified_field_name(v, @opts[:last_joined_table] || @opts[:from].first).intern if v.is_a?(Symbol)
+          join_conditions[k] = v
+        end
+        " #{join_type} #{table} ON #{expression_list(join_conditions)}"
       end
 
       # Returns a joined dataset with the specified join type and condition.
@@ -427,6 +443,18 @@ module Sequel
         else
           values = values[0] if values.size == 1
           case values
+          when Array
+            if values.fields
+              if values.empty?
+                "INSERT INTO #{@opts[:from]} DEFAULT VALUES;"
+              else
+                fl = values.fields
+                vl = transform_save(values.values).map {|v| literal(v)}
+                "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)});"
+              end
+            else
+              "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)});"
+            end
           when Hash
             values = transform_save(values) if @transform
             if values.empty?
@@ -437,7 +465,7 @@ module Sequel
               "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)});"
             end
           when Dataset
-            "INSERT INTO #{@opts[:from]} #{literal(values)}"
+            "INSERT INTO #{@opts[:from]} #{literal(values)};"
           else
             "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)});"
           end
@@ -457,6 +485,9 @@ module Sequel
           raise SequelError, "Can't update a joined dataset"
         end
 
+        if values.is_a?(Array) && values.fields
+          values = values.to_hash
+        end
         values = transform_save(values) if @transform
         set_list = values.map {|k, v| "#{field_name(k)} = #{literal(v)}"}.
           join(COMMA_SEPARATOR)
@@ -494,11 +525,11 @@ module Sequel
       # 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
+      def to_table_reference(idx = nil)
         if opts.keys == [:from] && opts[:from].size == 1
           opts[:from].first.to_s
         else
-          "(#{sql})"
+          idx ? "(#{sql}) t#{idx}" : "(#{sql})"
         end
       end
 
@@ -523,7 +554,7 @@ module Sequel
         end
       end
       
-      SELECT_COUNT = {:select => ["COUNT(*)"], :order => nil}.freeze
+      SELECT_COUNT = {:select => ["COUNT(*)".lit], :order => nil}.freeze
 
       # Returns the number of records in the dataset.
       def count

data/lib/sequel/dbi.rb

@@ -14,6 +14,10 @@ module Sequel
         dbname = 'DBI:' + dbname unless dbname =~ /^DBI:/
         ::DBI.connect(dbname, @opts[:user], @opts[:password])
       end
+      
+      def disconnect
+        @pool.disconnect {|c| c.disconnect}
+      end
     
       def dataset(opts = nil)
         DBI::Dataset.new(self, opts)
@@ -56,6 +60,19 @@ module Sequel
         self
       end
       
+      def array_tuples_fetch_rows(sql, &block)
+        @db.synchronize do
+          s = @db.execute sql
+          begin
+            @columns = s.column_names.map {|c| c.to_sym}
+            s.fetch {|r| r.fields = @columns; yield r}
+          ensure
+            s.finish rescue nil
+          end
+        end
+        self
+      end
+      
       def hash_row(stmt, row)
         @columns.inject({}) do |m, c|
           m[c] = row.shift

data/lib/sequel/model.rb

@@ -1,82 +1,276 @@
-module Sequel
-  class Model
-  end
-end
-
-require File.join(File.dirname(__FILE__), 'model/base')
-require File.join(File.dirname(__FILE__), 'model/hooks')
-require File.join(File.dirname(__FILE__), 'model/record')
-require File.join(File.dirname(__FILE__), 'model/schema')
-require File.join(File.dirname(__FILE__), 'model/relations')
-
-module Sequel
-  class Model
-    def self.subset(name, *args, &block)
-      meta_def(name) {filter(*args, &block)}
-    end
-    
-    def primary_key_hash(value)
-      # stock implementation
-      {:id => value}
-    end
-    
-    def self.find(cond)
-      dataset[cond.is_a?(Hash) ? cond : primary_key_hash(cond)]
-    end
-    
-    def self.find_or_create(cond)
-      find(cond) || create(cond)
-    end
-
-    class << self; alias_method :[], :find; end
-    
-    ############################################################################
-    
-    def self.destroy_all
-      has_hooks?(:before_destroy) ? dataset.destroy : dataset.delete
-    end
-    def self.delete_all; dataset.delete; end
-    
-    FIND_BY_REGEXP = /^find_by_(.*)/.freeze
-    FILTER_BY_REGEXP = /^filter_by_(.*)/.freeze
-    ALL_BY_REGEXP = /^all_by_(.*)/.freeze
-    
-    def self.method_missing(m, *args, &block)
-      Thread.exclusive do
-        method_name = m.to_s
-        if method_name =~ FIND_BY_REGEXP
-          c = $1.to_sym
-          meta_def(method_name) {|arg| find(c => arg)}
-        elsif method_name =~ FILTER_BY_REGEXP
-          c = $1.to_sym
-          meta_def(method_name) {|arg| filter(c => arg)}
-        elsif method_name =~ ALL_BY_REGEXP
-          c = $1.to_sym
-          meta_def(method_name) {|arg| filter(c => arg).all}
-        elsif dataset.respond_to?(m)
-          instance_eval("def #{m}(*args, &block); dataset.#{m}(*args, &block); end")
-        end
-      end
-      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 [](field); @values[field]; end
-    
-    def []=(field, value); @values[field] = value; end
-    
-    def each(&block); @values.each(&block); end
-    def keys; @values.keys; end
-    
-    def id; @values[:id]; end
-    
-    def ==(obj)
-      (obj.class == model) && (obj.values == @values)
-    end
-  end
-  
-end
+module Sequel
+  # == Cheatsheet:
+  #   class Item < Sequel::Model(:items)
+  #     set_schema do
+  #       primary_key :id
+  #       text :name, :unique => true, :null => false
+  #       boolean :active, :default => true
+  #       integer :grade
+  #
+  #       index :grade
+  #     end
+  #   end
+  #
+  #   Item.create_table unless Item.table_exists?
+  #   Item.create_table!
+  #
+  #   i = Item.create(:name => 'Shoes', :grade => 0)
+  #
+  #   Item[1].grade #=> 0
+  #
+  #   i.set(:grade => 2)
+  #   i.grade # => 2
+  #
+  #   Item[:name => 'Shoes'].grade # => 2
+  #
+  #   i.grade = 4
+  #   Item[1].grade # => 2
+  #   i.save
+  #   Item[1].grade # => 4
+  #
+  # == Subsets
+  # Subsets are filter mapped to class methods:
+  #
+  #   class Ticket < Sequel::Model(:tickets)
+  #
+  #     subset(:pending) { finished_at == nil }
+  #     subset(:closed)  { finished_at != nil }
+  #
+  #     # ...
+  #
+  #   end
+  #
+  # Now you can do:
+  #
+  #   Ticket.pending.each { |ticket| puts ticket.caption }
+  #
+  # == Advanced filtering methods (or dataset magic)
+  # One of the cool features of Sequel::Model is that it acts as a proxy to
+  # the underlying dataset, so you can invoke methods on the class instead of
+  # on the dataset:
+  #
+  #   Customer.filter(:name =~ 'Roberts')
+  #
+  # In the prevailing style of implementing models (which is actually very
+  # similar to ActiveRecord models) table-wide operations are defined as
+  # class methods:
+  #
+  #   class Node < Sequel::Model(:nodes)
+  #     def self.subtree(path)
+  #       filter(:path => Regexp.new("^#{path}(/.+)?$"))
+  #     end
+  #     def self.alarms
+  #       filter {:kind => ALARM}
+  #     end
+  #     def self.recalculate
+  #       exclude(:expression => nil).each {|n| n.calculate}
+  #     end
+  #   end
+  #
+  # The recalculate class method calls the exclude method. The exclude
+  # call is proxied to the underlying dataset, which lets you call each
+  # method separately:
+  #
+  #   Node.subtree('/test')
+  #   Node.alarms
+  #   Node.recalculate
+  #
+  # ... but this will raise a NoMethodError:
+  #
+  #   Node.subtree('/test').alarms.recalculate
+  #
+  # It turns out the solution is very simple - instead of defining class
+  # methods, define dataset methods:
+  #
+  #   class Node < Sequel::Model(:nodes)
+  #     def dataset.subtree(path)
+  #       filter(:path => Regexp.new("^#{path}(/.+)?$"))
+  #     end
+  #     def dataset.alarms
+  #       filter {:kind => ALARM}
+  #     end
+  #     def dataset.recalculate
+  #       exclude(:expression => nil).each {|n| n.calculate}
+  #     end
+  #   end
+  #
+  # Now you can mix all of these methods any way you like:
+  #
+  #   Node.filter {:stamp < Time.now < 3600}.alarms
+  #   Node.filter(:project_id => 123).subtree('/abc')
+  #   Node.subtree('/test').recalculate
+  #   # ...
+  #
+  # == Schemas
+  # You can define your schema in the Model class itself:
+  #
+  #   class Comment < Sequel::Model(:comments)
+  #     set_schema do
+  #       primary_key :id
+  #       foreign_key :post_id, :table => :posts, :on_delete => :cascade
+  #
+  #       varchar :name
+  #       varchar :email
+  #       text :comment
+  #     end
+  #
+  #     # ...
+  #
+  #   end
+  #
+  # == Hooks
+  # You can setup hooks here:
+  # * before_save calls either
+  # * before_create with
+  # * after_create or if record already exists
+  # * before_update with
+  # * after_update and finally
+  # * after_save
+  # ... and here:
+  # * before_destroy with
+  # * after_destroy
+  #
+  # ...with:
+  #
+  #   class Example < Sequel::Model(:hooks)
+  #     before_create { self.created_at = Time.now }
+  #
+  #     # ...
+  #   end
+  #
+  # == Serialization of complexe attributes
+  # Sometimes there are datatypes you can't natively map to your db. In this
+  # case you can just do serialize:
+  #
+  #   class Serialized < Sequel::Model(:serialized)
+  #     serialize :column1, :format => :yaml    # YAML is the default serialization method
+  #     serialize :column2, :format => :marshal # serializes through marshalling
+  #
+  #     # ...
+  #
+  #   end
+  class Model
+    alias_method :model, :class
+  end
+end
+
+require File.join(File.dirname(__FILE__), 'model/base')
+require File.join(File.dirname(__FILE__), 'model/hooks')
+require File.join(File.dirname(__FILE__), 'model/record')
+require File.join(File.dirname(__FILE__), 'model/schema')
+require File.join(File.dirname(__FILE__), 'model/relations')
+require File.join(File.dirname(__FILE__), 'model/caching')
+
+module Sequel
+  class Model
+
+    # Defines a method that returns a filtered dataset.
+    def self.subset(name, *args, &block)
+      dataset.meta_def(name) {filter(*args, &block)}
+    end
+
+    # Comprehensive description goes here!
+    def primary_key_hash(value)
+      # stock implementation
+      {:id => value}
+    end
+
+    # Finds a single record according to the supplied filter, e.g.:
+    #
+    #   Ticket.find :author => 'Sharon' # => record
+    #   Ticket.find {:price}17 # => Dataset
+    #
+    def self.find(*args, &block)
+      dataset.filter(*args, &block).limit(1).first
+      # dataset[cond.is_a?(Hash) ? cond : primary_key_hash(cond)]
+    end
+    
+    def self.[](*args)
+      args = args.first if (args.size == 1)
+      dataset[(Hash === args) ? args : primary_key_hash(args)]
+    end
+    
+    # Like find but invokes create with given conditions when record does not
+    # exists.
+    def self.find_or_create(cond)
+      find(cond) || create(cond)
+    end
+
+    ############################################################################
+
+    # Like delete_all, but invokes before_destroy and after_destroy hooks if used.
+    def self.destroy_all
+      has_hooks?(:before_destroy) || has_hooks?(:after_destroy) ? \
+        dataset.destroy : dataset.delete
+    end
+    # Deletes all records.
+    def self.delete_all
+      dataset.delete
+    end
+
+    FIND_BY_REGEXP = /^find_by_(.*)/.freeze
+    FILTER_BY_REGEXP = /^filter_by_(.*)/.freeze
+    ALL_BY_REGEXP = /^all_by_(.*)/.freeze
+
+    def self.method_missing(m, *args, &block) #:nodoc:
+      Thread.exclusive do
+        method_name = m.to_s
+        if method_name =~ FIND_BY_REGEXP
+          c = $1.to_sym
+          meta_def(method_name) {|arg| find(c => arg)}
+        elsif method_name =~ FILTER_BY_REGEXP
+          c = $1.to_sym
+          meta_def(method_name) {|arg| filter(c => arg)}
+        elsif method_name =~ ALL_BY_REGEXP
+          c = $1.to_sym
+          meta_def(method_name) {|arg| filter(c => arg).all}
+        elsif dataset.respond_to?(m)
+          instance_eval("def #{m}(*args, &block); dataset.#{m}(*args, &block); end")
+        end
+      end
+      respond_to?(m) ? send(m, *args, &block) : super(m, *args)
+    end
+
+    # Comprehensive description goes here!
+    def self.join(*args)
+      table_name = dataset.opts[:from].first
+      dataset.join(*args).select(table_name.to_sym.ALL)
+    end
+
+    # Returns value of attribute.
+    def [](field)
+      @values[field]
+    end
+    # Sets value of attribute.
+    def []=(field, value)
+      @values[field] = value
+    end
+
+    # Enumerates through all attributes.
+    #
+    # === Example:
+    #   Ticket.find(7).each { |k, v| puts "#{k} => #{v}" }
+    def each(&block)
+      @values.each(&block)
+    end
+    # Returns attribute names.
+    def keys
+      @values.keys
+    end
+
+    # Returns value for <tt>:id</tt> attribute.
+    def id
+      @values[:id]
+    end
+
+    # Compares models by values.
+    def ==(obj)
+      (obj.class == model) && (obj.values == @values)
+    end
+    # Compares object by pkey.
+    def ===(obj)
+      (obj.class == model) && (obj.pkey == pkey)
+    end
+
+  end
+end