sequel 0.3.0.1 → 0.3.1

data/lib/sequel/model/record.rb

@@ -28,7 +28,9 @@ module Sequel
     # <i>You can even set it to nil!</i>
     def self.set_primary_key(*key)
       # if k is nil, we go to no_primary_key
-      return no_primary_key unless key
+      if key.empty? || (key.size == 1 && key.first == nil)
+        return no_primary_key
+      end
       
       # backwards compat
       key = (key.length == 1) ? key[0] : key.flatten
@@ -40,6 +42,12 @@ module Sequel
         class_def(:this) do
           @this ||= dataset.filter(key => @values[key]).limit(1).naked
         end
+        class_def(:pk) do
+          @pk ||= @values[key]
+        end
+        class_def(:pk_hash) do
+          @pk ||= {key => @values[key]}
+        end
         class_def(:cache_key) do
           pk = @values[key] || (raise SequelError, 'no primary key for this record')
           @cache_key ||= "#{self.class}:#{pk}"
@@ -52,6 +60,14 @@ module Sequel
         block = eval("proc {@this ||= self.class.dataset.filter(#{exp_list.join(',')}).limit(1).naked}")
         class_def(:this, &block)
         
+        exp_list = key.map {|k| "@values[#{k.inspect}]"}
+        block = eval("proc {@pk ||= [#{exp_list.join(',')}]}")
+        class_def(:pk, &block)
+        
+        exp_list = key.map {|k| "#{k.inspect} => @values[#{k.inspect}]"}
+        block = eval("proc {@this ||= {#{exp_list.join(',')}}}")
+        class_def(:pk_hash, &block)
+        
         exp_list = key.map {|k| '#{@values[%s]}' % k.inspect}.join(',')
         block = eval('proc {@cache_key ||= "#{self.class}:%s"}' % exp_list)
         class_def(:cache_key, &block)
@@ -65,7 +81,9 @@ module Sequel
     def self.no_primary_key #:nodoc:
       meta_def(:primary_key) {nil}
       meta_def(:primary_key_hash) {|v| raise SequelError, "#{self} does not have a primary key"}
-      class_def(:this) {raise SequelError, "No primary key is associated with this model"}
+      class_def(:this)      {raise SequelError, "No primary key is associated with this model"}
+      class_def(:pk)        {raise SequelError, "No primary key is associated with this model"}
+      class_def(:pk_hash)   {raise SequelError, "No primary key is associated with this model"}
       class_def(:cache_key) {raise SequelError, "No primary key is associated with this model"}
     end
     
@@ -97,7 +115,18 @@ module Sequel
     
     # Returns value for primary key.
     def pkey
-      @pkey ||= @values[primary_key]
+      warn "Model#pkey is deprecated. Please use Model#pk instead."
+      @pkey ||= @values[self.class.primary_key]
+    end
+    
+    # Returns the primary key value identifying the model instance. Stock implementation.
+    def pk
+      @pk ||= @values[:id]
+    end
+    
+    # Returns a hash identifying the model instance. Stock implementation.
+    def pk_hash
+      @pk_hash ||= {:id => @values[:id]}
     end
     
     # Creates new instance with values set to passed-in Hash.
@@ -109,11 +138,11 @@ module Sequel
 
       @new = new_record
       unless @new # determine if it's a new record
-        pk = primary_key
+        k = self.class.primary_key
         # if there's no primary key for the model class, or
         # @values doesn't contain a primary key value, then 
         # we regard this instance as new.
-        @new = (pk == nil) || (!(Array === pk) && !@values[pk])
+        @new = (k == nil) || (!(Array === k) && !@values[k])
       end
     end
     
@@ -187,8 +216,14 @@ module Sequel
         att = $1.to_sym
         write = $2 == '='
         
-        # check wether the column is legal
+        # check whether the column is legal
         unless columns.include?(att)
+          # if read accessor and a value exists for the column, we return it
+          if !write && @values.has_key?(att)
+            return @values[att]
+          end
+          
+          # otherwise, raise an error
           raise SequelError, "Invalid column (#{att.inspect}) for #{self}"
         end
 

data/lib/sequel/model/relations.rb

@@ -1,31 +1,107 @@
-# TODO: refactoring...
 module Sequel
   class Model
-
-    ONE_TO_ONE_PROC = "proc {i = @values[:%s]; %s[i] if i}".freeze
-    ID_POSTFIX = "_id".freeze
-    FROM_DATASET = "db[%s]".freeze
+    ID_POSTFIX = '_id'.freeze
     
-    # Comprehensive description goes here!
+    # Creates a 1-1 relationship by defining an association method, e.g.:
+    # 
+    #   class Session < Sequel::Model(:sessions)
+    #   end
+    #
+    #   class Node < Sequel::Model(:nodes)
+    #     one_to_one :producer, :from => Session
+    #     # which is equivalent to
+    #     def producer
+    #       Session[producer_id] if producer_id
+    #     end
+    #   end
+    #
+    # You can also set the foreign key explicitly by including a :key option:
+    #
+    #   one_to_one :producer, :from => Session, :key => :producer_id
+    #
+    # The one_to_one macro also creates a setter, which accepts nil, a hash or
+    # a model instance, e.g.:
+    #
+    #   p = Producer[1234]
+    #   node = Node[:path => '/']
+    #   node.producer = p
+    #   node.producer_id #=> 1234
+    #
     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])
+      # deprecation
+      if opts[:class]
+        warn "The :class option has been deprecated. Please use :from instead."
+        opts[:from] = opts[:class]
+      end
+      
+      from = opts[:from]
+      from || (raise SequelError, "No association source defined (use :from option)")
+      key = opts[:key] || (name.to_s + ID_POSTFIX).to_sym
+      
+      setter_name = "#{name}=".to_sym
+      
+      case from
+      when Symbol
+        class_def(name) {(k = @values[key]) ? db[from][:id => k] : nil}
+      when Sequel::Dataset
+        class_def(name) {(k = @values[key]) ? from[:id => k] : nil}
+      else
+        class_def(name) {(k = @values[key]) ? from[k] : nil}
+      end
+      class_def(setter_name) do |v|
+        case v
+        when nil
+          set(key => nil)
+        when Sequel::Model
+          set(key => v.pk)
+        when Hash
+          set(key => v[:id])
+        end
+      end
+
+      # define_method name, &eval(ONE_TO_ONE_PROC % [key, from])
     end
   
-    ONE_TO_MANY_PROC = "proc {%s.filter(:%s => pkey)}".freeze
-    ONE_TO_MANY_ORDER_PROC = "proc {%s.filter(:%s => pkey).order(%s)}".freeze
-
-    # Comprehensive description goes here!
+    # Creates a 1-N relationship by defining an association method, e.g.:
+    # 
+    #   class Book < Sequel::Model(:books)
+    #   end
+    #
+    #   class Author < Sequel::Model(:authors)
+    #     one_to_many :books, :from => Book
+    #     # which is equivalent to
+    #     def books
+    #       Book.filter(:author_id => id)
+    #     end
+    #   end
+    #
+    # You can also set the foreign key explicitly by including a :key option:
+    #
+    #   one_to_many :books, :from => Book, :key => :author_id
+    #
     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]
-      )
+      # deprecation
+      if opts[:class]
+        warn "The :class option has been deprecated. Please use :from instead."
+        opts[:from] = opts[:class]
+      end
+      # deprecation
+      if opts[:on]
+        warn "The :on option has been deprecated. Please use :key instead."
+        opts[:key] = opts[:on]
+      end
+      
+      
+      from = opts[:from]
+      from || (raise SequelError, "No association source defined (use :from option)")
+      key = opts[:key] || (self.to_s + ID_POSTFIX).to_sym
+      
+      case from
+      when Symbol
+        class_def(name) {db[from].filter(key => pk)}
+      else
+        class_def(name) {from.filter(key => pk)}
+      end
     end
   end
 end

data/lib/sequel/mysql.rb

@@ -197,6 +197,7 @@ module Sequel
       def literal(v)
         case v
         when LiteralString: quoted_field_name(v)
+        when String: "'#{v.gsub(/'|\\/, '\&\&')}'"
         when true: TRUE
         when false: FALSE
         else

data/lib/sequel/oracle.rb

@@ -0,0 +1,109 @@
+if !Object.const_defined?('Sequel')
+  require File.join(File.dirname(__FILE__), '../sequel')
+end
+
+require 'oci8'
+
+module Sequel
+  module Oracle
+    class Database < Sequel::Database
+      set_adapter_scheme :oracle
+      
+      # AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
+      # 
+      # def auto_increment_sql
+      #   AUTO_INCREMENT
+      # end
+      # 
+      def connect
+        if @opts[:database]
+          dbname = @opts[:host] ? \
+            "//#{@opts[:host]}/#{@opts[:database]}" : @opts[:database]
+        else
+          dbname = @opts[:host]
+        end
+        conn = OCI8.new(@opts[:user], @opts[:password], dbname, @opts[:privilege])
+        conn.autocommit = true
+        conn.non_blocking = true
+        conn
+      end
+      
+      def disconnect
+        @pool.disconnect {|c| c.logoff}
+      end
+    
+      def dataset(opts = nil)
+        Oracle::Dataset.new(self, opts)
+      end
+    
+      def execute(sql)
+        @logger.info(sql) if @logger
+        @pool.hold {|conn| conn.Execute(sql)}
+      end
+      
+      alias_method :do, :execute
+    end
+    
+    class Dataset < Sequel::Dataset
+      def literal(v)
+        case v
+        when Time: literal(v.iso8601)
+        else
+          super
+        end
+      end
+
+      def fetch_rows(sql, &block)
+        @db.synchronize do
+          cursor = @db.execute sql
+          begin
+            @columns = cursor.get_col_names.map {|c| c.to_sym}
+            while r = cursor.fetch
+              row = {}
+              r.each_with_index {|v, i| row[columns[i]] = v}
+              yield row
+            end
+          ensure
+            cursor.close
+          end
+        end
+        self
+      end
+      
+      def hash_row(row)
+        @columns.inject({}) do |m, c|
+          m[c] = row.shift
+          m
+        end
+      end
+    
+      def array_tuples_fetch_rows(sql, &block)
+        @db.synchronize do
+          cursor = @db.execute sql
+          begin
+            @columns = cursor.get_col_names.map {|c| c.to_sym}
+            while r = cursor.fetch
+              r.keys = columns
+              yield r
+            end
+          ensure
+            cursor.close
+          end
+        end
+        self
+      end
+      
+      def insert(*values)
+        @db.do insert_sql(*values)
+      end
+    
+      def update(values, opts = nil)
+        @db.do update_sql(values, opts)
+      end
+    
+      def delete(opts = nil)
+        @db.do delete_sql(opts)
+      end
+    end
+  end
+end

data/lib/sequel/postgres.rb

@@ -137,6 +137,13 @@ module Sequel
       1114 => :to_time
     }
 
+    if PGconn.respond_to?(:translate_results=)
+      PGconn.translate_results = true
+      AUTO_TRANSLATE = true
+    else
+      AUTO_TRANSLATE = false
+    end
+
     class Database < Sequel::Database
       set_adapter_scheme :postgres
     
@@ -433,7 +440,7 @@ module Sequel
           next if used_fields.include?(field)
           used_fields << field
         
-          if translator = translators[idx]
+          if !AUTO_TRANSLATE and translator = translators[idx]
             kvs << ":\"#{field}\" => ((t = r[#{idx}]) ? t.#{translator} : nil)"
           else
             kvs << ":\"#{field}\" => r[#{idx}]"
@@ -475,7 +482,7 @@ module Sequel
       def array_tuples_compile_converter(fields, translators)
         tr = []
         fields.each_with_index do |field, idx|
-          if t = translators[idx]
+          if !AUTO_TRANSLATE and t = translators[idx]
             tr << "if (v = r[#{idx}]); r[#{idx}] = v.#{t}; end"
           end
         end

data/lib/sequel/schema/schema_sql.rb

@@ -40,7 +40,10 @@ module Sequel
         sql << NOT_NULL if column[:null] == false
         sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
         sql << PRIMARY_KEY if column[:primary_key]
-        sql << " REFERENCES #{column[:table]}" if column[:table]
+        if column[:table]
+          sql << " REFERENCES #{column[:table]}"
+          sql << "(#{column[:key]})" if column[:key]
+        end
         sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
         sql << " #{auto_increment_sql}" if column[:auto_increment]
         sql

data/spec/adapters/mysql_spec.rb

@@ -134,6 +134,13 @@ context "A MySQL dataset" do
     @d.filter(:name => /bc/).count.should == 2
     @d.filter(:name => /^bc/).count.should == 1
   end
+  
+  specify "should correctly literalize strings with comment backslashes in them" do
+    @d.delete
+    proc {@d << {:name => ':\\'}}.should_not raise_error
+    
+    @d.first[:name].should == ':\\'
+  end
 end
 
 context "A MySQL dataset in array tuples mode" do

data/spec/adapters/sqlite_spec.rb

@@ -264,9 +264,9 @@ context "An SQLite dataset in array tuples mode" do
     @d << {:name => 'abc', :value => 4.56}
     @d << {:name => 'def', :value => 7.89}
     @d.select(:name, :value).to_a.sort_by {|h| h[:value]}.should == [
-      Array.from_hash({:name => 'abc', :value => 1.23}),
-      Array.from_hash({:name => 'abc', :value => 4.56}),
-      Array.from_hash({:name => 'def', :value => 7.89})
+      ['abc', 1.23],
+      ['abc', 4.56],
+      ['def', 7.89]
     ]
   end
 end  

data/spec/array_keys_spec.rb

@@ -28,7 +28,7 @@ context "An array with symbol keys" do
     @a.keys.should == [:a, :b, :c, :d]
   end
   
-  specify "should provide key acess using strings" do
+  specify "should provide key access using strings" do
     @a['a'].should == 1
     @a['A'].should be_nil
     
@@ -280,7 +280,7 @@ context "An array with string keys" do
     @a.keys.should == ['a', 'b', 'c', :d]
   end
 
-  specify "should provide key acess using strings" do
+  specify "should provide key access using strings" do
     @a['a'].should == 1
     @a['A'].should be_nil
 

data/spec/connection_pool_spec.rb

@@ -205,7 +205,7 @@ context "A connection pool with a max size of 5" do
     @pool = Sequel::ConnectionPool.new(5) {@invoked_count += 1}
   end
   
-  specify "should let five threads simulatneously access separate connections" do
+  specify "should let five threads simultaneously access separate connections" do
     cc = {}
     threads = []
     stop = nil