amalgalite 1.6.0-x64-mingw32

data/lib/amalgalite/type_maps/storage_map.rb

@@ -0,0 +1,38 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+module Amalgalite::TypeMaps
+  ##
+  # An Amalagliate TypeMap that has a one-to-one conversion between SQLite types
+  # and Ruby classes
+  #
+  class StorageMap < ::Amalgalite::TypeMap
+    ##
+    # A straight logical mapping (for me at least) of basic Ruby classes to SQLite types, if
+    # nothing can be found then default to TEXT.
+    #
+    def bind_type_of( obj )
+      case obj
+      when Float
+        ::Amalgalite::SQLite3::Constants::DataType::FLOAT
+      when Integer
+        ::Amalgalite::SQLite3::Constants::DataType::INTEGER
+      when NilClass
+        ::Amalgalite::SQLite3::Constants::DataType::NULL
+      when ::Amalgalite::Blob
+        ::Amalgalite::SQLite3::Constants::DataType::BLOB
+      else
+        ::Amalgalite::SQLite3::Constants::DataType::TEXT
+      end
+    end
+
+    ##
+    # Do no mapping, just return the value as it was retrieved from SQLite.
+    #
+    def result_value_of( delcared_type, value )
+      return value
+    end
+  end
+end

data/lib/amalgalite/type_maps/text_map.rb

@@ -0,0 +1,21 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+#
+
+module Amalgalite::TypeMaps
+  ##
+  # An Amalagliate TypeMap that converts both bind parameters and result
+  # parameters to a String, no matter what.
+  #
+  class TextMap < ::Amalgalite::TypeMap
+    def bind_type_of( obj )
+      return ::Amalgalite::SQLite3::Constants::DataType::TEXT
+    end
+
+    def result_value_of( delcared_type, value )
+      return value.to_s
+    end
+  end
+end

data/lib/amalgalite/version.rb

@@ -0,0 +1,8 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for licensing details
+#++
+
+module Amalgalite
+  VERSION = "1.6.0"
+end

data/lib/amalgalite/view.rb

@@ -0,0 +1,26 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+module Amalgalite
+  #
+  # a class representing the meta information about an SQLite view
+  #
+  class View
+    # the schame this view is assciated with
+    attr_accessor :schema
+
+    # the table name
+    attr_reader   :name
+
+    # the original sql that was used to create this table
+    attr_reader   :sql
+
+    def initialize( name, sql ) 
+      @name    = name
+      @sql     = sql
+    end
+  end
+end
+

data/spec/aggregate_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+class AggregateTest1 < ::Amalgalite::Aggregate
+  def initialize
+    @name = 'atest1'
+    @arity = -1
+    @count = 0
+  end
+  def step( *args )
+    @count += 1
+  end
+  def finalize
+    return @count
+  end
+end
+
+
+describe "Aggregate SQL Functions" do
+
+  it "must have a finalize method implemented" do
+    ag = ::Amalgalite::Aggregate.new
+    lambda { ag.finalize }.should raise_error( NotImplementedError, /Aggregate#finalize must be implemented/ )
+  end
+
+  it "can define a custom SQL aggregate as a class with N params" do
+    @iso_db.define_aggregate("atest1", AggregateTest1 )
+    r = @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country")
+    r.first['a'].should eql(r.first['c'])
+    r.first['a'].should eql(242)
+  end
+
+  it "can remove a custom SQL aggregate by class" do
+    @iso_db.define_aggregate("atest1", AggregateTest1 )
+    @iso_db.aggregates.size.should eql(1)
+    r = @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country")
+    r.first['a'].should eql(r.first['c'])
+    r.first['a'].should eql(242)
+    @iso_db.remove_aggregate( "atest1", AggregateTest1 )
+    @iso_db.aggregates.size.should eql(0)
+    lambda{ @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country") }.should raise_error(::Amalgalite::SQLite3::Error, /no such function: atest1/ )
+  end
+
+  it "can remove a custom SQL aggregate by arity" do
+    @iso_db.define_aggregate("atest1", AggregateTest1 )
+    @iso_db.aggregates.size.should eql(1)
+    r = @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country")
+    r.first['a'].should eql(r.first['c'])
+    r.first['a'].should eql(242)
+    @iso_db.remove_aggregate( "atest1", -1)
+    @iso_db.aggregates.size.should eql(0)
+    lambda{ @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country") }.should raise_error(::Amalgalite::SQLite3::Error, /no such function: atest1/ )
+  end
+
+  it "can remove all custom SQL aggregates with the same name" do
+    class AT2 < AggregateTest1
+      def arity() 1; end
+    end
+    @iso_db.define_aggregate("atest1", AggregateTest1 )
+    @iso_db.define_aggregate("atest1", AT2)
+    @iso_db.aggregates.size.should eql(2)
+    r = @iso_db.execute("SELECT atest1(id,name) as a, atest1(id), count(*) as c FROM country")
+    r.first['a'].should eql(r.first['c'])
+    r.first['a'].should eql(242)
+    @iso_db.remove_aggregate( "atest1" )
+    @iso_db.aggregates.size.should eql(0)
+    lambda{ @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country") }.should raise_error(::Amalgalite::SQLite3::Error, /no such function: atest1/ )
+  end
+
+
+
+  it "does not allow mixing of arbitrary and mandatory arguments to an SQL function" do
+    class AggregateTest2 < AggregateTest1
+      def name() "atest2"; end
+      def arity() -2; end
+    end
+    lambda { @iso_db.define_aggregate("atest2", AggregateTest2 ) }.should raise_error( ::Amalgalite::Database::AggregateError, 
+                                                    /Use only mandatory or arbitrary parameters in an SQL Aggregate, not both/ )
+  end
+
+  it "does not allow outrageous arity" do
+    class AggregateTest3 < AggregateTest1
+      def name() "atest3"; end
+      def arity() 128; end
+    end
+    lambda { @iso_db.define_aggregate("atest3", AggregateTest3 ) }.should raise_error( ::Amalgalite::SQLite3::Error, /SQLITE_ERROR .* Library used incorrectly/ )
+  end
+
+  it "does not allow registering a function which does not match the defined name " do
+    class AggregateTest4 < AggregateTest1
+      def name() "name_mismatch"; end
+    end
+    lambda { @iso_db.define_aggregate("atest4", AggregateTest4 ) }.should raise_error( ::Amalgalite::Database::AggregateError,
+                                           /Aggregate implementation name 'name_mismatch' does not match defined name 'atest4'/)
+  end
+
+  it "handles an error being thrown during the step function" do
+    class AggregateTest5 < AggregateTest1
+      def initialize
+        @name = "atest5"
+        @arity = -1
+        @count = 0
+      end
+
+      def step( *args )
+        @count += 1
+        if @count > 50 then
+          raise "Stepwise error!" if @count > 50
+        end
+      end
+
+    end
+
+    @iso_db.define_aggregate( "atest5", AggregateTest5 )
+    lambda { @iso_db.execute( "SELECT atest5(*) AS a FROM country" ) }.should raise_error( ::Amalgalite::SQLite3::Error, /Stepwise error!/ )
+  end
+
+  it "handles an error being thrown during the finalize function" do
+    class AggregateTest6 < AggregateTest1
+      def initialize
+        @name = "atest6"
+        @count = 0
+        @arity = -1
+      end
+      def finalize
+        raise "Finalize error!"
+      end
+    end
+    @iso_db.define_aggregate( "atest6", AggregateTest6 )
+    lambda { @iso_db.execute( "SELECT atest6(*) AS a FROM country" ) }.should raise_error( ::Amalgalite::SQLite3::Error, /Finalize error!/ )
+  end
+
+  it "handles an error being thrown during initialization in the C extension" do
+    class AggregateTest7 < AggregateTest1
+      def self.called?
+        if @called then
+          raise "Initialization error!"
+        else
+          @called = true
+        end
+      end
+
+      def initialize
+        super
+        @name = "atest7"
+        @count = 0
+        @arity = -1
+        self.class.called?
+      end
+    end
+    @iso_db.define_aggregate( "atest7", AggregateTest7 )
+    lambda { @iso_db.execute( "SELECT atest7(*) AS a FROM country" ) }.should raise_error( ::Amalgalite::SQLite3::Error, /Initialization error!/ )
+  end
+end
+

data/spec/amalgalite_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Amalgalite do
+end

data/spec/blob_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Amalgalite::Blob do
+
+  before(:each) do
+    @blob_db_name = File.join(File.dirname( __FILE__ ), "blob.db")
+    File.unlink @blob_db_name if File.exist?( @blob_db_name )
+    @db = Amalgalite::Database.new( @blob_db_name )
+    @schema_sql = <<-SQL
+      CREATE TABLE blobs(
+        id      INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        name    VARCHAR(128) NOT NULL UNIQUE,
+        data    TEXT ); 
+    SQL
+    @db.execute( @schema_sql )
+    @country_data_file = Amalgalite::Iso3166Database.country_data_file
+    @junk_file = File.join( File.dirname(__FILE__), "test_output")
+  end
+
+  after(:each) do
+    @db.close
+    File.unlink @blob_db_name if File.exist?( @blob_db_name )
+    File.unlink @junk_file    if File.exist?( @junk_file )
+  end
+
+  { :file   => Amalgalite::Iso3166Database.country_data_file,
+    :string => IO.read( Amalgalite::Iso3166Database.country_data_file),
+    :io     => StringIO.new( IO.read( Amalgalite::Iso3166Database.country_data_file) ) }.each_pair do |style, data |
+    describe "inserts a blob from a #{style}" do
+      before(:each) do
+        column = @db.schema.tables['blobs'].columns['data']
+        @db.execute("INSERT INTO blobs(name, data) VALUES ($name, $data)",
+                    { "$name" => @country_data_file,
+                      "$data" => Amalgalite::Blob.new( style => data,
+                                                      :column => column ) } )
+        @db.execute("VACUUM")
+      end
+
+      after(:each) do
+        @db.execute("DELETE FROM blobs")
+        data.rewind if data.respond_to?( :rewind )
+      end
+
+      it "and retrieves the data as a single value" do
+        all_rows = @db.execute("SELECT name,data FROM blobs")
+        all_rows.size.should eql(1)
+        all_rows.first['name'].should eql(@country_data_file)
+        all_rows.first['data'].should_not be_incremental
+        all_rows.first['data'].to_string_io.string.should eql(IO.read( @country_data_file ))
+      end
+
+      it "and retrieves the data using incremental IO" do
+        all_rows = @db.execute("SELECT * FROM blobs")
+        all_rows.size.should eql(1)
+        all_rows.first['name'].should eql(@country_data_file)
+        all_rows.first['data'].should be_incremental
+        all_rows.first['data'].to_string_io.string.should eql(IO.read( @country_data_file ))
+      end
+
+      it "writes the data to a file " do
+        all_rows = @db.execute("SELECT * FROM blobs")
+        all_rows.size.should eql(1)
+        all_rows.first['name'].should eql(@country_data_file)
+        all_rows.first['data'].should be_incremental
+        all_rows.first['data'].write_to_file( @junk_file )
+        IO.read( @junk_file).should eql(IO.read( @country_data_file ))
+      end
+    end
+  end
+
+
+
+  it "raises an error if initialized incorrectly" do
+    lambda{ Amalgalite::Blob.new( :file => "/dev/null", :string => "foo" ) }.should raise_error( Amalgalite::Blob::Error )
+  end
+end
+
+

data/spec/boolean_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+require 'amalgalite'
+require 'amalgalite/boolean'
+
+describe Amalgalite::Boolean do
+  %w[ True Y Yes T 1 ].each do |v|
+    it "converts #{v} to true" do
+      Amalgalite::Boolean.to_bool(v).should == true
+    end
+  end
+
+  %w[ False F f No n 0 ].each do |v|
+    it "converts #{v} to false " do
+      Amalgalite::Boolean.to_bool(v).should == false
+    end
+  end
+
+  %w[ other things nil ].each do |v|
+    it "converts #{v} to nil" do
+      Amalgalite::Boolean.to_bool(v).should == nil
+    end
+  end
+end

data/spec/busy_handler.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+class BusyHandlerTest < Amalgalite::BusyHandler
+  attr_accessor :call_count
+  def initialize( max = 5 )
+    @max = max
+    @call_count = 0
+  end
+
+  def call( c )
+    @call_count += 1
+    if call_count >= @max then
+      return false
+    end
+    return true
+  end
+end
+
+describe "Busy Handlers" do
+  before(:each) do
+    @read_db = Amalgalite::Database.new( @iso_db_path )
+    @write_db = Amalgalite::Database.new( @iso_db_path )
+  end
+
+  after(:each) do
+    @write_db.close
+    @read_db.close
+  end
+
+  it "raises NotImplemented if #call is not overwritten" do
+    bh = ::Amalgalite::BusyHandler.new
+    lambda { bh.call( 42 ) }.should raise_error( ::NotImplementedError, /The busy handler call\(N\) method must be implemented/ )
+  end
+
+  it "can be registered as block" do
+    call_count = 0
+    @write_db.busy_handler do |x|
+      call_count = x
+      if call_count >= 20 then
+        false
+      else
+        true
+      end
+    end
+
+    # put a read lock on the database
+    @read_db.transaction( "DEFERRED" )
+
+    # put a read lock on the database, but want to go to an exclusive
+    @write_db.transaction( "IMMEDIATE" )
+
+    # do a read operation
+    @read_db.execute("SELECT count(*) FROM subcountry")
+
+    # attempt to do a write operation and commit it
+    @write_db.execute("DELETE FROM subcountry")
+    lambda { @write_db.execute("COMMIT"); }.should raise_error( ::Amalgalite::SQLite3::Error, /database is locked/ )
+    call_count.should == 20
+  end
+
+  it "can be registered as lambda" do
+    call_count = 0
+    callable = lambda do |x|
+      call_count = x
+      if call_count >= 40 then
+        false
+      else
+        true
+      end
+    end
+
+    @write_db.busy_handler( callable )
+
+    # put a read lock on the database
+    @read_db.transaction( "DEFERRED" )
+
+    # put a read lock on the database, but want to go to an exclusive
+    @write_db.transaction( "IMMEDIATE" )
+
+    # do a read operation
+    @read_db.execute("SELECT count(*) FROM subcountry")
+
+    # attempt to do a write operation and commit it
+    @write_db.execute("DELETE FROM subcountry")
+    lambda { @write_db.execute("COMMIT"); }.should raise_error( ::Amalgalite::SQLite3::Error, /database is locked/ )
+    call_count.should == 40
+  end
+
+  it "can be registered as a class" do
+    h = BusyHandlerTest.new( 10 )
+    @write_db.busy_handler( h )
+
+    # put a read lock on the database
+    @read_db.transaction( "DEFERRED" )
+
+    # put a read lock on the database, but want to go to an exclusive
+    @write_db.transaction( "IMMEDIATE" )
+
+    # do a read operation
+    @read_db.execute("SELECT count(*) FROM subcountry")
+
+    # attempt to do a write operation and commit it
+    @write_db.execute("DELETE FROM subcountry")
+    lambda { @write_db.execute("COMMIT"); }.should raise_error( ::Amalgalite::SQLite3::Error, /database is locked/ )
+    h.call_count.should == 10
+  end
+
+  it "has a default timeout class available " do
+    to = ::Amalgalite::BusyTimeout.new( 5, 10 ) 
+    @write_db.busy_handler( to )
+
+    # put a read lock on the database
+    @read_db.transaction( "DEFERRED" )
+
+    # put a read lock on the database, but want to go to an exclusive
+    @write_db.transaction( "IMMEDIATE" )
+
+    # do a read operation
+    @read_db.execute("SELECT count(*) FROM subcountry")
+
+    # attempt to do a write operation and commit it
+    @write_db.execute("DELETE FROM subcountry")
+    before = Time.now
+    lambda { @write_db.execute("COMMIT"); }.should raise_error( ::Amalgalite::SQLite3::Error, /database is locked/ )
+    after = Time.now
+    to.call_count.should > 5
+    (after - before).should > 0.05
+  end
+
+  it "cannot register a block with the wrong arity" do
+    lambda do 
+      @write_db.define_busy_handler { |x,y| puts "What!" }
+    end.should raise_error( ::Amalgalite::Database::BusyHandlerError, /A busy handler expects 1 and only 1 argument/ )
+  end
+
+  it "can remove a busy handler" do
+    bht = BusyHandlerTest.new
+
+    @write_db.busy_handler( bht )
+
+    # put a read lock on the database
+    @read_db.transaction( "DEFERRED" )
+
+    # put a read lock on the database, but want to go to an exclusive
+    @write_db.transaction( "IMMEDIATE" )
+
+    # do a read operation
+    @read_db.execute("SELECT count(*) FROM subcountry")
+
+    # attempt to do a write operation and commit it
+    @write_db.execute("DELETE FROM subcountry")
+    @write_db.remove_busy_handler
+    lambda { @write_db.execute("COMMIT"); }.should raise_error( ::Amalgalite::SQLite3::Error, /database is locked/ )
+    bht.call_count.should == 0
+  end
+
+end