sequel 0.2.0.2 → 0.2.1

data/lib/sequel/dataset/convenience.rb

@@ -3,6 +3,10 @@ require 'enumerator'
 module Sequel
   class Dataset
     module Convenience
+      def empty?
+        count == 0
+      end
+      
       # Returns the first record in the dataset.
       def single_record(opts = nil)
         each(opts) {|r| return r}
@@ -186,6 +190,48 @@ module Sequel
           end
         end
       end
+      
+      module QueryBlockCopy
+        def each(*args); raise SequelError, "#each cannot be invoked inside a query block."; end
+        def insert(*args); raise SequelError, "#insert cannot be invoked inside a query block."; end
+        def update(*args); raise SequelError, "#update cannot be invoked inside a query block."; end
+        def delete(*args); raise SequelError, "#delete cannot be invoked inside a query block."; end
+        
+        def clone_merge(opts)
+          @opts.merge!(opts)
+        end
+      end
+      
+      # Translates a query block into a dataset. Query blocks can be useful
+      # when expressing complex SELECT statements, e.g.:
+      #
+      #   dataset = DB[:items].query do
+      #     select :x, :y, :z
+      #     where {:x > 1 && :y > 2}
+      #     order_by :z.DESC
+      #   end
+      #
+      def query(&block)
+        copy = clone_merge({})
+        copy.extend(QueryBlockCopy)
+        copy.instance_eval(&block)
+        clone_merge(copy.opts)
+      end
+      
+      MUTATION_RE = /^(.+)!$/.freeze
+      
+      def method_missing(m, *args, &block)
+        if m.to_s =~ MUTATION_RE
+          m = $1.to_sym
+          super unless respond_to?(m)
+          copy = send(m, *args, &block)
+          super if copy.class != self.class
+          @opts.merge!(copy.opts)
+          self
+        else
+          super
+        end
+      end
     end
   end
 end

data/lib/sequel/dataset/sequelizer.rb

@@ -108,7 +108,11 @@ class Sequel::Dataset
       when :>, :<, :>=, :<=
         l = eval_expr(e[1], b)
         r = eval_expr(e[3][1], b)
-        "(#{literal(l)} #{op} #{literal(r)})"
+        if (Symbol === l) || (Sequel::LiteralString === l) || (Symbol === r) || (Sequel::LiteralString === r)
+          "(#{literal(l)} #{op} #{literal(r)})"
+        else
+          ext_expr(e, b)
+        end
       when :==
         l = eval_expr(e[1], b)
         r = eval_expr(e[3][1], b)
@@ -120,7 +124,11 @@ class Sequel::Dataset
       when :+, :-, :*, :/, :%
         l = eval_expr(e[1], b)
         r = eval_expr(e[3][1], b)
-        "(#{literal(l)} #{op} #{literal(r)})".lit
+        if (Symbol === l) || (Sequel::LiteralString === l) || (Symbol === r) || (Sequel::LiteralString === r)
+          "(#{literal(l)} #{op} #{literal(r)})".lit
+        else
+          ext_expr(e, b)
+        end
       when :in, :in?
         # in/in? operators are supported using two forms:
         #   :x.in([1, 2, 3])
@@ -146,12 +154,32 @@ class Sequel::Dataset
       end
     end
     
+    def fcall_expr(e, b)
+      ext_expr(e, b)
+    end
+    
+    def vcall_expr(e, b)
+      eval(e[1].to_s, b)
+    end
+    
+    def iter_expr(e, b)
+      if e[1] == [:fcall, :proc]
+        eval_expr(e[3], b) # inline proc
+      else
+        ext_expr(e, b) # method call with inline proc
+      end
+    end
+    
     # Evaluates a parse-tree into an SQL expression.
     def eval_expr(e, b)
       case e[0]
       when :call # method call
         call_expr(e, b)
-      when :ivar, :cvar, :dvar, :vcall, :const, :gvar # local ref
+      when :fcall
+        fcall_expr(e, b)
+      when :vcall
+        vcall_expr(e, b)
+      when :ivar, :cvar, :dvar, :const, :gvar # local ref
         eval(e[1].to_s, b)
       when :nth_ref:
         eval("$#{e[1]}", b)
@@ -182,16 +210,14 @@ class Sequel::Dataset
         r = eval_expr(e[1], b)
         compare_expr(l, r)
       when :iter
-        if e[1] == [:fcall, :proc]
-          eval_expr(e[3], b) # inline proc
-        else
-          ext_expr(e, b) # method call with inline proc
-        end
+        iter_expr(e, b)
       when :dasgn, :dasgn_curr
         # assignment
         l = e[1]
         r = eval_expr(e[2], b)
         raise SequelError, "Invalid expression #{l} = #{r}. Did you mean :#{l} == #{r}?"
+      when :if, :dstr
+        ext_expr(e, b)
       else
         raise SequelError, "Invalid expression tree: #{e.inspect}"
       end

data/lib/sequel/dataset/sql.rb

@@ -145,6 +145,8 @@ module Sequel
       def order(*order)
         clone_merge(:order => order)
       end
+      
+      alias_method :order_by, :order
 
       # Returns a copy of the dataset with the order reversed. If no order is
       # given, the existing order is inverted.
@@ -176,6 +178,8 @@ module Sequel
       def group(*fields)
         clone_merge(:group => fields)
       end
+      
+      alias_method :group_by, :group
 
       # 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 
@@ -424,15 +428,14 @@ module Sequel
           values = values[0] if values.size == 1
           case values
           when Hash
-            field_list = []
-            value_list = []
-            values.each do |k, v|
-              field_list << field_name(k)
-              value_list << literal(v)
+            values = transform_save(values) if @transform
+            if values.empty?
+              "INSERT INTO #{@opts[:from]} DEFAULT VALUES;"
+            else
+              fl, vl = [], []
+              values.each {|k, v| fl << field_name(k); vl << literal(v)}
+              "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)});"
             end
-            fl = field_list.join(COMMA_SEPARATOR)
-            vl = value_list.join(COMMA_SEPARATOR)
-            "INSERT INTO #{@opts[:from]} (#{fl}) VALUES (#{vl});"
           when Dataset
             "INSERT INTO #{@opts[:from]} #{literal(values)}"
           else
@@ -454,6 +457,7 @@ module Sequel
           raise SequelError, "Can't update a joined dataset"
         end
 
+        values = transform_save(values) if @transform
         set_list = values.map {|k, v| "#{field_name(k)} = #{literal(v)}"}.
           join(COMMA_SEPARATOR)
         sql = "UPDATE #{@opts[:from]} SET #{set_list}"

data/lib/sequel/model.rb

@@ -1,161 +1,27 @@
 module Sequel
   class Model
-    @@db = nil
-    
-    def self.db
-      @db ||= ((superclass != Object) && (superclass.db)) || nil
-    end
-    def self.db=(db); @db = db; end
-    def self.database_opened(db)
-      @db = db if self == Model && !@db
-    end
-    
-    def self.table_name
-      @table_name ||= ((superclass != Model) && (superclass.table_name)) || nil
-    end
-    def self.set_table_name(t); @table_name = t; end
+  end
+end
 
-    def self.dataset
-      return @dataset if @dataset
-      if !table_name
-        raise SequelError, "Table name not specified for #{self}."
-      elsif !db
-        raise SequelError, "Database not specified for #{self}."
-      end
-      @dataset = db[table_name]
-      @dataset.set_model(self)
-      @dataset
-    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')
 
-    def self.set_dataset(ds)
-      @db = ds.db
-      @dataset = ds
-      @dataset.set_model(self)
-    end
-    
-    def self.cache_by(column, expiration)
-      @cache_column = column
-      
-      prefix = "#{name}.#{column}."
-      define_method(:cache_key) do
-        prefix + @values[column].to_s
-      end
-      
-      define_method("find_by_#{column}".to_sym) do |arg|
-        key = cache_key
-        rec = CACHE[key]
-        if !rec
-          rec = find(column => arg)
-          CACHE.set(key, rec, expiration)
-        end
-        rec
-      end
-      
-      alias_method :destroy, :destroy_and_invalidate_cache
-      alias_method :set, :set_and_update_cache
-    end
-    
-    def self.cache_column
-      @cache_column
-    end
-    
-    def self.primary_key; @primary_key ||= :id; end
-    def self.set_primary_key(k); @primary_key = k; end
-    
-    def self.set_schema(name = nil, &block)
-      name ? set_table_name(name) : name = table_name
-      @schema = Schema::Generator.new(db, name, &block)
-      if @schema.primary_key_name
-        set_primary_key @schema.primary_key_name
-      end
-    end
-    def self.schema
-      @schema || ((superclass != Model) && (superclass.schema))
-    end
-    
-    def self.table_exists?
-      db.table_exists?(table_name)
-    end
-    
-    def self.create_table
-      db.create_table_sql_list(*schema.create_info).each {|s| db << s} 
-    end
-    
-    def self.drop_table
-      db.execute db.drop_table_sql(table_name)
-    end
-    
-    def self.recreate_table
-      drop_table if table_exists?
-      create_table
-    end
-    
+module Sequel
+  class Model
     def self.subset(name, *args, &block)
       meta_def(name) {filter(*args, &block)}
     end
     
-    ONE_TO_ONE_PROC = "proc {i = @values[:%s]; %s[i] if i}".freeze
-    ID_POSTFIX = "_id".freeze
-    FROM_DATASET = "db[%s]".freeze
-    
-    def self.one_to_one(name, opts)
-      klass = opts[:class] ? opts[:class] : (FROM_DATASET % name.inspect)
-      key = opts[:key] || (name.to_s + ID_POSTFIX)
-      define_method name, &eval(ONE_TO_ONE_PROC % [key, klass])
-    end
-  
-    ONE_TO_MANY_PROC = "proc {%s.filter(:%s => @pkey)}".freeze
-    ONE_TO_MANY_ORDER_PROC = "proc {%s.filter(:%s => @pkey).order(%s)}".freeze
-    def self.one_to_many(name, opts)
-      klass = opts[:class] ? opts[:class] :
-        (FROM_DATASET % (opts[:table] || name.inspect))
-      key = opts[:on]
-      order = opts[:order]
-      define_method name, &eval(
-        (order ? ONE_TO_MANY_ORDER_PROC : ONE_TO_MANY_PROC) %
-        [klass, key, order.inspect]
-      )
-    end
-    
-    def self.get_hooks(key)
-      @hooks ||= {}
-      @hooks[key] ||= []
-    end
-    
-    def self.has_hooks?(key)
-      !get_hooks(key).empty?
-    end
-    
-    def run_hooks(key)
-      self.class.get_hooks(key).each {|h| instance_eval(&h)}
-    end
-    
-    def self.before_save(&block)
-      get_hooks(:before_save).unshift(block)
-    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_save(&block)
-      get_hooks(:after_save) << block
-    end
-    
-    def self.after_create(&block)
-      get_hooks(:after_create) << block
-    end
-    
-    def self.after_destroy(&block)
-      get_hooks(:after_destroy) << block
+    def primary_key_hash(value)
+      # stock implementation
+      {:id => value}
     end
     
     def self.find(cond)
-      dataset[cond.is_a?(Hash) ? cond : {primary_key => cond}]
+      dataset[cond.is_a?(Hash) ? cond : primary_key_hash(cond)]
     end
     
     def self.find_or_create(cond)
@@ -166,56 +32,11 @@ module Sequel
     
     ############################################################################
     
-    attr_reader :values, :pkey
-    
-    def model
-      self.class
-    end
-    
-    def primary_key
-      self.class.primary_key
-    end
-    
-    def initialize(values)
-      @values = values
-      @pkey = values[self.class.primary_key]
-    end
-    
-    def exists?
-      model.filter(primary_key => @pkey).count == 1
-    end
-    
-    def refresh
-      @values = self.class.dataset.naked[primary_key => @pkey] ||
-        (raise SequelError, "Record not found")
-      self
-    end
-    
     def self.destroy_all
       has_hooks?(:before_destroy) ? dataset.destroy : dataset.delete
     end
     def self.delete_all; dataset.delete; end
     
-    def self.create(values = nil)
-      db.transaction do
-        obj = new(values || {})
-        obj.save
-        obj
-      end
-    end
-    
-    def destroy
-      db.transaction do
-        run_hooks(:before_destroy)
-        delete
-        run_hooks(:after_destroy)
-      end
-    end
-    
-    def delete
-      model.dataset.filter(primary_key => @pkey).delete
-    end
-    
     FIND_BY_REGEXP = /^find_by_(.*)/.freeze
     FILTER_BY_REGEXP = /^filter_by_(.*)/.freeze
     ALL_BY_REGEXP = /^all_by_(.*)/.freeze
@@ -244,63 +65,18 @@ module Sequel
       dataset.join(*args).select(table_name.to_sym.ALL)
     end
     
-    def db; self.class.db; end
-    
     def [](field); @values[field]; end
     
     def []=(field, value); @values[field] = value; end
     
-    WRITE_ATTR_REGEXP = /(.*)=$/.freeze
-
-    def method_missing(m, value = nil)
-      write = m.to_s =~ WRITE_ATTR_REGEXP
-      att = write ? $1.to_sym : m
-      # raise unless the att is recognized or this is a new unaved record
-      super unless @values.include?(att) || !@pkey
-      
-      write ? (self[att] = value) : self[att]
-    end
-    
     def each(&block); @values.each(&block); end
     def keys; @values.keys; end
     
     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)
-        refresh
-        run_hooks(:after_create)
-      end
-      run_hooks(:after_save)
-    end
-    
     def ==(obj)
       (obj.class == model) && (obj.values == @values)
     end
-    
-    def set(values)
-      model.dataset.filter(primary_key => @pkey).update(values)
-      @values.merge!(values)
-    end
   end
   
-  def self.Model(table)
-    @models ||= {}
-    @models[table] ||= Class.new(Sequel::Model) do
-      meta_def(:inherited) do |c|
-        if table.is_a?(Dataset)
-          c.set_dataset(table)
-        else
-          c.set_table_name(table)
-        end
-      end
-    end
-  end
 end