sequel_core 1.1 → 1.2

data/CHANGELOG

@@ -1,3 +1,17 @@
+=== 1.2 (2008-02-15)
+
+* Added support for :varchar[100] like type declarations in #create_table.
+
+* Fixed #rename_column in mysql adapter to support types like varchar(255) (#159).
+
+* Added support for order and limit in DELETE statement in MySQL adapter (#160).
+
+* Added checks to Dataset#multi_insert to prevent work if no values are given (#162).
+
+* Override ruby2ruby implementation of Proc#to_sexp which leaks memory (#161).
+
+* Added log option, help for sequel script (#157).
+
 === 1.1 (2008-02-15)
 
 * Fixed Dataset#join_table to support joining of datasets (#156).

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_core"
-VERS = "1.1"
+VERS = "1.2"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 

data/bin/sequel

@@ -1,29 +1,76 @@
 #!/usr/bin/env ruby
 
 require 'rubygems'
+require 'optparse'
+require 'sequel' rescue nil
 require 'sequel_core'
 require 'sequel_model' rescue nil
+require 'logger'
 
-usage = <<END
-Usage: sequel <connection URI>
-Sequel: Lightweight ORM library for Ruby
+$uri = nil
+$logfile = nil
+$echo = nil
 
-Examples:
-  sequel sqlite:///blog.db
-  sequel postgres://localhost/my_blog
+opts = OptionParser.new do |opts|
+  opts.banner = "Sequel: Lightweight ORM for Ruby"
+  opts.define_head "Usage: sequel <uri> [options]"
+  opts.separator ""
+  opts.separator "Examples:"
+  opts.separator "  sequel sqlite:///blog.db"
+  opts.separator "  sequel postgres://localhost/my_blog"
+  
+  opts.separator ""
+  opts.separator "For more information see http://code.google.com/p/ruby-sequel"
+  opts.separator ""
+  opts.separator "Options:"
 
-For more information see http://code.google.com/p/ruby-sequel
-END
+  opts.on("-l", "--log logfile", "log SQL statements to log file") do |v|
+    $logfile = v
+  end
+  
+  # opts.on("-e", "--echo", "echo SQL statements") do |v|
+  #   $echo = v
+  # end
+  
+  opts.on_tail("-?", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("-v", "--version", "Show version") do
+    class << Gem; attr_accessor :loaded_specs; end
+    specs = Gem.loaded_specs['sequel']
+    puts "sequel #{specs.version} (#{specs.date.strftime '%Y-%m-%d'})"
+    specs = Gem.loaded_specs['sequel_core']
+    puts "sequel_core #{specs.version} (#{specs.date.strftime '%Y-%m-%d'})"
+    begin
+      specs = Gem.loaded_specs['sequel_model']
+      puts "sequel_model #{specs.version} (#{specs.date.strftime '%Y-%m-%d'})"
+    rescue
+    end
+    exit
+  end
+end
+opts.parse!
 
 db = ARGV.shift
 
-if db.nil? || db.empty?
-  puts usage
+if db.blank?
+  puts opts
   exit
 end
 
+db_opts = {}
+if $logfile
+  db_opts[:logger] = Logger.new($logfile)
+end
+if $echo
+  db_opts[:echo] = true
+end
+
 begin
-  DB = Sequel.connect db
+  puts "db_opts = #{db_opts.inspect}"
+  DB = Sequel.connect db, db_opts
 rescue => e
   puts e.message
   exit
@@ -40,3 +87,85 @@ end
 require 'irb'
 puts "Your database is stored in DB..."
 IRB.start
+
+__END__
+
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'optparse'
+require 'bulkmail'
+
+$helo = nil
+$from = nil
+$recipients = []
+$content = nil
+$delay = 60..300
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: bulkmail <options>"
+  opts.define_head "Simple bulk-mailer."
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on("-h", "--helo HOSTNAME", "HELO host name.") do |v|
+    $helo = v
+  end
+  
+  opts.on("-r", "--recipients filename", "Recipients file name") do |v|
+    $recipients = IO.readlines(v).map {|l| l =~ /(.*)(\r\n|\n)$/ ? $1 : l}.compact
+  end
+  
+  opts.on("-c", "--content filename", "Content file name") do |v|
+    $content = IO.read(v)
+  end
+  
+  opts.on("-f", "--from from", "From address") do |v|
+    $from = v
+  end
+  
+  opts.on('-n', "--nodelay", "No delay") do |v|
+    $delay = 0
+  end
+  
+  # No argument, shows at tail.  This will print an options summary.
+  # Try it and see!
+  opts.on_tail("-?", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  # Another typical switch to print the version.
+  opts.on_tail("-v", "--version", "Show version") do
+    class << Gem; attr_accessor :loaded_specs; end
+    specs = Gem.loaded_specs['bulkmail']
+    puts "bulkmail #{specs.version} (#{specs.date.strftime '%Y-%m-%d'})"
+    exit
+  end
+end
+
+begin
+  opts.parse! ARGV
+rescue => e
+  puts e.message
+  puts e.backtrace.first
+  exit
+end
+
+unless $content
+  puts opts
+  exit
+end
+
+trap('INT') {exit}
+
+puts "Please hold on..."
+
+sender = BulkMail::Sender.new({
+  :list => $recipients,
+  :from => $from,
+  :message => $content,
+  :helo => $helo,
+  :delay => $delay
+})
+sender.start

data/lib/sequel_core/adapters/mysql.rb

@@ -141,9 +141,9 @@ module Sequel
       def alter_table_sql(table, op)
         case op[:op]
         when :rename_column
-          "ALTER TABLE #{table} CHANGE COLUMN #{literal(op[:name])} #{literal(op[:new_name])} #{op[:type]}"
+          "ALTER TABLE #{table} CHANGE COLUMN #{literal(op[:name])} #{literal(op[:new_name])} #{type_literal(op[:type])}"
         when :set_column_type
-          "ALTER TABLE #{table} CHANGE COLUMN #{literal(op[:name])} #{literal(op[:name])} #{op[:type]}"
+          "ALTER TABLE #{table} CHANGE COLUMN #{literal(op[:name])} #{literal(op[:name])} #{type_literal(op[:type])}"
         when :drop_index
           "DROP INDEX #{default_index_name(table, op[:columns])} ON #{table}"
         else
@@ -316,13 +316,26 @@ module Sequel
       # 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 #{column_list(order)}"
         end
+        if limit = opts[:limit]
+          sql << " LIMIT #{limit}"
+        end
 
+        sql
+      end
+      
+      # MySQL supports ORDER and LIMIT clauses in DELETE statements.
+      def delete_sql(opts = nil)
+        sql = super
+        opts = opts ? @opts.merge(opts) : @opts
+
+        if order = opts[:order]
+          sql << " ORDER BY #{column_list(order)}"
+        end
         if limit = opts[:limit]
           sql << " LIMIT #{limit}"
         end

data/lib/sequel_core/dataset/convenience.rb

@@ -242,15 +242,20 @@ module Sequel
       #   # this will commit every 50 records
       #   dataset.multi_insert(lots_of_records, :slice => 50)
       def multi_insert(*args)
-        if args[0].is_a?(Array) && args[1].is_a?(Array)
+        if args.empty?
+          return
+        elsif args[0].is_a?(Array) && args[1].is_a?(Array)
           columns, values, opts = *args
         else
           # we assume that an array of hashes is given
           hashes, opts = *args
+          return if hashes.empty?
           columns = hashes.first.keys
           # convert the hashes into arrays
           values = hashes.map {|h| columns.map {|c| h[c]}}
         end
+        # make sure there's work to do
+        return if columns.empty? || values.empty?
         
         slice_size = opts && (opts[:commit_every] || opts[:slice])
         

data/lib/sequel_core/dataset/sequelizer.rb

@@ -371,12 +371,12 @@ rescue Exception
 end
 
 class Proc
-  # replacement for Proc#to_sexp, if it's not available
-  unless instance_methods.include?('to_sexp')
-    def to_sexp
-      block = self
-      c = Class.new {define_method(:m, &block)}
-      ParseTree.translate(c, :m)[2]
-    end
+  # replacement for Proc#to_sexp as defined in ruby2ruby.
+  # see also: http://rubyforge.org/tracker/index.php?func=detail&aid=18095&group_id=1513&atid=5921
+  # The ruby2ruby implementation leaks memory, so we fix it.
+  def to_sexp
+    block = self
+    c = Class.new {define_method(:m, &block)}
+    ParseTree.translate(c, :m)[2]
   end
 end

data/lib/sequel_core/dataset/sql.rb

@@ -550,7 +550,7 @@ module Sequel
           "INSERT INTO #{table} (#{columns}) VALUES (#{literal(r)})"
         end
       end
-
+      
       # Formats an UPDATE statement using the given values.
       #
       #   dataset.update_sql(:price => 100, :category => 'software') #=>

data/lib/sequel_core/schema/schema_sql.rb

@@ -45,6 +45,10 @@ module Sequel
         schema_utility_dataset.literal(v)
       end
       
+      def type_literal(t)
+        t.is_a?(Symbol) ? t.to_s : literal(t)
+      end
+      
       def expression_list(*args, &block)
         schema_utility_dataset.expression_list(*args, &block)
       end
@@ -53,7 +57,7 @@ module Sequel
         if column[:type] == :check
           return constraint_definition_sql(column)
         end
-        sql = "#{literal(column[:name].to_sym)} #{TYPES[column[:type]]}"
+        sql = "#{literal(column[:name].to_sym)} #{type_literal(TYPES[column[:type]])}"
         column[:size] ||= 255 if column[:type] == :varchar
         elements = column[:size] || column[:elements]
         sql << "(#{literal(elements)})" if elements

data/spec/adapters/mysql_spec.rb

@@ -319,6 +319,17 @@ context "A MySQL database" do
     @db[:test2].first[:zyx].should == 'qqqq'
   end
   
+  specify "should support rename_column operations with types like varchar(255)" do
+    @db[:test2].delete
+    @db.add_column :test2, :tre, :text
+    @db[:test2] << {:name => 'mmm', :value => 111, :tre => 'qqqq'}
+
+    @db[:test2].columns.should == [:name, :value, :zyx, :tre]
+    @db.rename_column :test2, :tre, :ert, :type => :varchar[255]
+    @db[:test2].columns.should == [:name, :value, :zyx, :ert]
+    @db[:test2].first[:ert].should == 'qqqq'
+  end
+  
   specify "should support set_column_type operations" do
     @db.add_column :test2, :xyz, :float
     @db[:test2].delete

data/spec/dataset_spec.rb

@@ -1050,7 +1050,7 @@ end
 context "Dataset#empty?" do
   specify "should return true if records exist in the dataset" do
     @db = Sequel::Database.new
-    @db.meta_def(:execute) {|sql| puts "blah";@sqls ||=[]; @sqls << sql}
+    @db.meta_def(:execute) {|sql| @sqls ||=[]; @sqls << sql}
     @db.meta_def(:sqls) {@sqls ||= []}
     
     $cccc = Class.new(Sequel::Dataset) do
@@ -2171,6 +2171,35 @@ context "Dataset#multi_insert" do
       'COMMIT'
     ]
   end
+
+  specify "should not do anything if no columns or values are given" do
+    @ds.multi_insert
+    @db.sqls.should be_nil
+    
+    @ds.multi_insert([])
+    @db.sqls.should be_nil
+    
+    @ds.multi_insert([], [])
+    @db.sqls.should be_nil
+
+    @ds.multi_insert([{}, {}])
+    @db.sqls.should be_nil
+    
+    @ds.multi_insert([:a, :b], [])
+    @db.sqls.should be_nil
+    
+    @ds.multi_insert([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (x, y) VALUES (1, 2)",
+      "INSERT INTO items (x, y) VALUES (3, 4)",
+      'COMMIT',
+      'BEGIN',
+      "INSERT INTO items (x, y) VALUES (5, 6)",
+      'COMMIT'
+    ]
+  end
+  
 end
 
 context "Dataset#query" do

data/spec/schema_spec.rb

@@ -94,6 +94,13 @@ context "DB#create_table" do
     end
     @db.sqls.should == ["CREATE TABLE cats (name varchar(51))"]
   end
+  
+  specify "should accept varchar size as sql function" do
+    @db.create_table(:cats) do
+      column :name, :varchar[102]
+    end
+    @db.sqls.should == ["CREATE TABLE cats (name varchar(102))"]
+  end
 
   specify "should accept foreign keys" do
     @db.create_table(:cats) do

data/spec/sequelizer_spec.rb

@@ -59,46 +59,6 @@ context "Sequelizer without Ruby2Ruby" do
   end
 end
 
-context "Proc without #to_sexp method (Ruby2Ruby missing)" do
-  setup do
-    class Proc
-      alias_method :orig_to_sexp, :to_sexp
-      remove_method :to_sexp
-    end
-    
-    module Kernel
-      alias_method :orig_sq_require, :require
-      def require(name); raise LoadError if name == 'ruby2ruby'; end
-    end
-    old_verbose = $VERBOSE
-    $VERBOSE = nil
-    load(File.join(File.dirname(__FILE__), '../lib/sequel_core/dataset/sequelizer.rb'))
-    $VERBOSE = old_verbose
-    @db = Sequel::Database.new
-    @ds = @db[:items]
-  end
-  
-  teardown do
-    module Kernel
-      alias_method :require, :orig_sq_require
-    end
-    old_verbose = $VERBOSE
-    $VERBOSE = nil
-    load(File.join(File.dirname(__FILE__), '../lib/sequel_core/dataset/sequelizer.rb'))
-    $VERBOSE = old_verbose
-    
-    class Proc
-      alias_method :to_sexp, :orig_to_sexp
-    end
-  end
-  
-  specify "should define a replacement Proc#to_sexp implementation" do
-    pr = proc {1 + 1}
-    proc {pr.to_sexp}.should_not raise_error
-    pr.to_sexp.should == [:bmethod, nil, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]
-  end
-end
-
 context "Proc#to_sql" do
   DB = Sequel::Database.new
   DS = DB[:items]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_core
 version: !ruby/object:Gem::Version 
-  version: "1.1"
+  version: "1.2"
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-15 00:00:00 +02:00
+date: 2008-02-16 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency