sequel 4.26.0 → 5.37.0

data/lib/sequel/plugins/schema.rb

@@ -1,80 +0,0 @@
-module Sequel
-  module Plugins
-    # Sequel's built in schema plugin allows you to define your schema
-    # directly in the model using Model.set_schema (which takes a block
-    # similar to Database#create_table), and use Model.create_table to
-    # create a table using the schema information.
-    #
-    # This plugin is mostly suited to test code.  If there is any
-    # chance that your application's schema could change, you should
-    # be using the migration extension instead.
-    # 
-    # Usage:
-    #
-    #   # Add the schema methods to all model subclasses (called before loading subclasses)
-    #   Sequel::Model.plugin :schema
-    #
-    #   # Add the schema methods to the Album class
-    #   Album.plugin :schema
-    module Schema
-      module ClassMethods
-        # Creates table, using the column information from set_schema.
-        def create_table(*args, &block)
-          set_schema(*args, &block) if block
-          db.create_table(table_name, :generator=>@schema)
-          @db_schema = get_db_schema(true)
-          columns
-        end
-        
-        # Drops the table if it exists and then runs create_table.  Should probably
-        # not be used except in testing.
-        def create_table!(*args, &block)
-          drop_table?
-          create_table(*args, &block)
-        end
-
-        # Creates the table unless the table already exists
-        def create_table?(*args, &block)
-          create_table(*args, &block) unless table_exists?
-        end
-        
-        # Drops table.  If the table doesn't exist, this will probably raise an error.
-        def drop_table
-          db.drop_table(table_name)
-        end
-    
-        # Drops table if it already exists, do nothing if it doesn't exist.
-        def drop_table?
-          db.drop_table?(table_name)
-        end
-    
-        # Returns table schema created with set_schema for direct descendant of Model.
-        # Does not retreive schema information from the database, see db_schema if you
-        # want that.
-        def schema
-          @schema || (superclass.schema unless superclass == Model)
-        end
-    
-        # Defines a table schema (see Schema::Generator for more information).
-        #
-        # This is only needed if you want to use the create_table/create_table! methods.
-        # Will also set the dataset if you provide a name, as well as setting
-        # the primary key if you defined one in the passed block.
-        #
-        # In general, it is a better idea to use migrations for production code, as
-        # migrations allow changes to existing schema.  set_schema is mostly useful for
-        # test code or simple examples.
-        def set_schema(name = nil, &block)
-          set_dataset(db[name]) if name
-          @schema = db.create_table_generator(&block)
-          set_primary_key(@schema.primary_key_name) if @schema.primary_key_name
-        end
-        
-        # Returns true if table exists, false otherwise.
-        def table_exists?
-          db.table_exists?(table_name)
-        end
-      end
-    end
-  end
-end

data/lib/sequel/plugins/scissors.rb

@@ -1,33 +0,0 @@
-module Sequel
-  module Plugins
-    # The scissors plugin adds class methods for update, delete, and destroy.
-    # It is so named because this is considered dangerous, since it is easy
-    # to write:
-    #
-    #   Album.delete
-    #
-    # and delete all rows in the table, when you meant to write:
-    #
-    #   album.delete
-    #
-    # and only delete a single row.
-    #
-    # This plugin is mostly useful for backwards compatibility, and not
-    # recommended for use in production.  However, it can cut down on
-    # verbosity in non-transactional test code, so it may be appropriate
-    # to use when testing.
-    #
-    # Usage:
-    #
-    #   # Make all model subclass run with scissors
-    #   Sequel::Model.plugin :scissors
-    #
-    #   # Make the Album class run with scissors
-    #   Album.plugin :scissors
-    module Scissors
-      module ClassMethods
-        Plugins.def_dataset_methods(self, [:update, :delete, :destroy])
-      end
-    end
-  end
-end

data/spec/adapters/db2_spec.rb

@@ -1,160 +0,0 @@
-SEQUEL_ADAPTER_TEST = :db2
-
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
-
-if DB.table_exists?(:test)
-  DB.drop_table(:test)
-end
-
-describe Sequel::Database do
-  before do
-    @db = DB
-    @db.create_table(:test){String :a}
-    @ds = @db[:test]
-  end
-
-  after do
-    @db.drop_table(:test)
-  end
-  
-  it "should provide disconnect functionality after preparing a connection" do
-    @ds.prepare(:first, :a).call
-    @db.disconnect
-    @db.pool.size.must_equal 0
-  end
-
-  it "should return version correctly" do
-    @db.db2_version.must_match(/DB2 v/i)
-  end
-end
-
-describe "Simple Dataset operations" do
-  before(:all) do
-    Sequel::DB2.use_clob_as_blob = true
-    DB.create_table!(:items) do
-      Integer :id, :primary_key => true
-      Integer :number
-      column  :bin_string, 'varchar(20) for bit data'
-      column  :bin_clob, 'clob'
-    end
-    @ds = DB[:items]
-  end
-  after(:each) do
-    @ds.delete
-  end
-  after(:all) do
-    Sequel::DB2.use_clob_as_blob = false
-    DB.drop_table(:items)
-  end
-
-  it "should insert with a primary key specified" do
-    @ds.insert(:id => 1,   :number => 10)
-    @ds.insert(:id => 100, :number => 20)
-    @ds.select_hash(:id, :number).must_equal(1 => 10, 100 => 20)
-  end
-
-  it "should insert into binary columns" do
-    @ds.insert(:id => 1, :bin_string => Sequel.blob("\1"), :bin_clob => Sequel.blob("\2"))
-    @ds.select(:bin_string, :bin_clob).first.must_equal(:bin_string => "\1", :bin_clob => "\2")
-  end
-end
-
-describe Sequel::Database do
-  before do
-    @db = DB
-  end
-  after do
-    @db.drop_table(:items)
-  end
-
-  it "should parse primary keys from the schema properly" do
-    @db.create_table!(:items){Integer :number}
-    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.must_equal []
-    @db.create_table!(:items){primary_key :number}
-    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.must_equal [:number]
-    @db.create_table!(:items){Integer :number1, :null => false; Integer :number2, :null => false; primary_key [:number1, :number2]}
-    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.must_equal [:number1, :number2]
-  end
-
-  it "should not error on alter_table operations that need REORG" do
-    @db.create_table!(:items) do
-      varchar :a
-    end
-    @db.alter_table(:items) do
-      add_column :b, :varchar, :null => true
-      set_column_allow_null :a, false
-      add_index :a, :unique => true
-    end
-  end
-end
-
-describe "Sequel::IBMDB.convert_smallint_to_bool" do
-  before do
-    @db = DB
-    @db.create_table!(:booltest){column :b, 'smallint'; column :i, 'integer'}
-    @ds = @db[:booltest]
-  end
-  after do
-    Sequel::IBMDB.convert_smallint_to_bool = true
-    @db.drop_table(:booltest)
-  end
-  
-  it "should consider smallint datatypes as boolean if set, but not larger smallints" do
-    @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :boolean
-    @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
-    Sequel::IBMDB.convert_smallint_to_bool = false
-    @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :integer
-    @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
-  end
-  
-  it "should return smallints as bools and integers as integers when set" do
-    Sequel::IBMDB.convert_smallint_to_bool = true
-    @ds.delete
-    @ds << {:b=>true, :i=>10}
-    @ds.all.must_equal [{:b=>true, :i=>10}]
-    @ds.delete
-    @ds << {:b=>false, :i=>0}
-    @ds.all.must_equal [{:b=>false, :i=>0}]
-    @ds.delete
-    @ds << {:b=>true, :i=>1}
-    @ds.all.must_equal [{:b=>true, :i=>1}]
-  end
-
-  it "should return all smallints as integers when unset" do
-    Sequel::IBMDB.convert_smallint_to_bool = false
-    @ds.delete
-    @ds << {:b=>true, :i=>10}
-    @ds.all.must_equal [{:b=>1, :i=>10}]
-    @ds.delete
-    @ds << {:b=>false, :i=>0}
-    @ds.all.must_equal [{:b=>0, :i=>0}]
-    
-    @ds.delete
-    @ds << {:b=>1, :i=>10}
-    @ds.all.must_equal [{:b=>1, :i=>10}]
-    @ds.delete
-    @ds << {:b=>0, :i=>0}
-    @ds.all.must_equal [{:b=>0, :i=>0}]
-  end
-end if DB.adapter_scheme == :ibmdb
-
-describe "Simple Dataset operations in transactions" do
-  before do
-    DB.create_table!(:items_insert_in_transaction) do
-      Integer :id, :primary_key => true
-      integer :number
-    end
-    @ds = DB[:items_insert_in_transaction]
-  end
-  after do
-    DB.drop_table(:items_insert_in_transaction)
-  end
-
-  it "should insert correctly with a primary key specified inside a transaction" do
-    DB.transaction do
-      @ds.insert(:id=>100, :number=>20)
-      @ds.count.must_equal 1
-      @ds.order(:id).all.must_equal [{:id=>100, :number=>20}]
-    end
-  end
-end

data/spec/adapters/firebird_spec.rb

@@ -1,411 +0,0 @@
-SEQUEL_ADAPTER_TEST = :firebird
-
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
-
-def DB.sqls
-  (@sqls ||= [])
-end
-logger = Object.new
-def logger.method_missing(m, msg)
-  DB.sqls.push(msg)
-end
-DB.loggers = [logger]
-
-DB.create_table! :test do
-  varchar :name,  :size => 50
-  integer :val,   :index => true
-end
-
-DB.create_table! :test2 do
-  integer :val
-  timestamp :time_stamp
-end
-
-DB.create_table! :test3 do
-  integer :val
-  timestamp :time_stamp
-end
-
-DB.create_table! :test5 do
-  primary_key :xid
-  integer :val
-end
-
-DB.create_table! :test6 do
-  primary_key :xid
-  blob :val
-  String :val2
-  varchar :val3, :size=>200
-  String :val4, :text=>true
-end
-
-describe "A Firebird database" do
-  before do
-    @db = DB
-  end
-
-  it "should provide disconnect functionality" do
-    @db.tables
-    @db.pool.size.must_equal 1
-    @db.disconnect
-    @db.pool.size.must_equal 0
-  end
-
-  it "should raise Sequel::Error on error" do
-    proc{@db << "SELECT 1 + 'a'"}.must_raise(Sequel::Error)
-  end
-end
-
-describe "A Firebird dataset" do
-  before do
-    @d = DB[:test]
-    @d.delete # remove all records
-    @d.quote_identifiers = true
-  end
-
-  it "should return the correct record count" do
-    @d.count.must_equal 0
-    @d << {:name => 'abc', :val => 123}
-    @d << {:name => 'abc', :val  => 456}
-    @d << {:name => 'def', :val => 789}
-    @d.count.must_equal 3
-  end
-
-  it "should return the correct records" do
-    @d.to_a.must_equal []
-    @d << {:name => 'abc', :val => 123}
-    @d << {:name => 'abc', :val => 456}
-    @d << {:name => 'def', :val => 789}
-
-    @d.order(:val).to_a.must_equal [
-      {:name => 'abc', :val => 123},
-      {:name => 'abc', :val => 456},
-      {:name => 'def', :val => 789}
-    ]
-  end
-
-  it "should update records correctly" do
-    @d << {:name => 'abc', :val => 123}
-    @d << {:name => 'abc', :val => 456}
-    @d << {:name => 'def', :val => 789}
-    @d.filter(:name => 'abc').update(:val => 530)
-
-    # the third record should stay the same
-    # floating-point precision bullshit
-    @d[:name => 'def'][:val].must_equal 789
-    @d.filter(:val => 530).count.must_equal 2
-  end
-
-  it "should delete records correctly" do
-    @d << {:name => 'abc', :val => 123}
-    @d << {:name => 'abc', :val => 456}
-    @d << {:name => 'def', :val => 789}
-    @d.filter(:name => 'abc').delete
-
-    @d.count.must_equal 1
-    @d.first[:name].must_equal 'def'
-  end
-
-  it "should be able to literalize booleans" do
-    @d.literal(true)
-    @d.literal(false)
-  end
-
-  it "should quote columns and tables using double quotes if quoting identifiers" do
-    @d.quote_identifiers = true
-    @d.select(:name).sql.must_equal \
-      'SELECT "NAME" FROM "TEST"'
-
-    @d.select('COUNT(*)'.lit).sql.must_equal \
-      'SELECT COUNT(*) FROM "TEST"'
-
-    @d.select(:max[:val]).sql.must_equal \
-      'SELECT max("VAL") FROM "TEST"'
-
-    @d.select(:now[]).sql.must_equal \
-    'SELECT now() FROM "TEST"'
-
-    @d.select(:max[:items__val]).sql.must_equal \
-      'SELECT max("ITEMS"."VAL") FROM "TEST"'
-
-    @d.order(:name.desc).sql.must_equal \
-      'SELECT * FROM "TEST" ORDER BY "NAME" DESC'
-
-    @d.select('TEST.NAME AS item_:name'.lit).sql.must_equal \
-      'SELECT TEST.NAME AS item_:name FROM "TEST"'
-
-    @d.select('"NAME"'.lit).sql.must_equal \
-      'SELECT "NAME" FROM "TEST"'
-
-    @d.select('max(TEST."NAME") AS "max_:name"'.lit).sql.must_equal \
-      'SELECT max(TEST."NAME") AS "max_:name" FROM "TEST"'
-
-    @d.select(:test[:ABC, 'hello']).sql.must_equal \
-      "SELECT test(\"ABC\", 'hello') FROM \"TEST\""
-
-    @d.select(:test[:ABC__DEF, 'hello']).sql.must_equal \
-      "SELECT test(\"ABC\".\"DEF\", 'hello') FROM \"TEST\""
-
-    @d.select(:test[:ABC__DEF, 'hello'].as(:X2)).sql.must_equal \
-      "SELECT test(\"ABC\".\"DEF\", 'hello') AS \"X2\" FROM \"TEST\""
-
-    @d.insert_sql(:val => 333).must_match \
-      /\AINSERT INTO "TEST" \("VAL"\) VALUES \(333\)( RETURNING NULL)?\z/
-
-    @d.insert_sql(:X => :Y).must_match \
-      /\AINSERT INTO "TEST" \("X"\) VALUES \("Y"\)( RETURNING NULL)?\z/
-  end
-
-  it "should quote fields correctly when reversing the order if quoting identifiers" do
-    @d.quote_identifiers = true
-    @d.reverse_order(:name).sql.must_equal \
-      'SELECT * FROM "TEST" ORDER BY "NAME" DESC'
-
-    @d.reverse_order(:name.desc).sql.must_equal \
-      'SELECT * FROM "TEST" ORDER BY "NAME" ASC'
-
-    @d.reverse_order(:name, :test.desc).sql.must_equal \
-      'SELECT * FROM "TEST" ORDER BY "NAME" DESC, "TEST" ASC'
-
-    @d.reverse_order(:name.desc, :test).sql.must_equal \
-      'SELECT * FROM "TEST" ORDER BY "NAME" ASC, "TEST" DESC'
-  end
-
-  it "should support transactions" do
-    DB.transaction do
-      @d << {:name => 'abc', :val => 1}
-    end
-
-    @d.count.must_equal 1
-  end
-
-  it "should have #transaction yield the connection" do
-    DB.transaction do |conn|
-      conn.wont_equal nil
-    end
-  end
-
-  it "should correctly rollback transactions" do
-    proc do
-      DB.transaction do
-        @d << {:name => 'abc', :val => 1}
-        raise RuntimeError, 'asdf'
-      end
-    end.must_raise(RuntimeError)
-
-    @d.count.must_equal 0
-  end
-
-  it "should handle returning inside of the block by committing" do
-    def DB.ret_commit
-      transaction do
-        self[:test] << {:name => 'abc'}
-        return
-        self[:test] << {:name => 'd'}
-      end
-    end
-    @d.count.must_equal 0
-    DB.ret_commit
-    @d.count.must_equal 1
-    DB.ret_commit
-    @d.count.must_equal 2
-    proc do
-      DB.transaction do
-        raise RuntimeError, 'asdf'
-      end
-    end.must_raise(RuntimeError)
-
-    @d.count.must_equal 2
-  end
-
-  it "should quote and upcase reserved keywords" do
-    @d = DB[:testing]
-    @d.quote_identifiers = true
-    @d.select(:select).sql.must_equal \
-      'SELECT "SELECT" FROM "TESTING"'
-  end
-end
-
-describe "A Firebird dataset with a timestamp field" do
-  before do
-    @d = DB[:test3]
-    @d.delete
-  end
-
-  it "should store milliseconds in time fields" do
-    t = Time.now
-    @d << {:val=>1, :time_stamp=>t}
-    @d.literal(@d[:val =>'1'][:time_stamp]).must_equal @d.literal(t)
-    @d[:val=>'1'][:time_stamp].usec.must_equal t.usec - t.usec % 100
-  end
-end
-
-describe "A Firebird database" do
-  before do
-    @db = DB
-    @db.drop_table?(:posts)
-    @db.sqls.clear
-  end
-
-  it "should allow us to name the sequences" do
-    @db.create_table(:posts){primary_key :id, :sequence_name => "seq_test"}
-    check_sqls do
-      @db.sqls.must_equal [
-        "DROP SEQUENCE SEQ_TEST",
-        "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
-        "CREATE SEQUENCE SEQ_TEST",
-        "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_test;\n                end\n              end\n\n"
-      ]
-    end
-  end
-
-  it "should allow us to set the starting position for the sequences" do
-    @db.create_table(:posts){primary_key :id, :sequence_start_position => 999}
-    check_sqls do
-      @db.sqls.must_equal [
-        "DROP SEQUENCE SEQ_POSTS_ID",
-        "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
-        "CREATE SEQUENCE SEQ_POSTS_ID",
-        "ALTER SEQUENCE SEQ_POSTS_ID RESTART WITH 999",
-        "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
-      ]
-    end
-  end
-
-  it "should allow us to name and set the starting position for the sequences" do
-    @db.create_table(:posts){primary_key :id, :sequence_name => "seq_test", :sequence_start_position => 999}
-    check_sqls do
-      @db.sqls.must_equal [
-        "DROP SEQUENCE SEQ_TEST",
-        "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
-        "CREATE SEQUENCE SEQ_TEST",
-        "ALTER SEQUENCE SEQ_TEST RESTART WITH 999",
-        "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_test;\n                end\n              end\n\n"
-      ]
-    end
-  end
-
-  it "should allow us to name the triggers" do
-    @db.create_table(:posts){primary_key :id, :trigger_name => "trig_test"}
-    check_sqls do
-      @db.sqls.must_equal [
-        "DROP SEQUENCE SEQ_POSTS_ID",
-        "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
-        "CREATE SEQUENCE SEQ_POSTS_ID",
-        "          CREATE TRIGGER TRIG_TEST for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
-      ]
-    end
-  end
-
-  it "should allow us to not create the sequence" do
-    @db.create_table(:posts){primary_key :id, :create_sequence => false}
-    check_sqls do
-      @db.sqls.must_equal [
-        "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
-        "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
-      ]
-    end
-  end
-
-  it "should allow us to not create the trigger" do
-    @db.create_table(:posts){primary_key :id, :create_trigger => false}
-    check_sqls do
-      @db.sqls.must_equal [
-        "DROP SEQUENCE SEQ_POSTS_ID",
-        "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
-        "CREATE SEQUENCE SEQ_POSTS_ID",
-      ]
-    end
-  end
-
-  it "should allow us to not create either the sequence nor the trigger" do
-    @db.create_table(:posts){primary_key :id, :create_sequence => false, :create_trigger => false}
-    check_sqls do
-      @db.sqls.must_equal [
-        "CREATE TABLE POSTS (ID integer PRIMARY KEY )"
-      ]
-    end
-  end
-
-  it "should support column operations" do
-    @db.create_table!(:test2){varchar :name, :size => 50; integer :val}
-    @db[:test2] << {}
-    @db[:test2].columns.must_equal [:name, :val]
-
-    @db.add_column :test2, :xyz, :varchar, :size => 50
-    @db[:test2].columns.must_equal [:name, :val, :xyz]
-
-    @db[:test2].columns.must_equal [:name, :val, :xyz]
-    @db.drop_column :test2, :xyz
-
-    @db[:test2].columns.must_equal [:name, :val]
-
-    @db[:test2].delete
-    @db.add_column :test2, :xyz, :varchar, :default => '000', :size => 50#, :create_domain => 'xyz_varchar'
-    @db[:test2] << {:name => 'mmm', :val => 111, :xyz => 'qqqq'}
-
-    @db[:test2].columns.must_equal [:name, :val, :xyz]
-    @db.rename_column :test2, :xyz, :zyx
-    @db[:test2].columns.must_equal [:name, :val, :zyx]
-    @db[:test2].first[:zyx].must_equal 'qqqq'
-
-    @db.add_column :test2, :xyz, :decimal, :elements => [12, 2]
-    @db[:test2].delete
-    @db[:test2] << {:name => 'mmm', :val => 111, :xyz => 56.4}
-    @db.set_column_type :test2, :xyz, :varchar, :size => 50
-
-    @db[:test2].first[:xyz].must_equal "56.40"
-  end
-
-  it "should allow us to retrieve the primary key for a table" do
-    @db.create_table!(:test2){primary_key :id}
-    @db.primary_key(:test2).must_equal ["id"]
-  end
-end
-
-describe "Postgres::Dataset#insert" do
-  before do
-    @ds = DB[:test5]
-    @ds.delete
-  end
-
-  it "should have insert_returning_sql use the RETURNING keyword" do
-    @ds.insert_returning_sql(:XID, :val=>10).must_equal "INSERT INTO TEST5 (VAL) VALUES (10) RETURNING XID"
-    @ds.insert_returning_sql('*'.lit, :val=>10).must_equal "INSERT INTO TEST5 (VAL) VALUES (10) RETURNING *"
-    @ds.insert_returning_sql('NULL'.lit, :val=>10).must_equal "INSERT INTO TEST5 (VAL) VALUES (10) RETURNING NULL"
-  end
-
-  it "should correctly return the inserted record's primary key value" do
-    value1 = 10
-    id1 = @ds.insert(:val=>value1)
-    @ds.first(:XID=>id1)[:val].must_equal value1
-    value2 = 20
-    id2 = @ds.insert(:val=>value2)
-    @ds.first(:XID=>id2)[:val].must_equal value2
-  end
-
-  it "should return nil if the table has no primary key" do
-    ds = DB[:test]
-    ds.delete
-    ds.insert(:name=>'a').must_equal nil
-  end
-end
-
-describe "Postgres::Dataset#insert" do
-  before do
-    @ds = DB[:test6]
-    @ds.delete
-  end
-
-  it "should insert and retrieve a blob successfully" do
-    value1 = "\1\2\2\2\2222\2\2\2"
-    value2 = "abcd"
-    value3 = "efgh"
-    value4 = "ijkl"
-    id1 = @ds.insert(:val=>value1, :val2=>value2, :val3=>value3, :val4=>value4)
-    @ds.first(:XID=>id1)[:val].must_equal value1
-    @ds.first(:XID=>id1)[:val2].must_equal value2
-    @ds.first(:XID=>id1)[:val3].must_equal value3
-    @ds.first(:XID=>id1)[:val4].must_equal value4
-  end
-end