sequel 0.5.0.2 → 1.0

data/lib/sequel/schema/schema_sql.rb

@@ -1,131 +0,0 @@
-module Sequel
-  module Schema
-    module SQL
-      RESTRICT = 'RESTRICT'.freeze
-      CASCADE = 'CASCADE'.freeze
-      NO_ACTION = 'NO ACTION'.freeze
-      SET_NULL = 'SET NULL'.freeze
-      SET_DEFAULT = 'SET DEFAULT'.freeze
-    
-      def on_delete_clause(action)
-        case action
-        when :restrict
-          RESTRICT
-        when :cascade
-          CASCADE
-        when :set_null
-          SET_NULL
-        when :set_default
-          SET_DEFAULT
-        else
-          NO_ACTION
-        end
-      end
-      
-      AUTOINCREMENT = 'AUTOINCREMENT'.freeze
-
-      def auto_increment_sql
-        AUTOINCREMENT
-      end
-      
-      COMMA_SEPARATOR = ', '.freeze
-      UNIQUE = ' UNIQUE'.freeze
-      NOT_NULL = ' NOT NULL'.freeze
-      PRIMARY_KEY = ' PRIMARY KEY'.freeze
-
-      TYPES = Hash.new {|h, k| k}
-      TYPES[:double] = 'double precision'
-      
-      def schema_utility_dataset
-        @schema_utility_dataset ||= dataset
-      end
-      
-      def literal(v)
-        schema_utility_dataset.literal(v)
-      end
-
-      def column_definition_sql(column)
-        sql = "#{literal(column[:name].to_sym)} #{TYPES[column[:type]]}"
-        column[:size] ||= 255 if column[:type] == :varchar
-        elements = column[:size] || column[:elements]
-        sql << "(#{literal(elements)})" if elements
-        sql << UNIQUE if column[:unique]
-        sql << NOT_NULL if column[:null] == false
-        sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
-        sql << PRIMARY_KEY if column[:primary_key]
-        if column[:table]
-          sql << " REFERENCES #{column[:table]}"
-          sql << "(#{column[:key]})" if column[:key]
-        end
-        sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
-        sql << " #{auto_increment_sql}" if column[:auto_increment]
-        sql
-      end
-  
-      def column_list_sql(columns)
-        columns.map {|c| column_definition_sql(c)}.join(COMMA_SEPARATOR)
-      end
-    
-      UNDERSCORE = '_'.freeze
-
-      def default_index_name(table_name, columns)
-        "#{table_name}_#{columns.join(UNDERSCORE)}_index"
-      end
-    
-      def index_definition_sql(table_name, index)
-        index_name = index[:name] || default_index_name(table_name, index[:columns])
-        if index[:unique]
-          "CREATE UNIQUE INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
-        else
-          "CREATE INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
-        end
-      end
-    
-      def index_list_sql_list(table_name, indexes)
-        indexes.map {|i| index_definition_sql(table_name, i)}
-      end
-  
-      def create_table_sql_list(name, columns, indexes = nil)
-        sql = ["CREATE TABLE #{name} (#{column_list_sql(columns)})"]
-        if indexes && !indexes.empty?
-          sql.concat(index_list_sql_list(name, indexes))
-        end
-        sql
-      end
-      
-      def drop_table_sql(name)
-        "DROP TABLE #{name}"
-      end
-      
-      def rename_table_sql(name, new_name)
-        "ALTER TABLE #{name} RENAME TO #{new_name}"
-      end
-      
-      def alter_table_sql_list(table, operations)
-        operations.map {|op| alter_table_sql(table, op)}
-      end
-      
-      def alter_table_sql(table, op)
-        case op[:op]
-        when :add_column
-          "ALTER TABLE #{table} ADD COLUMN #{column_definition_sql(op)}"
-        when :drop_column
-          "ALTER TABLE #{table} DROP COLUMN #{literal(op[:name])}"
-        when :rename_column
-          "ALTER TABLE #{table} RENAME COLUMN #{literal(op[:name])} TO #{literal(op[:new_name])}"
-        when :set_column_type
-          "ALTER TABLE #{table} ALTER COLUMN #{literal(op[:name])} TYPE #{op[:type]}"
-        when :set_column_default
-          "ALTER TABLE #{table} ALTER COLUMN #{literal(op[:name])} SET DEFAULT #{literal(op[:default])}"
-        when :add_index
-          index_definition_sql(table, op)
-        when :drop_index
-          "DROP INDEX #{default_index_name(table, op[:columns])}"
-        else
-          raise Error, "Unsupported ALTER TABLE operation"
-        end
-      end
-    end
-  end
-end
-

data/lib/sequel/sqlite.rb

@@ -1,6 +0,0 @@
-warn "Requiring 'sequel/sqlite' is deprecated. Please modify your code to require 'sequel' instead."
-
-if !Object.const_defined?('Sequel')
-  require File.join(File.dirname(__FILE__), '../sequel')
-end
-require File.join(File.dirname(__FILE__), 'adapters/sqlite')

data/lib/sequel/worker.rb

@@ -1,58 +0,0 @@
-require "thread"
-
-module Sequel
-
-  class Worker < Thread
-      
-    attr_reader :queue
-    attr_reader :errors
-  
-    def initialize(db = nil)
-      @queue = Queue.new
-      @errors = []
-      t = self
-      t.abort_on_exception = true
-      @transaction = !db.nil?
-      db ? super {db.transaction {t.work}} : super {t.work}
-    end
-    
-    def work
-      loop {next_job}
-    rescue Sequel::Error::WorkerStop # signals the worker thread to stop
-    ensure
-      rollback! if @transaction && !@errors.empty?
-    end
-    
-    def busy?
-      @cur || !@queue.empty?
-    end
-  
-    def async(proc = nil, &block)
-      @queue << (proc || block)
-      self
-    end
-    alias_method :add, :async
-    alias_method :<<, :async
-  
-    def join
-      while busy?
-        sleep 0.1
-      end
-      self.raise Error::WorkerStop
-      super
-    end
-
-    private
-    def next_job
-      @cur = @queue.pop
-      @cur.call
-    rescue Error::WorkerStop => e
-      raise e
-    rescue Exception => e
-      @errors << e
-    ensure
-      @cur = nil
-    end
-  end
-
-end

data/spec/adapters/informix_spec.rb

@@ -1,139 +0,0 @@
-require File.join(File.dirname(__FILE__), '../../lib/sequel')
-
-INFORMIX_DB = Sequel('informix://localhost/mydb')
-if INFORMIX_DB.table_exists?(:test)
-  INFORMIX_DB.drop_table :test
-end
-INFORMIX_DB.create_table :test do
-  text :name
-  integer :value
-  
-  index :value
-end
-
-context "A Informix database" do
-  specify "should provide disconnect functionality" do
-    INFORMIX_DB.execute("select user from dual")
-    INFORMIX_DB.pool.size.should == 1
-    INFORMIX_DB.disconnect
-    INFORMIX_DB.pool.size.should == 0
-  end
-end
-
-context "A Informix dataset" do
-  setup do
-    @d = INFORMIX_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
-    INFORMIX_DB.transaction do
-      @d << {:name => 'abc', :value => 1}
-    end
-
-    @d.count.should == 1
-  end
-  
-  specify "should support #first and #last" do
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
-    
-    @d.order(:value).first.should == {:name => 'abc', :value => 123}
-    @d.order(:value).last.should == {:name => 'def', :value => 789}
-  end
-end
-
-context "A Informix dataset in array tuples mode" do
-  setup do
-    @d = INFORMIX_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

data/spec/adapters/mysql_spec.rb

@@ -1,330 +0,0 @@
-require File.join(File.dirname(__FILE__), '../../lib/sequel')
-require 'logger'
-
-MYSQL_DB = Sequel('mysql://root@localhost/sandbox')
-MYSQL_DB.drop_table(:items) if MYSQL_DB.table_exists?(:items)
-MYSQL_DB.drop_table(:test2) if MYSQL_DB.table_exists?(:test2)
-MYSQL_DB.create_table :items do
-  text :name
-  integer :value, :index => true
-end
-MYSQL_DB.create_table :test2 do
-  text :name
-  integer :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]
-    @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 quote columns using back-ticks" do
-    @d.select(:name).sql.should == \
-      'SELECT `name` FROM items'
-      
-    @d.select('COUNT(*)'.lit).sql.should == \
-      'SELECT COUNT(*) FROM items'
-
-    @d.select(:value.MAX).sql.should == \
-      'SELECT max(`value`) FROM items'
-      
-    @d.select(:NOW[]).sql.should == \
-    'SELECT NOW() FROM items'
-
-    @d.select(:items__value.MAX).sql.should == \
-      'SELECT max(items.`value`) FROM items'
-
-    @d.order(:name.DESC).sql.should == \
-      'SELECT * FROM items ORDER BY `name` DESC'
-
-    @d.select('items.name AS item_name'.lit).sql.should == \
-      'SELECT items.name AS item_name FROM items'
-      
-    @d.select('`name`'.lit).sql.should == \
-      'SELECT `name` FROM items'
-
-    @d.select('max(items.`name`) AS `max_name`'.lit).sql.should == \
-      'SELECT max(items.`name`) AS `max_name` FROM items'
-      
-    @d.select(:test[:abc, 'hello']).sql.should == \
-      "SELECT test(`abc`, 'hello') FROM items"
-
-    @d.select(:test[:abc__def, 'hello']).sql.should == \
-      "SELECT test(abc.`def`, 'hello') FROM items"
-
-    @d.select(:test[:abc__def, 'hello'].as(:x2)).sql.should == \
-      "SELECT test(abc.`def`, 'hello') AS `x2` FROM items"
-
-    @d.insert_sql(:value => 333).should == \
-      'INSERT INTO items (`value`) VALUES (333)'
-
-    @d.insert_sql(:x => :y).should == \
-      'INSERT INTO items (`x`) VALUES (`y`)'
-  end
-  
-  specify "should quote fields correctly when reversing the order" do
-    @d.reverse_order(:name).sql.should == \
-      'SELECT * FROM items ORDER BY `name` DESC'
-
-    @d.reverse_order(:name.DESC).sql.should == \
-      'SELECT * FROM items ORDER BY `name`'
-
-    @d.reverse_order(:name, :test.DESC).sql.should == \
-      'SELECT * FROM items ORDER BY `name` DESC, `test`'
-
-    @d.reverse_order(:name.DESC, :test).sql.should == \
-      'SELECT * FROM items ORDER BY `name`, `test` DESC'
-  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
-  
-  specify "should support regexps" do
-    @d << {:name => 'abc', :value => 1}
-    @d << {:name => 'bcd', :value => 2}
-    @d.filter(:name => /bc/).count.should == 2
-    @d.filter(:name => /^bc/).count.should == 1
-  end
-  
-  specify "should correctly literalize strings with comment backslashes in them" do
-    @d.delete
-    proc {@d << {:name => ':\\'}}.should_not raise_error
-    
-    @d.first[:name].should == ':\\'
-  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
-
-context "MySQL datasets" do
-  setup do
-    @d = MYSQL_DB[:orders]
-  end
-  
-  specify "should correctly quote column references" do
-    market = 'ICE'
-    ack_stamp = Time.now - 15 * 60 # 15 minutes ago
-    @d.query do
-      select :market, :minute[:from_unixtime[:ack]].as(:minute)
-      where do
-        :ack > ack_stamp
-        :market == market
-      end
-      group_by :minute[:from_unixtime[:ack]]
-    end.sql.should == \
-      "SELECT `market`, minute(from_unixtime(`ack`)) AS `minute` FROM orders WHERE ((`ack` > #{@d.literal(ack_stamp)}) AND (`market` = 'ICE')) GROUP BY minute(from_unixtime(`ack`))"
-  end
-end
-
-# # Commented out because it was causing subsequent examples to fail for some reason
-# context "Simple stored procedure test" do
-#   setup do
-#     # Create a simple stored procedure but drop it first if there
-#     MYSQL_DB.execute("DROP PROCEDURE IF EXISTS sp_get_server_id;")
-#     MYSQL_DB.execute("CREATE PROCEDURE sp_get_server_id() SQL SECURITY DEFINER SELECT @@SERVER_ID as server_id;")
-#   end
-# 
-#   specify "should return the server-id via a stored procedure call" do
-#     @server_id = MYSQL_DB["SELECT @@SERVER_ID as server_id;"].first[:server_id] # grab the server_id via a simple query
-#     @server_id_by_sp = MYSQL_DB["CALL sp_get_server_id();"].first[:server_id]
-#     @server_id_by_sp.should == @server_id  # compare it to output from stored procedure
-#   end
-# end
-# 
-context "Joiמed MySQL dataset" do
-  setup do
-    @ds = MYSQL_DB[:nodes].join(:attributes, :node_id => :id)
-  end
-  
-  specify "should quote fields correctly" do
-    @ds.sql.should == \
-      "SELECT * FROM nodes INNER JOIN attributes ON (attributes.`node_id` = nodes.`id`)"
-  end
-end
-
-context "A MySQL database" do
-  setup do
-    @db = MYSQL_DB
-  end
-
-  specify "should support add_column operations" do
-    @db.add_column :test2, :xyz, :text
-    
-    @db[:test2].columns.should == [:name, :value, :xyz]
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => '000'}
-    @db[:test2].first[:xyz].should == '000'
-  end
-  
-  specify "should support drop_column operations" do
-    @db[:test2].columns.should == [:name, :value, :xyz]
-    @db.drop_column :test2, :xyz
-    
-    @db[:test2].columns.should == [:name, :value]
-  end
-  
-  specify "should support rename_column operations" do
-    @db[:test2].delete
-    @db.add_column :test2, :xyz, :text
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 'qqqq'}
-
-    @db[:test2].columns.should == [:name, :value, :xyz]
-    @db.rename_column :test2, :xyz, :zyx, :type => :text
-    @db[:test2].columns.should == [:name, :value, :zyx]
-    @db[:test2].first[:zyx].should == 'qqqq'
-  end
-  
-  specify "should support set_column_type operations" do
-    @db.add_column :test2, :xyz, :float
-    @db[:test2].delete
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 56.78}
-    @db.set_column_type :test2, :xyz, :integer
-    
-    @db[:test2].first[:xyz].should == 57
-  end
-  
-  specify "should support add_index" do
-    @db.add_index :test2, :value
-  end
-  
-  specify "should support drop_index" do
-    @db.drop_index :test2, :value
-  end
-end  
-
-context "A MySQL database" do
-  setup do
-    @db = MYSQL_DB
-  end
-  
-  specify "should support defaults for boolean columns" do
-    g = Sequel::Schema::Generator.new(@db) do
-      boolean :active1, :default => true
-      boolean :active2, :default => false
-    end
-    statements = @db.create_table_sql_list(:items, *g.create_info)
-    statements.should == [
-      "CREATE TABLE items (`active1` boolean DEFAULT 1, `active2` boolean DEFAULT 0)"
-    ]
-  end
-end