sequel 0.2.1.1 → 0.3.0

data/lib/sequel/model/relations.rb

@@ -1,9 +1,12 @@
+# 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
     
+    # Comprehensive description goes here!
     def self.one_to_one(name, opts)
       klass = opts[:class] ? opts[:class] : (FROM_DATASET % name.inspect)
       key = opts[:key] || (name.to_s + ID_POSTFIX)
@@ -12,6 +15,8 @@ module Sequel
   
     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!
     def self.one_to_many(name, opts)
       klass = opts[:class] ? opts[:class] :
         (FROM_DATASET % (opts[:table] || name.inspect))

data/lib/sequel/model/schema.rb

@@ -1,5 +1,9 @@
 module Sequel
   class Model
+    # Defines a table schema (see Schema::Generator for more information).
+    #
+    # This is only needed if you want to use the create_table or drop_table
+    # methods.
     def self.set_schema(name = nil, &block)
       name ? set_dataset(db[name]) : name = table_name
       @schema = Schema::Generator.new(db, name, &block)
@@ -8,32 +12,38 @@ module Sequel
       end
     end
     
+    # Returns table schema for direct descendant of Model.
     def self.schema
       @schema || ((superclass != Model) && (superclass.schema))
     end
 
+    # Returns name of table.
     def self.table_name
       dataset.opts[:from].first
     end
     
+    # Returns true if table exists, false otherwise.
     def self.table_exists?
       db.table_exists?(table_name)
     end
     
+    # Creates table.
     def self.create_table
       db.create_table_sql_list(*schema.create_info).each {|s| db << s} 
     end
     
+    # Drops table.
     def self.drop_table
       db.execute db.drop_table_sql(table_name)
     end
     
+    # Like create_table but invokes drop_table when table_exists? is true.
     def self.create_table!
       drop_table if table_exists?
       create_table
-      
     end
     
+    # Deprecated, use create_table! instead.
     def self.recreate_table
       warn "Model.recreate_table is deprecated. Please use Model.create_table! instead."
       create_table!

data/lib/sequel/mysql.rb

@@ -2,27 +2,40 @@ if !Object.const_defined?('Sequel')
   require File.join(File.dirname(__FILE__), '../sequel')
 end
 
+require "bigdecimal"
+require "bigdecimal/util"
 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
+    0   => :to_d,     # MYSQL_TYPE_DECIMAL
+    1   => :to_i,     # MYSQL_TYPE_TINY
+    2   => :to_i,     # MYSQL_TYPE_SHORT
+    3   => :to_i,     # MYSQL_TYPE_LONG
+    4   => :to_f,     # MYSQL_TYPE_FLOAT
+    5   => :to_f,     # MYSQL_TYPE_DOUBLE
+    # 6   => ??,        # MYSQL_TYPE_NULL
+    7   => :to_time,  # MYSQL_TYPE_TIMESTAMP
+    8   => :to_i,     # MYSQL_TYPE_LONGLONG
+    9   => :to_i,     # MYSQL_TYPE_INT24
+    10  => :to_time,  # MYSQL_TYPE_DATE
+    11  => :to_time,  # MYSQL_TYPE_TIME
+    12  => :to_time,  # MYSQL_TYPE_DATETIME
+    13  => :to_i,     # MYSQL_TYPE_YEAR
+    14  => :to_time,  # MYSQL_TYPE_NEWDATE
+    # 15  => :to_s      # MYSQL_TYPE_VARCHAR
+    # 16  => :to_s,     # MYSQL_TYPE_BIT
+    246 => :to_d,     # MYSQL_TYPE_NEWDECIMAL
+    247 => :to_i,     # MYSQL_TYPE_ENUM
+    248 => :to_i      # MYSQL_TYPE_SET
+    # 249 => :to_s,     # MYSQL_TYPE_TINY_BLOB
+    # 250 => :to_s,     # MYSQL_TYPE_MEDIUM_BLOB
+    # 251 => :to_s,     # MYSQL_TYPE_LONG_BLOB
+    # 252 => :to_s,     # MYSQL_TYPE_BLOB
+    # 253 => :to_s,     # MYSQL_TYPE_VAR_STRING
+    # 254 => :to_s,     # MYSQL_TYPE_STRING
+    # 255 => :to_s      # MYSQL_TYPE_GEOMETRY
   }
   
   def convert_type(v, type)
@@ -40,7 +53,20 @@ class Mysql::Result
     @columns
   end
   
-  def each_hash(with_table=nil)
+  def each_array(with_table = nil)
+    c = columns
+    while row = fetch_row
+      c.each_with_index do |f, i|
+        if (t = MYSQL_TYPES[@column_types[i]]) && (v = row[i])
+          row[i] = v.send(t)
+        end
+      end
+      row.fields = c
+      yield row
+    end
+  end
+  
+  def each_hash(with_table = nil)
     c = columns
     while row = fetch_row
       h = {}
@@ -78,6 +104,10 @@ module Sequel
         conn
       end
       
+      def disconnect
+        @pool.disconnect {|c| c.close}
+      end
+      
       def tables
         @pool.hold do |conn|
           conn.list_tables.map {|t| t.to_sym}
@@ -166,6 +196,7 @@ module Sequel
       
       def literal(v)
         case v
+        when LiteralString: quoted_field_name(v)
         when true: TRUE
         when false: FALSE
         else
@@ -225,6 +256,19 @@ module Sequel
         end
         self
       end
+
+      def array_tuples_fetch_rows(sql, &block)
+        @db.synchronize do
+          r = @db.execute_select(sql)
+          begin
+            @columns = r.columns
+            r.each_array(&block)
+          ensure
+            r.free
+          end
+        end
+        self
+      end
     end
   end
 end

data/lib/sequel/odbc.rb

@@ -14,6 +14,10 @@ module Sequel
         conn.autocommit = true
         conn
       end
+      
+      def disconnect
+        @pool.disconnect {|c| c.disconnect}
+      end
     
       def dataset(opts = nil)
         ODBC::Dataset.new(self, opts)
@@ -46,7 +50,7 @@ module Sequel
 
       def fetch_rows(sql, &block)
         @db.synchronize do
-          s = @db.execute sql
+          s = @db.execute select_sql(sql)
           begin
             @columns = s.columns(true).map {|c| c.name.to_sym}
             rows = s.fetch_all
@@ -86,6 +90,43 @@ module Sequel
         end
       end
       
+      def array_tuples_fetch_rows(sql, &block)
+        @db.synchronize do
+          s = @db.execute sql
+          begin
+            @columns = s.columns(true).map {|c| c.name.to_sym}
+            rows = s.fetch_all
+            rows.each {|r| yield array_tuples_make_row(r)}
+          ensure
+            s.drop unless s.nil? rescue nil
+          end
+        end
+        self
+      end
+      
+      def array_tuples_make_row(row)
+        row.fields = @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
+          # SQL_TYPE_DATE, SQL_TYPE_TIME and SQL_TYPE_TIMESTAMP.
+          #
+          # The conversions below are consistent with the mappings in
+          # ODBCColumn#mapSqlTypeToGenericType and Column#klass.
+          case v
+          when ::ODBC::TimeStamp
+            row[idx] = DateTime.new(v.year, v.month, v.day, v.hour, v.minute, v.second)
+          when ::ODBC::Time
+            now = DateTime.now
+            row[idx] = Time.gm(now.year, now.month, now.day, v.hour, v.minute, v.second)
+          when ::ODBC::Date
+            row[idx] = Date.new(v.year, v.month, v.day)
+          end
+        end
+        row
+      end
+      
+
       def insert(*values)
         @db.do insert_sql(*values)
       end

data/lib/sequel/postgres.rb

@@ -154,6 +154,10 @@ module Sequel
         end
         conn
       end
+      
+      def disconnect
+        @pool.disconnect {|c| c.close}
+      end
     
       def dataset(opts = nil)
         Postgres::Dataset.new(self, opts)
@@ -280,6 +284,7 @@ module Sequel
     class Dataset < Sequel::Dataset
       def literal(v)
         case v
+        when LiteralString: v
         when String, Fixnum, Float, TrueClass, FalseClass: PGconn.quote(v)
         else
           super
@@ -436,6 +441,46 @@ module Sequel
         end
         eval("lambda {|r| {#{kvs.join(COMMA_SEPARATOR)}}}")
       end
+
+      def array_tuples_fetch_rows(sql, &block)
+        @db.synchronize do
+          result = @db.execute(sql)
+          begin
+            conv = array_tuples_row_converter(result)
+            result.each {|r| yield conv[r]}
+          ensure
+            result.clear
+          end
+        end
+      end
+      
+      @@array_tuples_converters_mutex = Mutex.new
+      @@array_tuples_converters = {}
+
+      def array_tuples_row_converter(result)
+        fields = []; translators = []
+        result.fields.each_with_index do |f, idx|
+          fields << f.to_sym
+          translators << PG_TYPES[result.type(idx)]
+        end
+        @columns = fields
+        
+        # create result signature and memoize the converter
+        sig = [fields, translators].hash
+        @@array_tuples_converters_mutex.synchronize do
+          @@array_tuples_converters[sig] ||= array_tuples_compile_converter(fields, translators)
+        end
+      end
+    
+      def array_tuples_compile_converter(fields, translators)
+        tr = []
+        fields.each_with_index do |field, idx|
+          if t = translators[idx]
+            tr << "if (v = r[#{idx}]); r[#{idx}] = v.#{t}; end"
+          end
+        end
+        eval("lambda {|r| r.fields = fields; #{tr.join(';')}; r}")
+      end
     end
   end
 end

data/lib/sequel/pretty_table.rb

@@ -1,17 +1,20 @@
-# Print nice-looking plain-text tables
-# +--+-------+
-# |id|name   |
-# |--+-------|
-# |1 |fasdfas|
-# |2 |test   |
-# +--+-------+
-
 module Sequel
+  # Prints nice-looking plain-text tables
+  # +--+-------+
+  # |id|name   |
+  # |--+-------|
+  # |1 |fasdfas|
+  # |2 |test   |
+  # +--+-------+
   module PrettyTable
-    def self.hash_columns(records)
+    def self.records_columns(records)
       columns = []
       records.each do |r|
-        r.keys.each {|k| columns << k unless columns.include?(k)}
+        if Array === r && (f = r.fields)
+          return r.fields
+        elsif Hash === r
+          r.keys.each {|k| columns << k unless columns.include?(k)}
+        end
       end
       columns
     end
@@ -53,7 +56,7 @@ module Sequel
     end
     
     def self.print(records, columns = nil) # records is an array of hashes
-      columns ||= hash_columns(records)
+      columns ||= records_columns(records)
       sizes = column_sizes(records, columns)
       
       puts separator_line(columns, sizes)

data/lib/sequel/schema/schema_generator.rb

@@ -18,12 +18,18 @@ module Sequel
         @primary_key ? @primary_key[:name] : nil
       end
       
-      def primary_key(name, type = nil, opts = nil)
+      def primary_key(name, *args)
         @primary_key = @db.serial_primary_key_options.merge({
           :name => name
         })
-        @primary_key.merge!({:type => type}) if type
-        @primary_key.merge!(opts) if opts
+        
+        if opts = args.pop
+          opts = {:type => opts} unless opts.is_a?(Hash)
+          if type = args.pop
+            opts.merge!(:type => type)
+          end
+          @primary_key.merge!(opts)
+        end
         @primary_key
       end
       

data/lib/sequel/sqlite.rb

@@ -21,6 +21,10 @@ module Sequel
         db.type_translation = true
         db
       end
+      
+      def disconnect
+        @pool.disconnect {|c| c.close}
+      end
     
       def dataset(opts = nil)
         SQLite::Dataset.new(self, opts)
@@ -93,18 +97,39 @@ module Sequel
         pragma_set(:temp_store, value)
       end
       
+      def transaction(&block)
+        @pool.hold do |conn|
+          if conn.transaction_active?
+            return yield(conn)
+          end
+          begin
+            result = nil
+            conn.transaction {result = yield(conn)}
+            result
+          rescue => e
+            raise e unless SequelRollbackError === e
+          end
+        end
+      end
     end
     
     class Dataset < Sequel::Dataset
       def literal(v)
         case v
         when Time: literal(v.iso8601)
-        when Date: literal(v.to_s)
         else
           super
         end
       end
 
+      def insert_sql(*values)
+        if (values.size == 1) && values.first.is_a?(Sequel::Dataset)
+          "INSERT INTO #{@opts[:from]} #{values.first.sql};"
+        else
+          super(*values)
+        end
+      end
+
       def fetch_rows(sql, &block)
         @db.execute_select(sql) do |result|
           @columns = result.columns.map {|c| c.to_sym}
@@ -116,6 +141,13 @@ module Sequel
           end
         end
       end
+      
+      def array_tuples_fetch_rows(sql, &block)
+        @db.execute_select(sql) do |result|
+          @columns = result.columns.map {|c| c.to_sym}
+          result.each(&block)
+        end
+      end
     
       def insert(*values)
         @db.execute_insert insert_sql(*values)

data/spec/adapters/mysql_spec.rb

@@ -11,6 +11,19 @@ MYSQL_DB.create_table :items do
   index :value
 end
 
+context "A MySQL database" do
+  setup do
+    @db = MYSQL_DB
+  end
+  
+  specify "should provide disconnect functionality" do
+    @db.tables
+    @db.pool.size.should == 1
+    @db.disconnect
+    @db.pool.size.should == 0
+  end
+end
+
 context "A MySQL dataset" do
   setup do
     @d = MYSQL_DB[:items]
@@ -25,24 +38,19 @@ context "A MySQL dataset" do
     @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
+  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).all.should == [
+
+    @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}
@@ -74,7 +82,7 @@ context "A MySQL dataset" do
     @d.select(:name).sql.should == \
       'SELECT `name` FROM items'
       
-    @d.select('COUNT(*)').sql.should == \
+    @d.select('COUNT(*)'.lit).sql.should == \
       'SELECT COUNT(*) FROM items'
 
     @d.select(:value.MAX).sql.should == \
@@ -89,13 +97,13 @@ context "A MySQL dataset" do
     @d.order(:name.DESC).sql.should == \
       'SELECT * FROM items ORDER BY `name` DESC'
       
-    @d.select('items.name AS item_name').sql.should == \
+    @d.select('items.name AS item_name'.to_sym).sql.should == \
       'SELECT items.`name` AS `item_name` FROM items'
       
-    @d.select('`name`').sql.should == \
+    @d.select('`name`'.lit).sql.should == \
       'SELECT `name` FROM items'
 
-    @d.select('max(items.`name`) as `max_name`').sql.should == \
+    @d.select('max(items.`name`) AS `max_name`'.lit).sql.should == \
       'SELECT max(items.`name`) AS `max_name` FROM items'
 
     @d.insert_sql(:value => 333).should == \
@@ -126,4 +134,50 @@ context "A MySQL dataset" do
     @d.filter(:name => /bc/).count.should == 2
     @d.filter(:name => /^bc/).count.should == 1
   end
-end
+end
+
+context "A MySQL dataset in array tuples mode" do
+  setup do
+    @d = MYSQL_DB[:items]
+    @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