amalgalite 0.4.2-x86-mswin32-60

data/lib/amalgalite/type_maps/text_map.rb

@@ -0,0 +1,23 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+#
+require 'amalgalite/type_map'
+require 'amalgalite3'
+
+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,37 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for licensingn details
+#++
+
+module Amalgalite
+  # Version information for Amagalite
+  module Version
+
+    MAJOR   = 0
+    MINOR   = 4
+    BUILD   = 2
+
+    #
+    # return the Version as an array of MAJOR, MINOR, BUILD
+    #
+    def self.to_a 
+      [MAJOR, MINOR, BUILD]
+    end
+
+    # return the Version as a dotted String MAJOR.MINOR.BUILD
+    def self.to_s
+      to_a.join(".")
+    end
+
+    # return the Vesion as a hash 
+    def self.to_hash
+      { :major => MAJOR, :minor => MINOR, :build => BUILD }
+    end
+
+    # Version string constant
+    STRING = Version.to_s.freeze
+  end
+
+  # Version string constant
+  VERSION = Version.to_s.freeze
+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/amalgalite_spec.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+
+describe Amalgalite do
+end

data/spec/blob_spec.rb

@@ -0,0 +1,81 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite'
+
+describe Amalgalite::Blob do
+  DATA_FILE = File.expand_path( File.join( File.dirname(__FILE__), "iso-3166-country.txt" ) )
+  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 )
+    @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   => DATA_FILE,
+    :string => IO.read( DATA_FILE ),
+    :io     => StringIO.new( IO.read( 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" => 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 == 1;
+        all_rows.first['name'].should == DATA_FILE
+        all_rows.first['data'].should_not be_incremental
+        all_rows.first['data'].to_string_io.string.should == IO.read( DATA_FILE )
+      end
+
+      it "and retrieves the data using incremental IO" do
+        all_rows = @db.execute("SELECT * FROM blobs")
+        all_rows.size.should == 1;
+        all_rows.first['name'].should == DATA_FILE
+        all_rows.first['data'].should be_incremental
+        all_rows.first['data'].to_string_io.string.should == IO.read( DATA_FILE )
+      end
+
+      it "writes the data to a file " do
+        all_rows = @db.execute("SELECT * FROM blobs")
+        all_rows.size.should == 1;
+        all_rows.first['name'].should == DATA_FILE
+        all_rows.first['data'].should be_incremental
+        all_rows.first['data'].write_to_file( @junk_file )
+        IO.read( @junk_file).should == IO.read( 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,23 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+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/database_spec.rb

@@ -0,0 +1,238 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite'
+require 'amalgalite/taps/io'
+require 'amalgalite/taps/console'
+
+describe Amalgalite::Database do
+  before(:each) do
+    @schema = IO.read( SpecInfo.test_schema_file )
+    @iso_db_file = SpecInfo.make_iso_db
+    @iso_db = Amalgalite::Database.new( SpecInfo.make_iso_db )
+  end
+
+  after(:each) do
+    File.unlink SpecInfo.test_db if File.exist?( SpecInfo.test_db )
+    @iso_db.close
+    File.unlink @iso_db_file if File.exist?( @iso_db_file )
+  end
+
+  it "can create a new database" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    db.instance_of?(Amalgalite::Database) 
+    db.api.instance_of?(Amalgalite::SQLite3::Database) 
+    File.exist?( SpecInfo.test_db ).should == true
+  end
+
+  it "creates a new UTF-8 database (need exec to check pragma encoding)" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    db.execute_batch( @schema );
+    db.should_not be_utf16
+    db.encoding.should == "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 { Amalgalite::Database.new( SpecInfo.test_db, "r") }.should raise_error(Amalgalite::SQLite3::Error)
+    lambda { Amalgalite::Database.new( SpecInfo.test_db, "r+") }.should raise_error(Amalgalite::SQLite3::Error)
+  end
+
+  it "raises an error if an invalid mode is used" do
+    lambda { Amalgalite::Database.new( SpecInfo.test_db, "b+" ) }.should raise_error(Amalgalite::Database::InvalidModeError)
+  end
+
+  it "can be in autocommit mode, and is by default" do
+    @iso_db.autocommit?.should == true
+  end
+
+  it "reports false for autocommit? when inside a transaction" do
+    @iso_db.execute(" BEGIN ")
+    @iso_db.autocommit?.should == false
+    @iso_db.in_transaction?.should == true
+    @iso_db.execute(" COMMIT")
+    @iso_db.in_transaction?.should == false
+  end
+
+  it "prepares a statment" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    stmt = db.prepare("SELECT datetime()")
+    stmt.instance_of?(Amalgalite::Statement)
+    stmt.api.instance_of?(Amalgalite::SQLite3::Statement)
+  end
+
+  it "raises an error on invalid syntax when preparing a bad sql statement" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    lambda { db.prepare("SELECT nothing FROM stuf") }.should raise_error(Amalgalite::SQLite3::Error)
+  end
+
+  it "closes normally" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    lambda { db.close }.should_not raise_error( Amalgalite::SQLite3::Error )
+  end
+
+  it "returns the id of the last inserted row" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    db.last_insert_rowid.should == 0
+  end
+
+  it "is in autocommit mode by default" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    db.should be_autocommit
+  end
+
+  it "report the number of rows changed with an insert" do
+    db = Amalgalite::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 == 1
+    db.total_changes.should == 3
+    db.close
+  end
+
+  it "reports the number of rows deleted" do
+    db = Amalgalite::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 == 2
+    db.close
+  end
+
+ 
+
+  it "can immediately execute an sql statement " do
+    db = Amalgalite::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 = Amalgalite::Database.new( SpecInfo.test_db )
+    db.execute_batch( @schema ).should == 5
+  end
+
+  it "traces the execution of code" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    sql = "CREATE TABLE trace_test( x, y, z)"
+    s = db.trace_tap = ::Amalgalite::Taps::StringIO.new
+    db.execute( sql )
+    db.trace_tap.string.should== "registered as trace tap\n#{sql}\n"
+    db.trace_tap = nil
+    s.string.should== "registered as trace tap\n#{sql}\nunregistered as trace tap\n"
+  end
+
+  it "raises an exception if the wrong type of object is used for tracing" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    lambda { db.trace_tap = Object.new }.should raise_error(Amalgalite::Error)
+  end
+
+  it "raises an exception if the wrong type of object is used for profile" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    lambda { db.profile_tap = Object.new }.should raise_error(Amalgalite::Error)
+  end
+
+  it "profiles the execution of code" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    s = db.profile_tap = ::Amalgalite::Taps::StringIO.new
+    db.execute_batch( @schema )
+    db.profile_tap.samplers.size.should == 6
+    db.profile_tap = nil
+    s.string.should =~ /unregistered as profile tap/m
+  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 == 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 == 1
+  end
+
+  it "can use something that responds to 'write' as a tap" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    s2 = db.trace_tap   = StringIO.new
+    s2.string.should == "registered as trace tap"
+  end
+
+  it "can clear all registered taps" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    s = db.profile_tap = ::Amalgalite::Taps::StringIO.new
+    db.trace_tap = s
+    db.execute_batch( @schema )
+    db.profile_tap.samplers.size.should == 6
+    db.clear_taps!
+    s.string.should =~ /unregistered as trace tap/m
+    s.string.should =~ /unregistered as profile tap/m
+  end
+
+  it "allows nested transactions even if SQLite under the covers does not" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    r = db.transaction do |db2|
+      r2 = db.transaction { 42 }
+      r2.should == 42
+      r2
+    end
+    r.should == 42
+  end
+
+  it "returns the result of the transaction when a block is yielded" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    (db.transaction { 42 }).should == 42
+  end
+
+  it "#reload_schema!" do
+    @iso_db = Amalgalite::Database.new( SpecInfo.make_iso_db )
+    schema = @iso_db.schema
+    schema.instance_of?( Amalgalite::Schema ).should == true
+    s2 = @iso_db.reload_schema!
+    s2.object_id.should_not == 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 == 242
+    @iso_db.execute("DELETE FROM country")
+    r = @iso_db.execute("SELECT count(1) as cnt FROM country");
+    r.first['cnt'].should == 0
+    @iso_db.rollback
+
+    r = @iso_db.execute("SELECT count(1) as cnt FROM country");
+    r.first['cnt'].should == 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 == 242
+        db.execute("DELETE FROM country")
+        db.in_transaction?.should == true
+        raise "testing rollback"
+      end
+    rescue => e
+      @iso_db.in_transaction?.should == false
+      @iso_db.execute("SELECT count(1) as cnt FROM country").first['cnt'].should == 242
+    end
+  end
+end
+

data/spec/default_map_spec.rb

@@ -0,0 +1,87 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite/type_maps/default_map'
+
+describe Amalgalite::TypeMaps::DefaultMap do
+  before(:each) do
+    @map = Amalgalite::TypeMaps::DefaultMap.new
+  end
+
+  describe "#bind_type_of" do
+
+    it "Float is bound to DataType::FLOAT" do
+      @map.bind_type_of( 3.14 ).should == ::Amalgalite::SQLite3::Constants::DataType::FLOAT
+    end
+
+    it "Fixnum is bound to DataType::INTGER" do
+      @map.bind_type_of( 42 ).should == ::Amalgalite::SQLite3::Constants::DataType::INTEGER
+    end
+
+    it "nil is bound to DataType::NULL" do
+      @map.bind_type_of( nil ).should == ::Amalgalite::SQLite3::Constants::DataType::NULL
+    end
+
+    it "::Amalgalite::Blob is bound to DataType::BLOB" do
+      @map.bind_type_of( ::Amalgalite::Blob.new( :column => true, :string => "just a test" ) ).should == ::Amalgalite::SQLite3::Constants::DataType::BLOB
+    end
+
+    it "everything else is bound to DataType::TEXT" do
+      @map.bind_type_of( "everything else" ).should == ::Amalgalite::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 "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 declated types of 'blob'" do
+      blob = @map.result_value_of( "blob", "stuff")
+      blob.to_s.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( ::Amalgalite::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( ::Amalgalite::Error )
+    end
+  end
+end