sequel 0.3.2 → 0.3.3

data/CHANGELOG

@@ -1,3 +1,19 @@
+=== 0.3.3 (2007-11-04)
+
+* Revised code to generate SQL statements without trailing semicolons.
+
+* Added Sequel::Worker implementation of a simple worker thread for asynchronous execution.
+
+* Added spec for Oracle adapter.
+
+* Fixed Oracle adapter to format INSERT statements without semicolons (thanks Liming Lian).
+
+* Renamed alias to Array#keys as Array#columns instead of Array#fields.
+
+* Renamed FieldCompositionMethods as ColumnCompositionMethods.
+
+* Implemented Sequel::NumericExtensions to provide stuff like 30.days.ago.
+
 === 0.3.2 (2007-11-01)
 
 * Added #to_column_name as alias to #to_field_name, #column_title as alias to #field_title.

data/Rakefile

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

data/lib/sequel.rb

@@ -2,7 +2,7 @@ require 'metaid'
 
 files = %w[
   core_ext array_keys error connection_pool pretty_table
-  dataset migration model schema database 
+  dataset migration model schema database worker
 ]
 dir = File.join(File.dirname(__FILE__), 'sequel')
 files.each {|f| require(File.join(dir, f))}

data/lib/sequel/array_keys.rb

@@ -183,8 +183,8 @@ module ArrayKeys
       end
     end
  
-    alias_method :fields, :keys
-    alias_method :fields=, :keys=
+    alias_method :columns, :keys
+    alias_method :columns=, :keys=
   end
   
   # The DatasetExtensions module provides extensions that modify

data/lib/sequel/connection_pool.rb

@@ -43,7 +43,7 @@ module Sequel
     # Assigns a connection to the current thread, yielding the connection
     # to the supplied block.
     # 
-    #   pool.hold {|conn| conn.execute('DROP TABLE posts;')}
+    #   pool.hold {|conn| conn.execute('DROP TABLE posts')}
     # 
     # Pool#hold is re-entrant, meaning it can be called recursively in
     # the same thread without blocking.

data/lib/sequel/core_ext.rb

@@ -17,6 +17,14 @@ class Array
   end
 end
 
+# Range extensions
+class Range
+  # Returns the interval between the beginning and end of the range.
+  def interval
+    last - first
+  end
+end
+
 module Sequel
   # LiteralString is used to represent literal SQL expressions. An 
   # LiteralString is copied verbatim into an SQL statement. Instances of
@@ -68,7 +76,7 @@ end
 
 # Methods to format column names and associated constructs. This module is
 # included in String and Symbol.
-module FieldCompositionMethods
+module ColumnCompositionMethods
   # Constructs a DESC clause for use in an ORDER BY clause.
   def DESC
     "#{to_column_name} DESC".lit
@@ -84,14 +92,14 @@ module FieldCompositionMethods
     "#{to_s}.*".lit
   end
   
-  FIELD_TITLE_RE1 = /^(.*)\sAS\s(.+)$/i.freeze
-  FIELD_TITLE_RE2 = /^([^\.]+)\.([^\.]+)$/.freeze
+  COLUMN_TITLE_RE1 = /^(.*)\sAS\s(.+)$/i.freeze
+  COLUMN_TITLE_RE2 = /^([^\.]+)\.([^\.]+)$/.freeze
   
   # Returns the column name. If the column name is aliased, the alias is 
   # returned.
   def field_title
     case s = to_column_name
-    when FIELD_TITLE_RE1, FIELD_TITLE_RE2: $2
+    when COLUMN_TITLE_RE1, COLUMN_TITLE_RE2: $2
     else
       s
     end
@@ -101,17 +109,17 @@ end
 
 # String extensions
 class String
-  include FieldCompositionMethods
+  include ColumnCompositionMethods
 end
 
 # Symbol extensions
 class Symbol
-  include FieldCompositionMethods
+  include ColumnCompositionMethods
   
 
-  FIELD_REF_RE1 = /^(\w+)__(\w+)___(\w+)/.freeze
-  FIELD_REF_RE2 = /^(\w+)___(\w+)$/.freeze
-  FIELD_REF_RE3 = /^(\w+)__(\w+)$/.freeze
+  COLUMN_REF_RE1 = /^(\w+)__(\w+)___(\w+)/.freeze
+  COLUMN_REF_RE2 = /^(\w+)___(\w+)$/.freeze
+  COLUMN_REF_RE3 = /^(\w+)__(\w+)$/.freeze
   
   # Converts a symbol into a column name. This method supports underscore
   # notation in order to express qualified (two underscores) and aliased 
@@ -125,9 +133,9 @@ class Symbol
   def to_field_name
     s = to_s
     case s
-    when FIELD_REF_RE1: "#{$1}.#{$2} AS #{$3}"
-    when FIELD_REF_RE2: "#{$1} AS #{$2}"
-    when FIELD_REF_RE3: "#{$1}.#{$2}"
+    when COLUMN_REF_RE1: "#{$1}.#{$2} AS #{$3}"
+    when COLUMN_REF_RE2: "#{$1} AS #{$2}"
+    when COLUMN_REF_RE3: "#{$1}.#{$2}"
     else
       s
     end
@@ -147,4 +155,37 @@ class Symbol
   end
 end
 
+module Sequel
+  # Facilitates time calculations by providing methods to convert from larger
+  # time units to seconds, and to convert relative time intervals to absolute
+  # ones. This module duplicates some of the functionality provided by Rails'
+  # ActiveSupport::CoreExtensions::Numeric::Time module.
+  module NumericExtensions
+    MINUTE = 60
+    HOUR = 3600
+    DAY = 86400
+    WEEK = DAY * 7
+  
+    # Converts self from minutes to seconds
+    def minutes;  self * MINUTE;  end; alias_method :minute, :minutes
+    # Converts self from hours to seconds
+    def hours;    self * HOUR;    end; alias_method :hour, :hours
+    # Converts self from days to seconds
+    def days;     self * DAY;     end; alias_method :day, :days
+    # Converts self from weeks to seconds
+    def weeks;    self * WEEK;    end; alias_method :week, :weeks
+  
+    # Returns the time at now - self.
+    def ago(t = Time.now); t - self; end
+    alias_method :before, :ago
 
+    # Returns the time at now + self.
+    def from_now(t = Time.now); t + self; end
+    alias_method :since, :from_now
+    
+    # Extends the Numeric class with numeric extensions.
+    def self.enable
+      Numeric.send(:include, self)
+    end
+  end
+end

data/lib/sequel/database.rb

@@ -180,7 +180,7 @@ module Sequel
     
     # Drops one or more tables corresponding to the given table names.
     def drop_table(*names)
-      execute(names.map {|n| drop_table_sql(n)}.join)
+      names.each {|n| execute(drop_table_sql(n))}
     end
     
     # Returns true if the given table exists.

data/lib/sequel/dataset/sql.rb

@@ -438,7 +438,7 @@ module Sequel
       #     'INSERT INTO items (a, b) VALUES (1, 2)'
       def insert_sql(*values)
         if values.empty?
-          "INSERT INTO #{@opts[:from]} DEFAULT VALUES;"
+          "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
         else
           values = values[0] if values.size == 1
           case values
@@ -446,27 +446,27 @@ module Sequel
             insert_sql(values.values)
           when Array
             if values.empty?
-              "INSERT INTO #{@opts[:from]} DEFAULT VALUES;"
-            elsif values.fields
-              fl = values.fields
+              "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
+            elsif values.keys
+              fl = values.keys
               vl = transform_save(values.values).map {|v| literal(v)}
-              "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)});"
+              "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
             else
-              "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)});"
+              "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)})"
             end
           when Hash
             values = transform_save(values) if @transform
             if values.empty?
-              "INSERT INTO #{@opts[:from]} DEFAULT VALUES;"
+              "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
             else
               fl, vl = [], []
               values.each {|k, v| fl << column_name(k); vl << literal(v)}
-              "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)});"
+              "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)});"
+            "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)})"
           end
         end
       end
@@ -484,7 +484,7 @@ module Sequel
           raise SequelError, "Can't update a joined dataset"
         end
 
-        if values.is_a?(Array) && values.fields
+        if values.is_a?(Array) && values.keys
           values = values.to_hash
         end
         values = transform_save(values) if @transform

data/lib/sequel/mysql.rb

@@ -96,9 +96,9 @@ module Sequel
           @opts[:database], @opts[:port])
         conn.query_with_result = false
         if encoding = @opts[:encoding] || @opts[:charset]
-          conn.query("set character_set_connection = '#{encoding}';")
-          conn.query("set character_set_client = '#{encoding}';")
-          conn.query("set character_set_results = '#{encoding}';")
+          conn.query("set character_set_connection = '#{encoding}'")
+          conn.query("set character_set_client = '#{encoding}'")
+          conn.query("set character_set_results = '#{encoding}'")
         end
         conn.reconnect = true
         conn
@@ -172,20 +172,20 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      UNQUOTABLE_FIELD_RE = /^(`(.+)`)|\*$/.freeze
+      UNQUOTABLE_COLUMN_RE = /^(`(.+)`)|\*$/.freeze
       def quote_column(f)
-        (f.nil? || f.empty? || f =~ UNQUOTABLE_FIELD_RE) ? f : "`#{f}`"
+        (f.nil? || f.empty? || f =~ UNQUOTABLE_COLUMN_RE) ? f : "`#{f}`"
       end
       
-      FIELD_EXPR_RE = /^([^\(]+\()?([^\.]+\.)?([^\s\)]+)?(\))?(\sAS\s(.+))?$/i.freeze
-      FIELD_ORDER_RE = /^(.*) (DESC|ASC)$/i.freeze
+      COLUMN_EXPR_RE = /^([^\(]+\()?([^\.]+\.)?([^\s\)]+)?(\))?(\sAS\s(.+))?$/i.freeze
+      COLUMN_ORDER_RE = /^(.*) (DESC|ASC)$/i.freeze
       def quoted_column_name(name)
         case name
-        when FIELD_EXPR_RE:
+        when COLUMN_EXPR_RE:
           $6 ? \
             "#{$1}#{$2}#{quote_column($3)}#{$4} AS #{quote_column($6)}" : \
             "#{$1}#{$2}#{quote_column($3)}#{$4}"
-        when FIELD_ORDER_RE: "#{quote_column($1)} #{$2}"
+        when COLUMN_ORDER_RE: "#{quote_column($1)} #{$2}"
         else
           quote_column(name)
         end

data/lib/sequel/postgres.rb

@@ -284,7 +284,7 @@ module Sequel
       end
 
       def drop_table_sql(name)
-        "DROP TABLE #{name} CASCADE;"
+        "DROP TABLE #{name} CASCADE"
       end
     end
   
@@ -350,7 +350,7 @@ module Sequel
         analysis.join("\r\n")
       end
     
-      LOCK = 'LOCK TABLE %s IN %s MODE;'.freeze
+      LOCK = 'LOCK TABLE %s IN %s MODE'.freeze
     
       ACCESS_SHARE = 'ACCESS SHARE'.freeze
       ROW_SHARE = 'ROW SHARE'.freeze

data/lib/sequel/schema/schema_sql.rb

@@ -63,9 +63,9 @@ module Sequel
         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} (#{columns});"
+          "CREATE UNIQUE INDEX #{index_name} ON #{table_name} (#{columns})"
         else
-          "CREATE INDEX #{index_name} ON #{table_name} (#{columns});"
+          "CREATE INDEX #{index_name} ON #{table_name} (#{columns})"
         end
       end
     
@@ -74,7 +74,7 @@ module Sequel
       end
   
       def create_table_sql_list(name, columns, indexes = nil)
-        sql = ["CREATE TABLE #{name} (#{column_list_sql(columns)});"]
+        sql = ["CREATE TABLE #{name} (#{column_list_sql(columns)})"]
         if indexes && !indexes.empty?
           sql.concat(index_list_sql_list(name, indexes))
         end
@@ -82,7 +82,7 @@ module Sequel
       end
       
       def drop_table_sql(name)
-        "DROP TABLE #{name};"
+        "DROP TABLE #{name}"
       end
     end
   end

data/lib/sequel/sqlite.rb

@@ -61,11 +61,11 @@ module Sequel
       end
       
       def pragma_get(name)
-        single_value("PRAGMA #{name};")
+        single_value("PRAGMA #{name}")
       end
       
       def pragma_set(name, value)
-        execute("PRAGMA #{name} = #{value};")
+        execute("PRAGMA #{name} = #{value}")
       end
       
       AUTO_VACUUM = {'0' => :none, '1' => :full, '2' => :incremental}.freeze
@@ -149,7 +149,7 @@ module Sequel
       def array_tuples_fetch_rows(sql, &block)
         @db.execute_select(sql) do |result|
           @columns = result.columns.map {|c| c.to_sym}
-          result.each(&block)
+          result.each {|r| r.keys = @columns; block[r]}
         end
       end
     

data/lib/sequel/worker.rb

@@ -0,0 +1,44 @@
+require 'thread'
+
+module Sequel
+  class Worker < Thread
+    class WorkerStopError < RuntimeError; end
+  
+    attr_reader :queue
+  
+    def initialize(db = nil)
+      @queue = Queue.new
+      t = self
+      if db
+        super {db.transaction {t.work}}
+      else
+        super {t.work}
+      end
+    end
+  
+    def work
+      begin
+        loop {@cur = @queue.pop; @cur.call; @cur = nil}
+      rescue WorkerStopError # do nothing
+      end
+    end
+    
+    def busy?
+      @cur || !@queue.empty?
+    end
+  
+    def async(proc = nil, &block)
+      @queue << (proc || block)
+    end
+    alias_method :add, :async
+    alias_method :<<, :async
+  
+    def join
+      while busy?
+        sleep 0.1
+      end
+      self.raise WorkerStopError
+      super
+    end
+  end
+end

data/spec/adapters/mysql_spec.rb

@@ -107,7 +107,7 @@ context "A MySQL dataset" do
       'SELECT max(items.`name`) AS `max_name` FROM items'
 
     @d.insert_sql(:value => 333).should == \
-      'INSERT INTO items (`value`) VALUES (333);'
+      'INSERT INTO items (`value`) VALUES (333)'
   end
   
   specify "should support ORDER clause in UPDATE statements" do

data/spec/adapters/oracle_spec.rb

@@ -0,0 +1,130 @@
+require File.join(File.dirname(__FILE__), '../../lib/sequel/oracle')
+
+ORACLE_DB = Sequel('oracle://hr:hr@loalhost/XE')
+if ORACLE_DB.table_exists?(:test)
+  ORACLE_DB.drop_table :test
+end
+ORACLE_DB.create_table :test do
+  text :name
+  integer :value
+  
+  index :value
+end
+
+context "A Oracle database" do
+  specify "should provide disconnect functionality" do
+    ORACLE_DB.execute("select user from dual")
+    ORACLE_DB.pool.size.should == 1
+    ORACLE_DB.disconnect
+    ORACLE_DB.pool.size.should == 0
+  end
+end
+
+context "A Oracle dataset" do
+  setup do
+    @d = ORACLE_DB[:test]
+    @d.delete # remove all records
+  end
+  
+  specify "should return the correct record count" do
+    @d.count.should == 0
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.count.should == 3
+  end
+  
+  specify "should return the correct records" do
+    @d.to_a.should == []
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+
+    @d.order(:value).to_a.should == [
+      {:name => 'abc', :value => 123},
+      {:name => 'abc', :value => 456},
+      {:name => 'def', :value => 789}
+    ]
+  end
+  
+  specify "should update records correctly" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.filter(:name => 'abc').update(:value => 530)
+    
+    # the third record should stay the same
+    # floating-point precision bullshit
+    @d[:name => 'def'][:value].should == 789
+    @d.filter(:value => 530).count.should == 2
+  end
+  
+  specify "should delete records correctly" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.filter(:name => 'abc').delete
+    
+    @d.count.should == 1
+    @d.first[:name].should == 'def'
+  end
+  
+  specify "should be able to literalize booleans" do
+    proc {@d.literal(true)}.should_not raise_error
+    proc {@d.literal(false)}.should_not raise_error
+  end
+  
+  specify "should support transactions" do
+    ORACLE_DB.transaction do
+      @d << {:name => 'abc', :value => 1}
+    end
+
+    @d.count.should == 1
+  end
+end
+
+context "A Oracle dataset in array tuples mode" do
+  setup do
+    @d = ORACLE_DB[:test]
+    @d.delete # remove all records
+    Sequel.use_array_tuples
+  end
+  
+  teardown do
+    Sequel.use_hash_tuples
+  end
+  
+  specify "should return the correct records" do
+    @d.to_a.should == []
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+
+    @d.order(:value).select(:name, :value).to_a.should == [
+      ['abc', 123],
+      ['abc', 456],
+      ['def', 789]
+    ]
+  end
+  
+  specify "should work correctly with transforms" do
+    @d.transform(:value => [proc {|v| v.to_s}, proc {|v| v.to_i}])
+
+    @d.to_a.should == []
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+
+    @d.order(:value).select(:name, :value).to_a.should == [
+      ['abc', '123'],
+      ['abc', '456'],
+      ['def', '789']
+    ]
+    
+    a = @d.order(:value).first
+    a.values.should == ['abc', '123']
+    a.keys.should == [:name, :value]
+    a[:name].should == 'abc'
+    a[:value].should == '123'
+  end
+end