sequel 0.2.0.1 → 0.2.0.2

data/CHANGELOG

@@ -1,3 +1,25 @@
+=== 0.2.0.2 (2007-09-07)
+
+* Dataset#insert can now accept subqueries.
+
+* Changed Migrator.apply to return the version.
+
+* Changed Sequel::Model() to cache intermediate classes so descendant classes can be reopened (#39).
+
+* Added :charset option to MySQL adapter (#40).
+
+* Fixed Dataset#exclude to add parens around NOT expression (#38).
+
+* Fixed use of sub-queries with all comparison operators in block filters (#38).
+
+* Fixed arithmetic expressions in block filters to not be literalized.
+
+* Changed Symbol#method_missing to return LiteralString.
+
+* Changed PrettyTable to right-align numbers.
+
+* Fixed Model.create_table (thanks Duane Johnson.)
+
 === 0.2.0.1 (2007-09-04)
 
 * Improved support for invoking methods with inline procs inside block filters.

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.2.0.1"
+VERS = "0.2.0.2"
 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

@@ -134,7 +134,7 @@ class Symbol
   # method name is made of all upper case letters.
   def method_missing(sym)
     ((s = sym.to_s) =~ /^([A-Z]+)$/) ? \
-      "#{s.downcase}(#{to_field_name})" : super
+      "#{s.downcase}(#{to_field_name})".lit : super
   end
   
   # Formats an SQL function with optional parameters

data/lib/sequel/dataset/sequelizer.rb

@@ -106,9 +106,9 @@ class Sequel::Dataset
     def call_expr(e, b)
       case op = e[2]
       when :>, :<, :>=, :<=
-        l = pt_expr(e[1], b)
-        r = pt_expr(e[3][1], b)
-        "(#{l} #{op} #{r})"
+        l = eval_expr(e[1], b)
+        r = eval_expr(e[3][1], b)
+        "(#{literal(l)} #{op} #{literal(r)})"
       when :==
         l = eval_expr(e[1], b)
         r = eval_expr(e[3][1], b)
@@ -118,9 +118,9 @@ class Sequel::Dataset
         r = eval_expr(e[3][1], b)
         match_expr(l, r)
       when :+, :-, :*, :/, :%
-        l = pt_expr(e[1], b)
-        r = pt_expr(e[3][1], b)
-        "(#{l} #{op} #{r})"
+        l = eval_expr(e[1], b)
+        r = eval_expr(e[3][1], b)
+        "(#{literal(l)} #{op} #{literal(r)})".lit
       when :in, :in?
         # in/in? operators are supported using two forms:
         #   :x.in([1, 2, 3])

data/lib/sequel/dataset/sql.rb

@@ -249,9 +249,9 @@ module Sequel
         if @opts[clause]
           l = expression_list(@opts[clause])
           r = expression_list(block || cond, parenthesize)
-          cond = "#{l} AND NOT #{r}"
+          cond = "#{l} AND (NOT #{r})"
         else
-          cond = "NOT #{expression_list(block || cond, true)}"
+          cond = "(NOT #{expression_list(block || cond, true)})"
         end
         clone_merge(clause => cond)
       end
@@ -420,18 +420,24 @@ module Sequel
       def insert_sql(*values)
         if values.empty?
           "INSERT INTO #{@opts[:from]} DEFAULT VALUES;"
-        elsif (values.size == 1) && values[0].is_a?(Hash)
-          field_list = []
-          value_list = []
-          values[0].each do |k, v|
-            field_list << field_name(k)
-            value_list << literal(v)
-          end
-          fl = field_list.join(COMMA_SEPARATOR)
-          vl = value_list.join(COMMA_SEPARATOR)
-          "INSERT INTO #{@opts[:from]} (#{fl}) VALUES (#{vl});"
         else
-          "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)});"
+          values = values[0] if values.size == 1
+          case values
+          when Hash
+            field_list = []
+            value_list = []
+            values.each do |k, v|
+              field_list << field_name(k)
+              value_list << literal(v)
+            end
+            fl = field_list.join(COMMA_SEPARATOR)
+            vl = value_list.join(COMMA_SEPARATOR)
+            "INSERT INTO #{@opts[:from]} (#{fl}) VALUES (#{vl});"
+          when Dataset
+            "INSERT INTO #{@opts[:from]} #{literal(values)}"
+          else
+            "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)});"
+          end
         end
       end
 

data/lib/sequel/migration.rb

@@ -115,6 +115,8 @@ module Sequel
         classes.each {|c| c.apply(db, direction)}
         set_current_migration_version(db, target)
       end
+      
+      target
     end
 
     # Returns a list of migration classes filtered for the migration range and

data/lib/sequel/model.rb

@@ -78,7 +78,7 @@ module Sequel
     end
     
     def self.create_table
-      db.execute schema.create_sql
+      db.create_table_sql_list(*schema.create_info).each {|s| db << s} 
     end
     
     def self.drop_table
@@ -292,7 +292,8 @@ module Sequel
   end
   
   def self.Model(table)
-    Class.new(Sequel::Model) do
+    @models ||= {}
+    @models[table] ||= Class.new(Sequel::Model) do
       meta_def(:inherited) do |c|
         if table.is_a?(Dataset)
           c.set_dataset(table)

data/lib/sequel/mysql.rb

@@ -69,6 +69,11 @@ module Sequel
         conn = Mysql.real_connect(@opts[:host], @opts[:user], @opts[:password], 
           @opts[:database], @opts[:port])
         conn.query_with_result = false
+        if @opts[:charset]
+          conn.query("set character_set_connection = '#{@opts[:charset]}';")
+          conn.query("set character_set_client = '#{@opts[:charset]}';")
+          conn.query("set character_set_results = '#{@opts[:charset]}';")
+        end
         conn.reconnect = true
         conn
       end

data/lib/sequel/pretty_table.rb

@@ -36,8 +36,16 @@ module Sequel
       '+' + columns.map {|c| '-' * sizes[c]}.join('+') + '+'
     end
     
+    def self.format_cell(size, v)
+      case v
+      when Bignum, Fixnum: "%#{size}d" % v
+      when Float: "%#{size}g" % v
+      else "%-#{size}s" % v.to_s
+      end
+    end
+    
     def self.data_line(columns, sizes, record)
-      '|' + columns.map {|c| "%-#{sizes[c]}s" % record[c].to_s}.join('|') + '|'
+      '|' + columns.map {|c| format_cell(sizes[c], record[c])}.join('|') + '|'
     end
     
     def self.header_line(columns, sizes)

data/spec/dataset_spec.rb

@@ -98,10 +98,22 @@ context "A simple dataset" do
     @dataset.delete_sql.should == 'DELETE FROM test'
   end
   
-  specify "should format an insert statement" do
+  specify "should format an insert statement with default values" do
     @dataset.insert_sql.should == 'INSERT INTO test DEFAULT VALUES;'
+  end
+  
+  specify "should format an insert statement with hash" do
     @dataset.insert_sql(:name => 'wxyz', :price => 342).
       should match(/INSERT INTO test \(name, price\) VALUES \('wxyz', 342\)|INSERT INTO test \(price, name\) VALUES \(342, 'wxyz'\)/)
+  end
+  
+  specify "should format an insert statement with sub-query" do
+    @sub = Sequel::Dataset.new(nil).from(:something).filter(:x => 2)
+    @dataset.insert_sql(@sub).should == \
+      "INSERT INTO test (SELECT * FROM something WHERE (x = 2))"
+  end
+  
+  specify "should format an insert statement with array" do
     @dataset.insert_sql('a', 2, 6.5).should ==
       "INSERT INTO test VALUES ('a', 2, 6.5);"
   end
@@ -361,33 +373,33 @@ context "Dataset#exclude" do
 
   specify "should correctly include the NOT operator when one condition is given" do
     @dataset.exclude(:region=>'Asia').select_sql.should ==
-      "SELECT * FROM test WHERE NOT (region = 'Asia')"
+      "SELECT * FROM test WHERE (NOT (region = 'Asia'))"
   end
 
   specify "should take multiple conditions as a hash and express the logic correctly in SQL" do
     @dataset.exclude(:region => 'Asia', :name => 'Japan').select_sql.
-      should match(Regexp.union(/WHERE NOT \(\(region = 'Asia'\) AND \(name = 'Japan'\)\)/,
-                                /WHERE NOT \(\(name = 'Japan'\) AND \(region = 'Asia'\)\)/))
+      should match(Regexp.union(/WHERE \(NOT \(\(region = 'Asia'\) AND \(name = 'Japan'\)\)\)/,
+                                /WHERE \(NOT \(\(name = 'Japan'\) AND \(region = 'Asia'\)\)\)/))
   end
 
   specify "should parenthesize a single string condition correctly" do
     @dataset.exclude("region = 'Asia' AND name = 'Japan'").select_sql.should ==
-      "SELECT * FROM test WHERE NOT (region = 'Asia' AND name = 'Japan')"
+      "SELECT * FROM test WHERE (NOT (region = 'Asia' AND name = 'Japan'))"
   end
 
   specify "should parenthesize an array condition correctly" do
     @dataset.exclude('region = ? AND name = ?', 'Asia', 'Japan').select_sql.should ==
-      "SELECT * FROM test WHERE NOT (region = 'Asia' AND name = 'Japan')"
+      "SELECT * FROM test WHERE (NOT (region = 'Asia' AND name = 'Japan'))"
   end
 
   specify "should corrently parenthesize when it is used twice" do
     @dataset.exclude(:region => 'Asia').exclude(:name => 'Japan').select_sql.should ==
-      "SELECT * FROM test WHERE NOT (region = 'Asia') AND NOT (name = 'Japan')"
+      "SELECT * FROM test WHERE (NOT (region = 'Asia')) AND (NOT (name = 'Japan'))"
   end
   
   specify "should support proc expressions" do
     @dataset.exclude {:id == (6...12)}.sql.should == 
-      'SELECT * FROM test WHERE NOT ((id >= 6 AND id < 12))'
+      'SELECT * FROM test WHERE (NOT ((id >= 6 AND id < 12)))'
   end
 end
 

data/spec/migration_spec.rb

@@ -229,7 +229,7 @@ context "Sequel::Migrator" do
 
     Sequel::Migrator.get_current_migration_version(@db).should == 5
   end
-
+  
   specify "should apply migrations correctly in the down direction" do
     Sequel::Migrator.apply(@db, '.', 1, 5)
     @db.drops.should == [5555, 3333, 2222]
@@ -250,4 +250,12 @@ context "Sequel::Migrator" do
 
     Sequel::Migrator.get_current_migration_version(@db).should == 0
   end
+  
+  specify "should return the target version" do
+    Sequel::Migrator.apply(@db, '.', 3, 2).should == 3
+
+    Sequel::Migrator.apply(@db, '.', 0).should == 0
+
+    Sequel::Migrator.apply(@db, '.').should == 5
+  end
 end

data/spec/model_spec.rb

@@ -44,4 +44,15 @@ describe Sequel::Model do
   it "puts the lotion in the basket or it gets the hose again" do
     # just kidding!
   end
+end
+
+class DummyModelBased < Sequel::Model(:blog)
+end
+
+context "Sequel::Model()" do
+  specify "should allow reopening of descendant classes" do
+    proc do
+      eval "class DummyModelBased < Sequel::Model(:blog); end"
+    end.should_not raise_error
+  end
 end

data/spec/pretty_table_spec.rb

@@ -39,14 +39,14 @@ context "PrettyTable" do
     Sequel::PrettyTable.print(@data2, [:a, :b])
     @output.rewind
     @output.read.should == \
-      "+--+----+\n|a |b   |\n+--+----+\n|23|45  |\n|45|2377|\n+--+----+\n"
+      "+--+----+\n|a |b   |\n+--+----+\n|23|  45|\n|45|2377|\n+--+----+\n"
   end
 
   specify "should also take header width into account" do
     Sequel::PrettyTable.print(@data3, [:aaa, :bb, :c])
     @output.rewind
     @output.read.should == \
-      "+---+--+-+\n|aaa|bb|c|\n+---+--+-+\n|1  |  | |\n|   |2 | |\n|   |  |3|\n+---+--+-+\n"
+      "+---+--+-+\n|aaa|bb|c|\n+---+--+-+\n|  1|  | |\n|   | 2| |\n|   |  |3|\n+---+--+-+\n"
   end
   
   specify "should print only the specified columns" do

data/spec/sequelizer_spec.rb

@@ -175,6 +175,12 @@ context "Proc#to_sql" do
 
     proc {:x == (a...b)}.to_sql.should == \
       "(x >= 3 AND x < 5)"
+      
+    t1 = Time.now - 4000
+    t2 = Time.now - 2000
+    
+    proc {:stamp == (t1..t2)}.to_sql.should == \
+      "(stamp >= #{DS.literal(t1)} AND stamp <= #{DS.literal(t2)})"
   end
 
   specify "should support comparison to sub-queries" do
@@ -186,8 +192,11 @@ context "Proc#to_sql" do
     # proc {:id == DB[:test].select(:node_id)}.to_sql.should == \
     # "(id IN (SELECT node_id FROM test))"
 
-    proc {:id == DB[:test].select(:node_id).filter {:active == true}}.to_sql.should == \
-    "(id IN (SELECT node_id FROM test WHERE (active = 't')))"
+    # proc {:id == DB[:test].select(:node_id).filter {:active == true}}.to_sql.should == \
+    #   "(id IN (SELECT node_id FROM test WHERE (active = 't')))"
+    
+    proc {:price >= DB[:items].select(:price)}.to_sql.should == \
+      "(price >= (SELECT price FROM items))"
   end
 
   specify "should support comparison to arrays" do

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.2.0.1
-date: 2007-09-04 00:00:00 +03:00
+  version: 0.2.0.2
+date: 2007-09-07 00:00:00 +03:00
 summary: Lightweight ORM library for Ruby
 require_paths: 
 - lib