sequel 0.3.1 → 0.3.2

data/lib/sequel/dbi.rb

@@ -65,7 +65,7 @@ module Sequel
           s = @db.execute sql
           begin
             @columns = s.column_names.map {|c| c.to_sym}
-            s.fetch {|r| r.fields = @columns; yield r}
+            s.fetch {|r| r.keys = @columns; yield r}
           ensure
             s.finish rescue nil
           end

data/lib/sequel/error.rb

@@ -1,10 +1,21 @@
+# Represents an error raised in Sequel code.
 class SequelError < StandardError
 end
 
+# SequelRollbackError is a special error used to rollback a transactions.
+# A transaction block will catch this error and wont pass further up the stack.
 class SequelRollbackError < StandardError
 end
 
+# Object extensions
 class Object
+  # Cancels the current transaction without an error:
+  #
+  #   DB.tranaction do
+  #     ...
+  #     rollback! if failed_to_contact_client
+  #     ...
+  #   end
   def rollback!
     raise SequelRollbackError
   end

data/lib/sequel/model.rb

@@ -79,12 +79,21 @@ module Sequel
   # 
   #   post = Post.create(:title => 'hello world')
   # 
-  # You can also create a new instance and save it:
+  # Another way is to construct a new instance and save it:
   # 
   #   post = Post.new
   #   post.title = 'hello world'
   #   post.save
   # 
+  # You can also supply a block to Model.new and Model.create:
+  # 
+  #   post = Post.create {|p| p.title = 'hello world'}
+  # 
+  #   post = Post.new do |p|
+  #     p.title = 'hello world'
+  #     p.save
+  #   end
+  # 
   # === Hooks
   # 
   # You can execute custom code when creating, updating, or deleting records by using hooks. The before_create and after_create hooks wrap record creation. The before_update and after_update wrap record updating. The before_save and after_save wrap record creation and updating. The before_destroy and after_destroy wrap destruction.
@@ -127,11 +136,14 @@ module Sequel
   #     def posts; Post.filter(:author_id => pk); end
   #   end
   # 
-  # Sequel also provides two macros to assist with common types of associations. The one_to_one macro is roughly equivalent to ActiveRecord's belongs_to macro:
+  # Sequel also provides two macros to assist with common types of associations. The one_to_one macro is roughly equivalent to ActiveRecord?'s belongs_to macro. It defines both getter and setter methods for the association:
   # 
   #   class Post < Sequel::Model(:posts)
   #     one_to_one :author, :from => Author
   #   end
+  #
+  #   post = Post.create(:name => 'hi!')
+  #   post.author = Author[:name => 'Sharon']
   # 
   # The one_to_many macro is roughly equivalent to ActiveRecord's has_many macro:
   # 
@@ -270,24 +282,18 @@ module Sequel
     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.is_dataset_magic_method?(m)
+      method_name = m.to_s
+      Sequel::Dataset::MAGIC_METHODS.each_key do |r|
+        return true if method_name =~ r
+      end
+      false
+    end
+    
     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)
+        if dataset.respond_to?(m) || is_dataset_magic_method?(m)
           instance_eval("def #{m}(*args, &block); dataset.#{m}(*args, &block); end")
         end
       end
@@ -301,12 +307,12 @@ module Sequel
     end
 
     # Returns value of attribute.
-    def [](field)
-      @values[field]
+    def [](column)
+      @values[column]
     end
     # Sets value of attribute.
-    def []=(field, value)
-      @values[field] = value
+    def []=(column, value)
+      @values[column] = value
     end
 
     # Enumerates through all attributes.

data/lib/sequel/model/record.rb

@@ -133,7 +133,7 @@ module Sequel
     #
     # This method guesses whether the record exists when
     # <tt>new_record</tt> is set to false.
-    def initialize(values = {}, new_record = false)
+    def initialize(values = {}, new_record = false, &block)
       @values = values
 
       @new = new_record
@@ -144,6 +144,8 @@ module Sequel
         # we regard this instance as new.
         @new = (k == nil) || (!(Array === k) && !@values[k])
       end
+      
+      block[self] if block
     end
     
     # Returns true if the current instance represents a new record.

data/lib/sequel/mysql.rb

@@ -61,7 +61,7 @@ class Mysql::Result
           row[i] = v.send(t)
         end
       end
-      row.fields = c
+      row.keys = c
       yield row
     end
   end
@@ -173,21 +173,21 @@ module Sequel
     
     class Dataset < Sequel::Dataset
       UNQUOTABLE_FIELD_RE = /^(`(.+)`)|\*$/.freeze
-      def quote_field(f)
+      def quote_column(f)
         (f.nil? || f.empty? || f =~ UNQUOTABLE_FIELD_RE) ? f : "`#{f}`"
       end
       
       FIELD_EXPR_RE = /^([^\(]+\()?([^\.]+\.)?([^\s\)]+)?(\))?(\sAS\s(.+))?$/i.freeze
       FIELD_ORDER_RE = /^(.*) (DESC|ASC)$/i.freeze
-      def quoted_field_name(name)
+      def quoted_column_name(name)
         case name
         when FIELD_EXPR_RE:
           $6 ? \
-            "#{$1}#{$2}#{quote_field($3)}#{$4} AS #{quote_field($6)}" : \
-            "#{$1}#{$2}#{quote_field($3)}#{$4}"
-        when FIELD_ORDER_RE: "#{quote_field($1)} #{$2}"
+            "#{$1}#{$2}#{quote_column($3)}#{$4} AS #{quote_column($6)}" : \
+            "#{$1}#{$2}#{quote_column($3)}#{$4}"
+        when FIELD_ORDER_RE: "#{quote_column($1)} #{$2}"
         else
-          quote_field(name)
+          quote_column(name)
         end
       end
       
@@ -196,7 +196,7 @@ module Sequel
       
       def literal(v)
         case v
-        when LiteralString: quoted_field_name(v)
+        when LiteralString: quoted_column_name(v)
         when String: "'#{v.gsub(/'|\\/, '\&\&')}'"
         when true: TRUE
         when false: FALSE
@@ -223,7 +223,7 @@ module Sequel
         opts = opts ? @opts.merge(opts) : @opts
         
         if order = opts[:order]
-          sql << " ORDER BY #{field_list(order)}"
+          sql << " ORDER BY #{column_list(order)}"
         end
 
         if limit = opts[:limit]

data/lib/sequel/odbc.rb

@@ -105,7 +105,7 @@ module Sequel
       end
       
       def array_tuples_make_row(row)
-        row.fields = @columns
+        row.keys = @columns
         row.each_with_index do |v, idx|
           # When fetching a result set, the Ruby ODBC driver converts all ODBC 
           # SQL types to an equivalent Ruby type; with the exception of

data/lib/sequel/oracle.rb

@@ -14,7 +14,7 @@ module Sequel
       # def auto_increment_sql
       #   AUTO_INCREMENT
       # end
-      # 
+
       def connect
         if @opts[:database]
           dbname = @opts[:host] ? \
@@ -38,7 +38,7 @@ module Sequel
     
       def execute(sql)
         @logger.info(sql) if @logger
-        @pool.hold {|conn| conn.Execute(sql)}
+        @pool.hold {|conn| conn.exec(sql)}
       end
       
       alias_method :do, :execute

data/lib/sequel/postgres.rb

@@ -419,31 +419,30 @@ module Sequel
       @@converters = {}
 
       def row_converter(result)
-        fields = []; translators = []
+        @columns = []; translators = []
         result.fields.each_with_index do |f, idx|
-          fields << f.to_sym
+          @columns << f.to_sym
           translators << PG_TYPES[result.type(idx)]
         end
-        @columns = fields
         
         # create result signature and memoize the converter
-        sig = [fields, translators].hash
+        sig = [@columns, translators].hash
         @@converters_mutex.synchronize do
-          @@converters[sig] ||= compile_converter(fields, translators)
+          @@converters[sig] ||= compile_converter(@columns, translators)
         end
       end
     
-      def compile_converter(fields, translators)
-        used_fields = []
+      def compile_converter(columns, translators)
+        used_columns = []
         kvs = []
-        fields.each_with_index do |field, idx|
-          next if used_fields.include?(field)
-          used_fields << field
+        columns.each_with_index do |column, idx|
+          next if used_columns.include?(column)
+          used_columns << column
         
           if !AUTO_TRANSLATE and translator = translators[idx]
-            kvs << ":\"#{field}\" => ((t = r[#{idx}]) ? t.#{translator} : nil)"
+            kvs << ":\"#{column}\" => ((t = r[#{idx}]) ? t.#{translator} : nil)"
           else
-            kvs << ":\"#{field}\" => r[#{idx}]"
+            kvs << ":\"#{column}\" => r[#{idx}]"
           end
         end
         eval("lambda {|r| {#{kvs.join(COMMA_SEPARATOR)}}}")
@@ -465,28 +464,27 @@ module Sequel
       @@array_tuples_converters = {}
 
       def array_tuples_row_converter(result)
-        fields = []; translators = []
+        @columns = []; translators = []
         result.fields.each_with_index do |f, idx|
-          fields << f.to_sym
+          @columns << f.to_sym
           translators << PG_TYPES[result.type(idx)]
         end
-        @columns = fields
         
         # create result signature and memoize the converter
-        sig = [fields, translators].hash
+        sig = [@columns, translators].hash
         @@array_tuples_converters_mutex.synchronize do
-          @@array_tuples_converters[sig] ||= array_tuples_compile_converter(fields, translators)
+          @@array_tuples_converters[sig] ||= array_tuples_compile_converter(@columns, translators)
         end
       end
     
-      def array_tuples_compile_converter(fields, translators)
+      def array_tuples_compile_converter(columns, translators)
         tr = []
-        fields.each_with_index do |field, idx|
+        columns.each_with_index do |column, idx|
           if !AUTO_TRANSLATE and t = translators[idx]
             tr << "if (v = r[#{idx}]); r[#{idx}] = v.#{t}; end"
           end
         end
-        eval("lambda {|r| r.fields = fields; #{tr.join(';')}; r}")
+        eval("lambda {|r| r.keys = columns; #{tr.join(';')}; r}")
       end
     end
   end

data/lib/sequel/pretty_table.rb

@@ -10,8 +10,8 @@ module Sequel
     def self.records_columns(records)
       columns = []
       records.each do |r|
-        if Array === r && (f = r.fields)
-          return r.fields
+        if Array === r && (k = r.keys)
+          return k
         elsif Hash === r
           r.keys.each {|k| columns << k unless columns.include?(k)}
         end

data/lib/sequel/schema/schema_sql.rb

@@ -60,12 +60,12 @@ module Sequel
       end
     
       def index_definition_sql(table_name, index)
-        fields = index[:columns].join(COMMA_SEPARATOR)
+        columns = index[:columns].join(COMMA_SEPARATOR)
         index_name = index[:name] || default_index_name(table_name, index[:columns])
         if index[:unique]
-          "CREATE UNIQUE INDEX #{index_name} ON #{table_name} (#{fields});"
+          "CREATE UNIQUE INDEX #{index_name} ON #{table_name} (#{columns});"
         else
-          "CREATE INDEX #{index_name} ON #{table_name} (#{fields});"
+          "CREATE INDEX #{index_name} ON #{table_name} (#{columns});"
         end
       end
     

data/lib/sequel/sqlite.rb

@@ -19,6 +19,10 @@ module Sequel
         end
         db = ::SQLite3::Database.new(@opts[:database])
         db.type_translation = true
+        # fix for timestamp translation
+        db.translator.add_translator("timestamp") do |t, v|
+          v =~ /^\d+$/ ? Time.at(v.to_i) : Time.parse(v) 
+        end 
         db
       end
       

data/spec/adapters/mysql_spec.rb

@@ -78,7 +78,7 @@ context "A MySQL dataset" do
     proc {@d.literal(false)}.should_not raise_error
   end
   
-  specify "should quote fields using back-ticks" do
+  specify "should quote columns using back-ticks" do
     @d.select(:name).sql.should == \
       'SELECT `name` FROM items'
       

data/spec/adapters/sqlite_spec.rb

@@ -6,6 +6,7 @@ SQLITE_DB.create_table :items do
   text :name
   float :value
 end
+SQLITE_DB.create_table(:time) {timestamp :t}
 
 context "An SQLite database" do
   setup do
@@ -120,6 +121,13 @@ context "An SQLite database" do
     @db.disconnect
     @db.pool.size.should == 0
   end
+
+  specify "should support timestamps" do
+    t1 = Time.at(Time.now.to_i) #normalize time
+    
+    SQLITE_DB[:time] << {:t => t1}
+    SQLITE_DB[:time].first[:t].should == t1
+  end
 end
 
 context "An SQLite dataset" do

data/spec/core_ext_spec.rb

@@ -127,47 +127,47 @@ context "Symbol#ALL" do
   end
 end
 
-context "Symbol#to_field_name" do
+context "Symbol#to_column_name" do
   specify "should convert qualified symbol notation into dot notation" do
-    :abc__def.to_field_name.should == 'abc.def'
+    :abc__def.to_column_name.should == 'abc.def'
   end
   
   specify "should convert AS symbol notation into SQL AS notation" do
-    :xyz___x.to_field_name.should == 'xyz AS x'
-    :abc__def___x.to_field_name.should == 'abc.def AS x'
+    :xyz___x.to_column_name.should == 'xyz AS x'
+    :abc__def___x.to_column_name.should == 'abc.def AS x'
   end
   
   specify "should support names with digits" do
-    :abc2.to_field_name.should == 'abc2'
-    :xx__yy3.to_field_name.should == 'xx.yy3'
-    :ab34__temp3_4ax.to_field_name.should == 'ab34.temp3_4ax'
-    :x1___y2.to_field_name.should == 'x1 AS y2'
-    :abc2__def3___ggg4.to_field_name.should == 'abc2.def3 AS ggg4'
+    :abc2.to_column_name.should == 'abc2'
+    :xx__yy3.to_column_name.should == 'xx.yy3'
+    :ab34__temp3_4ax.to_column_name.should == 'ab34.temp3_4ax'
+    :x1___y2.to_column_name.should == 'x1 AS y2'
+    :abc2__def3___ggg4.to_column_name.should == 'abc2.def3 AS ggg4'
   end
   
   specify "should support upper case and lower case" do
-    :ABC.to_field_name.should == 'ABC'
-    :Zvashtoy__aBcD.to_field_name.should == 'Zvashtoy.aBcD'
+    :ABC.to_column_name.should == 'ABC'
+    :Zvashtoy__aBcD.to_column_name.should == 'Zvashtoy.aBcD'
     
   end
 end
 
-context "FieldCompositionMethods#field_title" do
-  specify "should return the field name for non aliased fields" do
-    :xyz.field_title.should == 'xyz'
-    :abc__xyz.field_title.should == 'xyz'
+context "FieldCompositionMethods#column_title" do
+  specify "should return the column name for non aliased columns" do
+    :xyz.column_title.should == 'xyz'
+    :abc__xyz.column_title.should == 'xyz'
     
-    'abc'.field_title.should == 'abc'
-    'abc.def'.field_title.should == 'def'
+    'abc'.column_title.should == 'abc'
+    'abc.def'.column_title.should == 'def'
   end
   
-  specify "should return the field alias for aliased fields" do
-    :xyz___x.field_title.should == 'x'
-    :abc__xyz___y.field_title.should == 'y'
+  specify "should return the column alias for aliased columns" do
+    :xyz___x.column_title.should == 'x'
+    :abc__xyz___y.column_title.should == 'y'
     
-    'abc AS x'.field_title.should == 'x'
-    'abc as y'.field_title.should == 'y'
-    'abc.def AS d'.field_title.should == 'd'
+    'abc AS x'.column_title.should == 'x'
+    'abc as y'.column_title.should == 'y'
+    'abc.def AS d'.column_title.should == 'd'
   end
 end