libsql 0.1.0-x86-mingw32

data/spec/data/make-iso-db.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+DB="iso-3166.db"
+SCHEMA="iso-3166-schema.sql"
+
+rm -f ${DB}
+sqlite3 ${DB} < ${SCHEMA}
+echo ".import iso-3166-country.txt country" | sqlite3 ${DB} 
+echo ".import iso-3166-subcountry.txt subcountry" | sqlite3 ${DB} 
+
+sqlite3 ${DB} "select 'country_count',  count(1) from country"
+sqlite3 ${DB} "select 'subcountry_count', count(1) from subcountry"

data/spec/database_spec.rb

@@ -0,0 +1,505 @@
+require 'spec_helper'
+
+require 'thread'
+require 'libsql'
+require 'libsql/taps/io'
+require 'libsql/taps/console'
+require 'libsql/database'
+
+describe ::Libsql::Database do
+
+  it "can create a new database" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    db.instance_of?(::Libsql::Database) 
+    db.api.instance_of?(::Libsql::SQLite3::Database) 
+    File.exist?( SpecInfo.test_db ).should eql(true)
+  end
+
+  it "creates a new UTF-8 database (need exec to check pragma encoding)" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    db.execute_batch( @schema );
+    db.should_not be_utf16
+    db.encoding.should eql("UTF-8")
+  end
+
+  it "creates a new UTF-16 database (need exec to check pragma encoding)" 
+
+  it "raises an error if the file does not exist and the database is opened with a non-create mode" do
+    lambda { ::Libsql::Database.new( SpecInfo.test_db, "r") }.should raise_error(::Libsql::SQLite3::Error)
+    lambda { ::Libsql::Database.new( SpecInfo.test_db, "r+") }.should raise_error(::Libsql::SQLite3::Error)
+  end
+
+  it "raises an error if an invalid mode is used" do
+    lambda { ::Libsql::Database.new( SpecInfo.test_db, "b+" ) }.should raise_error(::Libsql::Database::InvalidModeError)
+  end
+
+  it "can be in autocommit mode, and is by default" do
+    @iso_db.autocommit?.should eql(true)
+  end
+
+  it "reports false for autocommit? when inside a transaction" do
+    @iso_db.execute(" BEGIN ")
+    @iso_db.autocommit?.should eql(false)
+    @iso_db.in_transaction?.should eql(true)
+    @iso_db.execute(" COMMIT")
+    @iso_db.in_transaction?.should eql(false)
+  end
+
+  it "prepares a statment" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    stmt = db.prepare("SELECT datetime()")
+    stmt.instance_of?(::Libsql::Statement)
+    stmt.api.instance_of?(::Libsql::SQLite3::Statement)
+  end
+
+  it "raises an error on invalid syntax when preparing a bad sql statement" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    lambda { db.prepare("SELECT nothing FROM stuf") }.should raise_error(::Libsql::SQLite3::Error)
+  end
+
+  it "closes normally" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    expect { db.close }.not_to raise_error
+  end
+
+  it "returns the id of the last inserted row" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    db.last_insert_rowid.should eql(0)
+  end
+
+  it "is in autocommit mode by default" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    db.should be_autocommit
+  end
+
+  it "report the number of rows changed with an insert" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    db.execute_batch <<-sql
+      CREATE TABLE t1( x );
+      INSERT INTO t1( x ) values ( 1 );
+      INSERT INTO t1( x ) values ( 2 );
+      INSERT INTO t1( x ) values ( 3 );
+    sql
+
+    db.row_changes.should eql(1)
+    db.total_changes.should eql(3)
+    db.close
+  end
+
+  it "reports the number of rows deleted" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    db.execute_batch <<-sql
+      CREATE TABLE t1( x );
+      INSERT INTO t1( x ) values ( 1 );
+      INSERT INTO t1( x ) values ( 2 );
+      INSERT INTO t1( x ) values ( 3 );
+      DELETE FROM t1 where x < 3;
+    sql
+    db.row_changes.should eql(2)
+    db.close
+  end
+
+  it "can immediately execute an sql statement " do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    db.execute( "CREATE TABLE t1( x, y, z )" ).should be_empty
+  end
+
+  it "can execute a batch of commands" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    db.execute_batch( @schema ).should eql(5)
+  end
+
+  it "returns an empty array when there are no results" do
+    row = @iso_db.execute("SELECT * from subcountry where country = 'Antarctica'")
+    row.should be_empty
+  end
+
+  it "traces the execution of code" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    sql = "CREATE TABLE trace_test( x, y, z)"
+    s = db.trace_tap = ::Libsql::Taps::StringIO.new
+    db.execute( sql )
+    escaped_sql= Regexp.quote(sql)
+    db.trace_tap.string.should match(/registered as trace tap/)
+    db.trace_tap.string.should match(/#{escaped_sql}/)
+    s.trace_count.should eql(2)
+    db.trace_tap = nil
+    s.trace_count.should eql(3)
+    s.string.should match(/unregistered as trace tap/)
+  end
+
+  it "raises an exception if the wrong type of object is used for tracing" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    lambda { db.trace_tap = Object.new }.should raise_error(::Libsql::Error)
+  end
+
+  it "profiles the execution of code" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    s = db.trace_tap = ::Libsql::Taps::StringIO.new
+    db.execute_batch( @schema )
+    db.trace_tap.samplers.size.should eql(5)
+    db.trace_tap = nil
+    s.string.should =~ /unregistered as trace tap/
+  end
+
+  it "#execute yields each row when called with a block" do
+    count = 0
+    @iso_db.execute( "SELECT * FROM country LIMIT 10") do |row|
+      count += 1
+    end
+    count.should eql(10)
+  end
+
+  it "#pragma yields each row when called with a block" do
+    count = 0
+    @iso_db.pragma( "index_info( subcountry_country )" ) do |row|
+      count += 1
+    end
+    count.should eql(1)
+  end
+
+  it "can use something that responds to 'write' as a tap" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    s2 = db.trace_tap   = StringIO.new
+    s2.string.should eql("registered as trace tap")
+  end
+
+  it "can clear all registered taps" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    s = db.trace_tap = ::Libsql::Taps::StringIO.new
+    db.execute_batch( @schema )
+    db.trace_tap.samplers.size.should eql(5)
+    db.clear_taps!
+    s.string.should =~ /unregistered as trace tap/m
+  end
+
+  it "allows nested transactions even if SQLite under the covers does not" do
+    db = ::Libsql::Database.new( SpecInfo.test_db )
+    r = db.transaction do |db2|
+      r2 = db.transaction { 42 }
+      r2.should eql(42)
+      r2
+    end
+    r.should eql(42)
+  end
+
+  %w[ transaction deferred_transaction immediate_transaction exclusive_transaction ].each do |trans|
+    it "returns the result of the #{trans} when a block is yielded" do
+      db = ::Libsql::Database.new( SpecInfo.test_db )
+      (db.send( trans ){ 42 }).should eql(42)
+    end
+  end
+
+  it "#reload_schema!" do
+    schema = @iso_db.schema
+    schema.instance_of?( ::Libsql::Schema ).should eql(true)
+    s2 = @iso_db.reload_schema!
+    s2.object_id.should_not eql(schema.object_id)
+  end
+
+  it "can rollback a transaction" do
+    @iso_db.transaction 
+    r = @iso_db.execute("SELECT count(1) as cnt FROM country");
+    r.first['cnt'].should eql(242)
+    @iso_db.execute("DELETE FROM country")
+    r = @iso_db.execute("SELECT count(1) as cnt FROM country");
+    r.first['cnt'].should eql(0)
+    @iso_db.rollback
+
+    r = @iso_db.execute("SELECT count(1) as cnt FROM country");
+    r.first['cnt'].should eql(242)
+  end
+
+  it "rolls back if an exception happens during a transaction block" do
+    begin
+      @iso_db.transaction do |db|
+        r = db.execute("SELECT count(1) as cnt FROM country");
+        r.first['cnt'].should eql(242)
+        db.execute("DELETE FROM country")
+        db.in_transaction?.should eql(true)
+        raise "testing rollback"
+      end
+    rescue
+      @iso_db.in_transaction?.should eql(false)
+      @iso_db.execute("SELECT count(1) as cnt FROM country").first['cnt'].should eql(242)
+    end
+  end
+
+  it "commits if an exception happens during a transaction block but is rescued within the block" do
+    @iso_db.transaction do |db|
+      begin
+        r = db.execute("SELECT count(1) as cnt FROM country");
+        r.first['cnt'].should eql(242)
+        db.execute("DELETE FROM country")
+        db.in_transaction?.should eql(true)
+        raise "testing rollback"
+      rescue => e
+        e.message.should == "testing rollback"
+      end
+      $!.should == nil
+    end
+    @iso_db.in_transaction?.should eql(false)
+    @iso_db.first_value_from("select count(1) as cnt from country").should eql(0)
+  end
+
+  it "does not reraise an exception that exits before the transaction starts" do
+    class MyExceptionTest < RuntimeError; end
+    db = ::Libsql::Database.new( ":memory:" )
+
+    lambda {
+      begin
+        raise MyExceptionTest, "James pointed this out"
+      rescue MyExceptionTest
+        db.transaction("EXCLUSIVE") { }
+      end
+    }.should_not raise_error
+  end
+
+  describe "#define_function" do
+   it "does not allow mixing of arbitrary and mandatory arguments to an SQL function" do
+      class DBFunctionTest2 < ::Libsql::Function
+        def initialize
+          super( 'ftest2', -2 )
+        end
+        def call( a, *args ); end
+      end
+      lambda { @iso_db.define_function("ftest2", DBFunctionTest2.new ) }.should raise_error( ::Libsql::Database::FunctionError )
+    end
+
+    it "does not allow outrageous arity" do
+      class DBFunctionTest3 < ::Libsql::Function
+        def initialize
+          super( 'ftest3', 128 )
+        end
+        def call( *args) ; end
+      end
+      lambda { @iso_db.define_function("ftest3", DBFunctionTest3.new ) }.should raise_error( ::Libsql::SQLite3::Error )
+    end
+
+ end
+
+  describe "#remove_function" do
+    it "unregisters a single function by name and arity" do
+      @iso_db.define_function( "rtest1" ) do
+        "rtest1 called"
+      end
+
+      @iso_db.functions.size.should eql(1 )
+
+      r = @iso_db.execute( "select rtest1() AS r" )
+      r.first['r'].should eql("rtest1 called")
+      @iso_db.remove_function("rtest1")
+
+      lambda { @iso_db.execute( "select rtest1() as r" )}.should raise_error( ::Libsql::SQLite3::Error, /no such function: rtest1/ )
+      @iso_db.functions.size.should eql(0)
+    end
+
+    it "unregisters a function by instances" do
+      class FunctionTest5 < ::Libsql::Function
+        def initialize
+          super( 'ftest5', 0)
+        end
+        def call( *args) "ftest5 called"; end
+      end
+      @iso_db.define_function("ftest5", FunctionTest5.new )
+      @iso_db.functions.size.should eql(1)
+      r = @iso_db.execute( "select ftest5() AS r" )
+      r.first['r'].should eql("ftest5 called")
+      @iso_db.remove_function("ftest5", FunctionTest5.new )
+      lambda { @iso_db.execute( "select ftest5() as r" )}.should raise_error( ::Libsql::SQLite3::Error, /no such function: ftest5/ )
+      @iso_db.functions.size.should eql(0)
+    end
+
+    it "unregisters all functions with the same name" do
+      @iso_db.function( "rtest" ) do |x|
+        "rtest #{x} called"
+      end
+
+      @iso_db.function( "rtest" ) do ||
+        "rtest/0 called"
+      end
+
+      @iso_db.functions.size.should eql(2)
+      r = @iso_db.execute( "select rtest(1) AS r")
+      r.first['r'].should eql("rtest 1 called")
+      r = @iso_db.execute( "select rtest() AS r")
+      r.first['r'].should eql("rtest/0 called")
+      @iso_db.remove_function( 'rtest' )
+      lambda {  @iso_db.execute( "select rtest(1) AS r") }.should raise_error( ::Libsql::SQLite3::Error )
+      lambda {  @iso_db.execute( "select rtest() AS r")  }.should raise_error( ::Libsql::SQLite3::Error )
+      @iso_db.functions.size.should eql(0)
+    end
+  end
+
+  it "can interrupt another thread that is also running in this database" do
+    executions = 0
+    control_queue = Queue.new
+    other = Thread.new( @iso_db ) do |db|
+      looping_sent = false
+      c = 0
+      loop do
+        begin
+          db.execute("select * from subcountry")
+          executions += 1
+          if not looping_sent then
+            control_queue.enq :looping 
+            looping_sent = true
+          end
+          if c > 20_000 then
+            break
+          end
+          c += 1
+        rescue => e
+          Thread.current[:loop_count] = c
+          Thread.current[:had_error] = e.dup
+          control_queue.enq :boom
+          break
+        end
+      end
+    end
+
+    rudeness = Thread.new( @iso_db ) do |db|
+      control_queue.deq
+      count = 0
+      loop do
+        @iso_db.interrupt!
+        break unless control_queue.empty?
+        if count > 20_000 then
+          break
+        end
+        count += 1
+      end
+    end
+
+    rudeness.join
+    other.join
+
+    #$stdout.puts " looped #{other[:loop_count]} times"
+    other[:had_error].should be_an_instance_of( ::Libsql::SQLite3::Error )
+    other[:had_error].message.should =~ / interrupted/
+  end
+
+  it "savepoints are considered 'in_transaction'" do
+    @iso_db.savepoint( 'test1' ) do |db|
+      db.should be_in_transaction
+    end
+  end
+
+  it "releases a savepoint" do
+    us_sub = @iso_db.execute( "select count(1) as cnt from subcountry where country = 'US'" ).first['cnt']
+    us_sub.should eql(57)
+    other_sub = @iso_db.execute( "select count(1) as cnt from subcountry where country != 'US'" ).first['cnt']
+
+    @iso_db.transaction
+    @iso_db.savepoint( "t1" ) do |s|
+      s.execute("DELETE FROM subcountry where country = 'US'")
+    end
+
+    all_sub = @iso_db.execute("SELECT count(*) as cnt from subcountry").first['cnt']
+
+    all_sub.should eql(other_sub)
+    @iso_db.rollback
+    all_sub = @iso_db.execute("SELECT count(*) as cnt from subcountry").first['cnt']
+    all_sub.should eql(( us_sub + other_sub ))
+
+  end
+
+  it "rolls back a savepoint" do
+    us_sub  = @iso_db.execute("SELECT count(*) as cnt from subcountry where country = 'US'").first['cnt']
+    lambda {
+      @iso_db.savepoint( "t1" ) do |s|
+        s.execute("DELETE FROM subcountry where country = 'US'")
+        as = @iso_db.execute("SELECT count(*) as cnt from subcountry where country = 'US'").first['cnt']
+        as.should be == 0
+        raise "sample error"
+      end
+    }.should raise_error( StandardError, /sample error/ )
+
+    @iso_db.execute("SELECT count(*) as cnt from subcountry where country = 'US'").first['cnt'].should eql(us_sub)
+  end
+
+  it "rolling back the outermost savepoint is still 'in_transaction'" do
+    @iso_db.savepoint( "t1" )
+    @iso_db.execute("DELETE FROM subcountry where country = 'US'")
+    @iso_db.rollback_to( "t1" )
+    @iso_db.should be_in_transaction
+    @iso_db.rollback
+    @iso_db.should_not be_in_transaction
+  end
+
+  it "can escape quoted strings" do
+    @iso_db.escape( "It's a happy day!" ).should eql("It''s a happy day!")
+  end
+
+  it "can quote and escape single quoted strings" do
+    @iso_db.quote( "It's a happy day!" ).should eql("'It''s a happy day!'")
+  end
+
+  it "can escape a symbol" do
+    @iso_db.escape( :stuff ).should eql("stuff")
+  end
+  
+  it "can quote a symbol" do
+    @iso_db.quote( :stuff ).should eql("'stuff'")
+  end
+
+  it "returns the first row of results as a convenience" do
+    row =  @iso_db.first_row_from("SELECT c.name, c.two_letter, count(*) AS count 
+                                     FROM country c
+                                     JOIN subcountry sc
+                                       ON c.two_letter  = sc.country 
+                                 GROUP BY c.name, c.two_letter
+                                 ORDER BY count DESC")
+    row.length.should eql(3)
+    row[0].should eql("United Kingdom")
+    row[1].should eql("GB")
+    row[2].should eql(232)
+    row['name'].should eql("United Kingdom")
+    row['two_letter'].should eql("GB")
+    row['count'].should eql(232)
+  end
+
+  it "returns and empty row if there are no results for the first row" do
+    row = @iso_db.first_row_from("SELECT * from subcountry where country = 'Antarctica'")
+    row.should be_empty
+  end
+
+  it "returns nil if there is no value in the first value" do
+    val = @iso_db.first_value_from("select * from subcountry where country = 'Antarctica'" )
+    val.should eql(nil)
+  end
+
+  it "returns the first value of results as a conveinience" do
+    val = @iso_db.first_value_from("SELECT count(*) from subcountry ")
+    val.should eql(3995)
+  end
+
+  it "replicates a database to memory" do
+    mem_db = @iso_db.replicate_to( ":memory:" )
+    @iso_db.close
+    val = mem_db.first_value_from("SELECT count(*) from subcountry" )
+    val.should eql(3995)
+  end
+
+  it "replicates a database to a database file" do
+    all_sub = @iso_db.execute("SELECT count(*) as cnt from subcountry").first['cnt']
+
+    fdb = ::Libsql::Database.new( SpecInfo.test_db )
+    @iso_db.replicate_to( fdb )
+    @iso_db.close
+
+    File.exist?( SpecInfo.test_db ).should be == true
+    fdb.execute("SELECT count(*) as cnt from subcountry").first['cnt'].should == all_sub
+  end
+
+  it "raises an error if it is given an invalid location to replicate to" do
+    lambda { @iso_db.replicate_to( false ) }.should raise_error( ArgumentError, /must be a String or a Database/ )
+  end
+
+  it "imports batch statements" do
+    db = ::Libsql::Database.new(":memory:")
+    db.import("CREATE TABLE things(stuff TEXT); INSERT INTO things (stuff) VALUES (\"foobar\");").should be_truthy
+    db.first_value_from("SELECT stuff FROM things").should == "foobar"
+  end
+
+end

data/spec/default_map_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'libsql/type_maps/default_map'
+
+describe ::Libsql::TypeMaps::DefaultMap do
+  before(:each) do
+    @map = ::Libsql::TypeMaps::DefaultMap.new
+  end
+
+  describe "#bind_type_of" do
+
+    it "Float is bound to DataType::FLOAT" do
+      @map.bind_type_of( 3.14 ).should == ::Libsql::SQLite3::Constants::DataType::FLOAT
+    end
+
+    it "Integer is bound to DataType::INTGER" do
+      @map.bind_type_of( 42 ).should == ::Libsql::SQLite3::Constants::DataType::INTEGER
+    end
+
+    it "nil is bound to DataType::NULL" do
+      @map.bind_type_of( nil ).should == ::Libsql::SQLite3::Constants::DataType::NULL
+    end
+
+    it "::Libsql::Blob is bound to DataType::BLOB" do
+      @map.bind_type_of( ::Libsql::Blob.new( :column => true, :string => "just a test" ) ).should == ::Libsql::SQLite3::Constants::DataType::BLOB
+    end
+
+    it "everything else is bound to DataType::TEXT" do
+      @map.bind_type_of( "everything else" ).should == ::Libsql::SQLite3::Constants::DataType::TEXT
+    end
+
+  end
+
+
+  describe "#result_value_of" do
+
+    it "Numeric's are returned" do
+      y = 42
+      x = @map.result_value_of( "INT", 42 )
+      x.object_id.should == y.object_id
+    end
+
+    it "Nil is returned" do
+      @map.result_value_of( "NULL", nil ).should == nil
+    end
+
+    it "DateTime is returned for delcared types of 'datetime'" do
+      @map.result_value_of( "DaTeTiME", "2008-04-01 23:23:23" ).should be_kind_of(DateTime)
+    end
+
+    it "Date is returned for declared types of 'date'" do
+      @map.result_value_of( "date", "2008-04-01 23:42:42" ).should be_kind_of(Date)
+    end
+
+    it "Time is returned for declared types of 'time'" do
+      @map.result_value_of( "timestamp", "2008-04-01T23:42:42" ).should be_kind_of(Time)
+    end
+
+    it "Float is returned for declared types of 'double'" do
+      @map.result_value_of( "double", "3.14" ).should be_kind_of(Float)
+    end
+    
+    it "Float is returned for declared types of 'float'" do
+      @map.result_value_of( "float", "3.14" ).should be_kind_of(Float)
+    end
+
+    it "Integer is returned for declared types of 'int'" do
+      @map.result_value_of( "int", "42" ).should be_kind_of(Integer)
+    end
+
+    it "boolean is returned for declared types of 'bool'" do
+      @map.result_value_of( "bool", "True" ).should == true
+    end
+
+    it "Blob is returned for declared types of 'blob'" do
+      blob = @map.result_value_of( "blob", "stuff")
+      blob.to_s.should == "stuff"
+    end
+
+    it "String is returned for delcared types of 'string'" do
+      @map.result_value_of( "string", "stuff").should == "stuff"
+    end
+
+    it "raises and error if an unknown sql type is returned" do
+      x = nil
+      lambda{ x = @map.result_value_of( "footype", "foo" ) }.should raise_error( ::Libsql::Error )
+    end
+    
+    it "raises and error if an ruby class is attempted to be mapped" do
+      lambda{ @map.result_value_of( "footype", 1..3 ) }.should raise_error( ::Libsql::Error )
+    end
+  end
+end

data/spec/function_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe "Scalar SQL Functions" do
+
+  it "can define a custom SQL function as a block with 0 params" do
+    @iso_db.define_function("foo") do 
+        "foo"
+    end
+    r = @iso_db.execute("SELECT foo() AS f");
+    r.first['f'].should == "foo"
+  end
+
+  it "has a signature" do
+    ::Libsql::Function.new( "testing_name", 42 ).signature.should == "testing_name/42"
+  end
+
+  it "can define a custom SQL function as a lambda with 2 param" do
+    @iso_db.define_function("foo2", lambda{ |x,y| "foo2 -> #{x} #{y}" } )
+    r = @iso_db.execute("SELECT foo2( 'bar', 'baz' ) as f")
+    r.first['f'].should == "foo2 -> bar baz"
+  end
+
+  it "can define a custom SQL function as a class with N params" do
+    class FunctionTest1 < ::Libsql::Function
+      def initialize
+        super('ftest', -1)
+      end
+      def call( *args )
+          "#{args.length} args #{args.join(', ')}"
+      end
+    end
+
+    @iso_db.define_function("ftest1", FunctionTest1.new )
+    r = @iso_db.execute("SELECT ftest1(1,2,3,'baz') as f")
+    r.first['f'].should == "4 args 1, 2, 3, baz"
+  end
+
+  [ [   1,   lambda { true  } ],
+    [   0,   lambda { false } ],
+    [   nil, lambda { nil   } ],
+    [ "foo", lambda { "foo" } ],
+    [ 42,    lambda { 42 }    ],
+    [ 42.2 , lambda { 42.2 }  ], ].each do |expected, func|
+    it "returns the appropriate class #{expected.class} " do
+      @iso_db.define_function("ctest", func )
+      r = @iso_db.execute( "SELECT ctest() AS c" )
+      r.first['c'].should == expected
+    end
+  end
+
+  it "does not allow outrageous arity" do
+    class FunctionTest3 < ::Libsql::Function
+      def initialize
+        super( 'ftest3', 128)
+      end
+    end
+    lambda { @iso_db.define_function("ftest3", FunctionTest3.new) }.should raise_error( ::Libsql::SQLite3::Error, /SQLITE_ERROR .* Library used incorrectly/ )
+  end
+
+  it "raises an error if the function returns a complex Ruby object" do
+    l = lambda { Hash.new }
+    @iso_db.define_function("htest", l)
+    begin
+      @iso_db.execute( "SELECT htest() AS h" ) 
+    rescue => e
+      e.should be_instance_of( ::Libsql::SQLite3::Error )
+      e.message.should =~ /Unable to convert ruby object to an SQL function result/
+    end
+  end
+
+  it "an error raised during the sql function is handled correctly" do
+    @iso_db.define_function( "etest" ) do 
+      raise "error from within an sql function"
+    end
+    lambda { @iso_db.execute( "SELECT etest() AS e" ) }.should raise_error( ::Libsql::SQLite3::Error, /error from within an sql function/ )
+  end
+end
+