sequel 0.1.8 → 0.1.9

data/CHANGELOG

@@ -1,3 +1,27 @@
+=== 0.1.9 (2007-07-21)
+
+* Fixed #update_sql and #insert_sql to support field quoting by calling #field_name.
+
+* Implemented automatic data type conversion in mysql adapter.
+
+* Added support for boolean literals in mysql adapter.
+
+* Added support for ORDER and LIMIT clauses in UPDATE statements in mysql adapter.
+
+* Implemented correct field quoting (using back-ticks) in mysql adapter.
+
+* Wrote basic MySQL spec.
+
+* Fixd MySQL::Dataset to return correct data types with symbols as hash keys.
+
+* Removed discunctional MySQL::Database#transaction.
+
+* Added support for single threaded operation.
+
+* Fixed bug in Dataset#format_eq_expression where Range objects would not be literalized correctly.
+
+* Added parens around postgres LIKE expressions using regexps.
+
 === 0.1.8 (2007-07-10)
 
 * Implemented Dataset#columns for retrieving the columns in the result set.

data/README

@@ -32,7 +32,7 @@ Sequel currently supports:
 * SQLite 3
 * DBI
 * ODBC
-* MySQL (basic support)
+* MySQL
 
 == The Sequel Console
 

data/Rakefile

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

data/lib/sequel/core_ext.rb

@@ -38,6 +38,11 @@ class String
   def expr
     Sequel::ExpressionString.new(self)
   end
+  
+  # Convert a string into a Time object
+  def to_time
+    Time.parse(self)
+  end
 end
 
 # Symbol extensions

data/lib/sequel/database.rb

@@ -5,6 +5,25 @@ require File.join(File.dirname(__FILE__), 'dataset')
 require File.join(File.dirname(__FILE__), 'model')
 
 module Sequel
+  # A SingleThreadedPool acts as a replacement for a ConnectionPool for use
+  # in single-threaded applications. ConnectionPool imposes a substantial
+  # performance penalty, so SingleThreadedPool is used to gain some speed.
+  class SingleThreadedPool
+    attr_writer :connection_proc
+    
+    def initialize(&block)
+      @connection_proc = block
+    end
+    
+    def hold
+      @conn ||= @connection_proc.call
+      yield @conn
+    rescue Exception => e
+      # if the error is not a StandardError it is converted into RuntimeError.
+      raise e.is_a?(StandardError) ? e : e.message
+    end
+  end
+  
   # A Database object represents a virtual connection to a database.
   # The Database class is meant to be subclassed by database adapters in order
   # to provide the functionality needed for executing queries.
@@ -18,15 +37,32 @@ module Sequel
     def initialize(opts = {}, &block)
       Model.database_opened(self)
       @opts = opts
-      @pool = ConnectionPool.new(@opts[:max_connections] || 4, &block)
-      @logger = opts[:logger]
+      
+      # Determine if the DB is single threaded or multi threaded
+      @single_threaded = opts[:single_threaded] || @@single_threaded
+      # Construct pool
+      if @single_threaded
+        @pool = SingleThreadedPool.new(&block)
+      else
+        @pool = ConnectionPool.new(opts[:max_connections] || 4, &block)
+      end
       @pool.connection_proc = block || proc {connect}
+
+      @logger = opts[:logger]
     end
     
     def connect
       raise NotImplementedError, "#connect should be overriden by adapters"
     end
     
+    def multi_threaded?
+      !@single_threaded
+    end
+    
+    def single_threaded?
+      @single_threaded
+    end
+    
     def uri
       uri = URI::Generic.new(
         self.class.adapter_scheme.to_s,
@@ -188,6 +224,12 @@ module Sequel
       raise SequelError, "Invalid database scheme" unless c
       c.new(c.uri_to_options(uri).merge(more_opts || {}))
     end
+    
+    @@single_threaded = false
+    
+    def self.single_threaded=(value)
+      @@single_threaded = value
+    end
   end
 end
 

data/lib/sequel/dataset/dataset_convenience.rb

@@ -12,7 +12,8 @@ module Sequel
       # Returns the first value of the first reecord in the dataset.
       def single_value(opts = nil)
         opts = opts ? NAKED_HASH.merge(opts) : NAKED_HASH
-        each(opts) {|r| return r.values.first}
+        # reset the columns cache so it won't fuck subsequent calls to columns
+        each(opts) {|r| @columns = nil; return r.values.first}
       end
 
       # Returns the first record in the dataset. If the num argument is specified,

data/lib/sequel/dataset/dataset_sql.rb

@@ -96,8 +96,8 @@ module Sequel
         case right
         when Range:
           right.exclude_end? ? \
-            "(#{left} >= #{right.begin} AND #{left} < #{right.end})" : \
-            "(#{left} >= #{right.begin} AND #{left} <= #{right.end})"
+            "(#{left} >= #{literal(right.begin)} AND #{left} < #{literal(right.end)})" : \
+            "(#{left} >= #{literal(right.begin)} AND #{left} <= #{literal(right.end)})"
         when Array:
           "(#{left} IN (#{literal(right)}))"
         when Dataset:
@@ -464,7 +464,7 @@ module Sequel
           field_list = []
           value_list = []
           values[0].each do |k, v|
-            field_list << k
+            field_list << field_name(k)
             value_list << literal(v)
           end
           fl = field_list.join(COMMA_SEPARATOR)
@@ -488,7 +488,7 @@ module Sequel
           raise SequelError, "Can't update a joined dataset"
         end
 
-        set_list = values.map {|k, v| "#{k} = #{literal(v)}"}.
+        set_list = values.map {|k, v| "#{field_name(k)} = #{literal(v)}"}.
           join(COMMA_SEPARATOR)
         sql = "UPDATE #{@opts[:from]} SET #{set_list}"
 

data/lib/sequel/mysql.rb

@@ -4,21 +4,74 @@ end
 
 require 'mysql'
 
+# Monkey patch Mysql::Result to yield hashes with symbol keys
+class Mysql::Result
+  MYSQL_TYPES = {
+    0 => :to_i,
+    1 => :to_i,
+    2 => :to_i,
+    3 => :to_i,
+    4 => :to_f,
+    5 => :to_f,
+    7 => :to_time,
+    8 => :to_i,
+    9 => :to_i,
+    10 => :to_time,
+    11 => :to_time,
+    12 => :to_time,
+    13 => :to_i,
+    14 => :to_time,
+    247 => :to_i,
+    248 => :to_i
+  }
+  
+  def convert_type(v, type)
+    v ? ((t = MYSQL_TYPES[type]) ? v.send(t) : v) : nil
+  end
+  
+  def columns(with_table = nil)
+    unless @columns
+      @column_types = []
+      @columns = fetch_fields.map do |f|
+        @column_types << f.type
+        (with_table ? (f.table + "." + f.name) : f.name).to_sym
+      end
+    end
+    @columns
+  end
+  
+  def each_hash(with_table=nil)
+    c = columns
+    while row = fetch_row
+      h = {}
+      c.each_with_index {|f, i| h[f] = convert_type(row[i], @column_types[i])}
+      yield h
+    end
+  end
+end
+
 module Sequel
   module MySQL
-
     class Database < Sequel::Database
       set_adapter_scheme :mysql
     
       def connect
-        Mysql.real_connect(@opts[:host], @opts[:user], @opts[:password], 
+        conn = Mysql.real_connect(@opts[:host], @opts[:user], @opts[:password], 
           @opts[:database], @opts[:port])
+        conn.query_with_result = false
+        conn
+      end
+      
+      def tables
+        @pool.hold do |conn|
+          conn.list_tables.map {|t| t.to_sym}
+        end
       end
     
       def dataset(opts = nil)
         MySQL::Dataset.new(self, opts)
       end
-    
+      
       def execute(sql)
         @logger.info(sql) if @logger
         @pool.hold do |conn|
@@ -26,6 +79,14 @@ module Sequel
         end
       end
       
+      def query(sql)
+        @logger.info(sql) if @logger
+        @pool.hold do |conn|
+          conn.query(sql)
+          conn.use_result
+        end
+      end
+      
       def execute_insert(sql)
         @logger.info(sql) if @logger
         @pool.hold do |conn|
@@ -41,13 +102,69 @@ module Sequel
           conn.affected_rows
         end
       end
-    
-      def transaction(&block)
-        @pool.hold {|conn| conn.transaction(&block)}
+
+      def transaction
+        @pool.hold do |conn|
+          @transactions ||= []
+          if @transactions.include? Thread.current
+            return yield(conn)
+          end
+          conn.query(SQL_BEGIN)
+          begin
+            @transactions << Thread.current
+            result = yield(conn)
+            conn.query(SQL_COMMIT)
+            result
+          rescue => e
+            conn.query(SQL_ROLLBACK)
+            raise e
+          ensure
+            @transactions.delete(Thread.current)
+          end
+        end
       end
     end
     
     class Dataset < Sequel::Dataset
+      def field_name(field)
+        f = field.is_a?(Symbol) ? field.to_field_name : field
+        if f =~ /^(([^\(]*)\(\*\))|\*$/
+          f
+        elsif f =~ /^([^\(]*)\(([^\*\)]*)\)$/
+          "#{$1}(`#{$2}`)"
+        elsif f =~ /^(.*) (DESC|ASC)$/
+          "`#{$1}` #{$2}"
+        else
+          "`#{f}`"
+        end
+      end
+
+      def literal(v)
+        case v
+        when true: '1'
+        when false: '0'
+        else
+          super
+        end
+      end
+      
+      # MySQL supports ORDER and LIMIT clauses in UPDATE statements.
+      def update_sql(values, opts = nil)
+        sql = super
+
+        opts = opts ? @opts.merge(opts) : @opts
+        
+        if order = opts[:order]
+          sql << " ORDER BY #{field_list(order)}"
+        end
+
+        if limit = opts[:limit]
+          sql << " LIMIT #{limit}"
+        end
+
+        sql
+      end
+
       def insert(*values)
         @db.execute_insert(insert_sql(*values))
       end
@@ -62,20 +179,16 @@ module Sequel
       
       def fetch_rows(sql)
         @db.synchronize do
-          result = @db.execute(sql)
+          r = @db.query(sql)
           begin
-            fetch_columns(result)
-            result.each_hash {|r| yield r}
+            @columns = r.columns
+            r.each_hash {|row| yield row}
           ensure
-            result.free
+            r.free
           end
         end
         self
       end
-      
-      def fetch_columns(result)
-        @columns = result.fetch_fields.map {|c| c.name.to_sym}
-      end
     end
   end
 end

data/lib/sequel/postgres.rb

@@ -122,10 +122,6 @@ class String
       nil
     end
   end
-
-  def postgres_to_time
-    Time.parse(self)
-  end
 end
 
 module Sequel
@@ -138,7 +134,7 @@ module Sequel
       23 => :to_i,
       700 => :to_f,
       701 => :to_f,
-      1114 => :postgres_to_time
+      1114 => :to_time
     }
 
     class Database < Sequel::Database
@@ -272,9 +268,6 @@ module Sequel
     end
   
     class Dataset < Sequel::Dataset
-      TRUE = "'t'".freeze
-      FALSE = "'f'".freeze
-      
       def literal(v)
         case v
         when String, Fixnum, Float, TrueClass, FalseClass: PGconn.quote(v)
@@ -283,14 +276,17 @@ module Sequel
         end
       end
     
-      LIKE = '%s ~ %s'.freeze
+      LIKE = '(%s ~ %s)'.freeze
       LIKE_CI = '%s ~* %s'.freeze
       
       def format_eq_expression(left, right)
         case right
         when Regexp:
-          (right.casefold? ? LIKE_CI : LIKE) %
-            [field_name(left), PGconn.quote(right.source)]
+          l = field_name(left)
+          r = PGconn.quote(right.source)
+          right.casefold? ? \
+            "(#{l} ~* #{r})" : \
+            "(#{l} ~ #{r})"
         else
           super
         end

data/spec/adapters/mysql_spec.rb

@@ -0,0 +1,105 @@
+require File.join(File.dirname(__FILE__), '../../lib/sequel/mysql')
+
+MYSQL_DB = Sequel('mysql://root@localhost/sandbox')
+if MYSQL_DB.table_exists?(:items)
+  MYSQL_DB.drop_table :items
+end
+MYSQL_DB.create_table :items do
+  text :name
+  integer :value
+end
+
+context "A MySQL dataset" do
+  setup do
+    @d = MYSQL_DB[:items]
+    @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 last inserted id when inserting records" do
+  #   id = @d << {:name => 'abc', :value => 1.23}
+  #   id.should == @d.first[:id]
+  # end
+  #
+  
+  specify "should return all records" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    
+    @d.order(:value).all.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 quote fields using back-ticks" do
+    @d.select(:name).sql.should == \
+      'SELECT `name` FROM items'
+      
+    @d.select('COUNT(*)').sql.should == \
+      'SELECT COUNT(*) FROM items'
+
+    @d.select(:value.MAX).sql.should == \
+      'SELECT max(`value`) FROM items'
+
+    @d.order(:name.DESC).sql.should == \
+      'SELECT * FROM items ORDER BY `name` DESC'
+      
+    @d.insert_sql(:value => 333).should == \
+      'INSERT INTO items (`value`) VALUES (333)'
+  end
+  
+  specify "should support ORDER clause in UPDATE statements" do
+    @d.order(:name).update_sql(:value => 1).should == \
+      'UPDATE items SET `value` = 1 ORDER BY `name`'
+  end
+  
+  specify "should support LIMIT clause in UPDATE statements" do
+    @d.limit(10).update_sql(:value => 1).should == \
+      'UPDATE items SET `value` = 1 LIMIT 10'
+  end
+  
+  specify "should support transactions" do
+    MYSQL_DB.transaction do
+      @d << {:name => 'abc', :value => 1}
+    end
+
+    @d.count.should == 1
+  end
+end

data/spec/core_ext_spec.rb

@@ -71,6 +71,13 @@ context "String#split_sql" do
   end
 end
 
+context "String#to_time" do
+  specify "should convert the string into a Time object" do
+    "2007-07-11".to_time.should == Time.parse("2007-07-11")
+    "06:30".to_time.should == Time.parse("06:30")
+  end
+end
+
 context "Symbol#DESC" do
   specify "should append the symbol with DESC" do
     :hey.DESC.should == 'hey DESC'

data/spec/database_spec.rb

@@ -363,4 +363,83 @@ context "Database#uri_to_options" do
     h[:port].should == 1234
     h[:database].should == 'blah'
   end
+end
+
+context "A single threaded database" do
+  teardown do
+    Sequel::Database.single_threaded = false
+  end
+  
+  specify "should use a SingleThreadedPool instead of a ConnectionPool" do
+    db = Sequel::Database.new(:single_threaded => true)
+    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+  end
+  
+  specify "should be constructable using :single_threaded => true option" do
+    db = Sequel::Database.new(:single_threaded => true)
+    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+  end
+  
+  specify "should be constructable using Database.single_threaded = true" do
+    Sequel::Database.single_threaded = true
+    db = Sequel::Database.new
+    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
+  end
+end
+
+context "A single threaded database" do
+  setup do
+    conn = 1234567
+    @db = Sequel::Database.new(:single_threaded => true) do
+      conn += 1
+    end
+  end
+  
+  specify "should invoke connection_proc only once" do
+    @db.pool.hold {|c| c.should == 1234568}
+    @db.pool.hold {|c| c.should == 1234568}
+  end
+  
+  specify "should convert an Exception into a RuntimeError" do
+    db = Sequel::Database.new(:single_threaded => true) do
+      raise Exception
+    end
+    
+    proc {db.pool.hold {|c|}}.should raise_error(RuntimeError)
+  end
+end
+
+context "A database" do
+  setup do
+    Sequel::Database.single_threaded = false
+  end
+  
+  teardown do
+    Sequel::Database.single_threaded = false
+  end
+  
+  specify "should be either single_threaded? or multi_threaded?" do
+    db = Sequel::Database.new(:single_threaded => true)
+    db.should be_single_threaded
+    db.should_not be_multi_threaded
+    
+    db = Sequel::Database.new(:max_options => 1)
+    db.should_not be_single_threaded
+    db.should be_multi_threaded
+    
+    db = Sequel::Database.new
+    db.should_not be_single_threaded
+    db.should be_multi_threaded
+    
+    Sequel::Database.single_threaded = true
+    
+    db = Sequel::Database.new
+    db.should be_single_threaded
+    db.should_not be_multi_threaded
+    
+    db = Sequel::Database.new(:max_options => 4)
+    db.should be_single_threaded
+    db.should_not be_multi_threaded
+    
+  end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.1.8
-date: 2007-07-10 00:00:00 +03:00
+  version: 0.1.9
+date: 2007-07-21 00:00:00 +03:00
 summary: Concise ORM for Ruby.
 require_paths: 
 - lib
@@ -33,12 +33,14 @@ files:
 - README
 - Rakefile
 - bin/sequel
+- doc/rdoc
 - spec/adapters
 - spec/connection_pool_spec.rb
 - spec/core_ext_spec.rb
 - spec/database_spec.rb
 - spec/dataset_spec.rb
 - spec/expressions_spec.rb
+- spec/adapters/mysql_spec.rb
 - spec/adapters/sqlite_spec.rb
 - lib/sequel
 - lib/sequel.rb