amalgalite 0.1.0

data/lib/amalgalite/version.rb

@@ -0,0 +1,32 @@
+#--
+# 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   = 1
+    BUILD   = 0
+
+    #
+    # 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
+
+    # 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,24 @@
+#--
+# 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 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/boolean_spec.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'spec'
+
+$: << 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,222 @@
+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 "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 "raises an error if a transaction is attempted within a transaction" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    db.transaction do |db2|
+      lambda{ db2.transaction }.should raise_error(Amalgalite::Error)
+    end
+  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,85 @@
+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 ).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 "raises NotImplemeted for blob conversion" do
+      lambda{ @map.result_value_of( "Blob", "some blob" ) }.should raise_error( NotImplementedError )
+    end
+
+    it "raises and error if an unknown sql type is returned" do
+      lambda{ @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

data/spec/integeration_spec.rb

@@ -0,0 +1,111 @@
+require 'rubygems'
+require 'spec'
+require 'date'
+require 'time'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite'
+
+describe "Integration specifications" 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
+
+  describe " - invalid queries" do
+    it "raises error with an invalid syntax" do
+      lambda{ @iso_db.prepare "SELECT from country" }.should raise_error( ::Amalgalite::SQLite3::Error )
+    end
+
+    it "raises error with invalid table" do
+      lambda{ @iso_db.prepare "SELECT * FROM foo" }.should raise_error( ::Amalgalite::SQLite3::Error )
+    end
+    
+    it "raises error with invalid column" do
+      lambda{ @iso_db.prepare "SELECT foo FROM country" }.should raise_error( ::Amalgalite::SQLite3::Error )
+    end
+  end
+
+  describe " - default types conversion" do
+
+    { 
+      "datetime"  => { :value => DateTime.now, :klass => DateTime }, 
+      "timestamp" => { :value => Time.now, :klass => Time   } ,
+      "date"      => { :value => Date.today, :klass => Date },
+      "integer"   => { :value => 42, :klass => Fixnum } ,
+      "double"    => { :value => 3.14, :klass => Float },
+      "varchar"   => { :value => "foobarbaz", :klass => String },
+      "boolean"   => { :value => true, :klass => TrueClass },
+      "varchar(2)"=> { :value => nil, :klass => NilClass }
+    }.each_pair do |sql_type, ruby_info|
+      it "converts a ruby obj (#{ruby_info[:value].to_s}) of #{ruby_info[:klass]} to an SQL type of #{sql_type} and back again " do
+        db = Amalgalite::Database.new( SpecInfo.test_db )
+        db.execute "CREATE TABLE t( c #{sql_type} )"
+        db.execute "insert into t (c) values ( ? )", ruby_info[:value]
+        rows = db.execute "select * from t"
+        rows.first['c'].class.should == ruby_info[:klass]
+
+        if [ DateTime, Time ].include?( ruby_info[:klass] ) then
+          rows.first['c'].strftime("%Y-%m-%d %H:%M:%S").should == ruby_info[:value].strftime("%Y-%m-%d %H:%M:%S")
+        else
+          rows.first['c'].should == ruby_info[:value]
+        end
+        db.close
+      end
+    end
+  end
+
+  describe " - storage type conversion" do
+    { 
+      "datetime"  => { :value => DateTime.now, :result => DateTime.now.strftime("%Y-%m-%dT%H:%M:%S%Z") } ,
+      "timestamp" => { :value => Time.now,     :result => Time.now.to_s },
+      "date"      => { :value => Date.today,   :result => Date.today.to_s },
+      "integer"   => { :value => 42,           :result => 42   } ,
+      "double"    => { :value => 3.14,         :result => 3.14 }  ,
+      "varchar"   => { :value => "foobarbaz",  :result => "foobarbaz" },
+      "boolean"   => { :value => true,         :result => "true" },
+      "varchar(2)"=> { :value => nil,          :result => nil }
+    }.each_pair do |sql_type, ruby_info|
+      it "converts a ruby obj (#{ruby_info[:value].to_s}) of class #{ruby_info[:value].class.name} to an SQL type of #{sql_type} and back to a storage type" do
+        db = Amalgalite::Database.new( SpecInfo.test_db )
+        db.type_map = Amalgalite::TypeMaps::StorageMap.new
+        db.execute "CREATE TABLE t( c #{sql_type} )"
+        db.execute "insert into t (c) values ( ? )", ruby_info[:value]
+        rows = db.execute "select * from t"
+        rows.first['c'].should == ruby_info[:result]
+        db.close
+      end
+    end
+  end
+
+  describe " - text type conversion" do
+    { 
+      "datetime"  => { :value => DateTime.now, :result => DateTime.now.strftime("%Y-%m-%dT%H:%M:%S%Z") } ,
+      "timestamp" => { :value => Time.now,     :result => Time.now.to_s },
+      "date"      => { :value => Date.today,   :result => Date.today.to_s },
+      "integer"   => { :value => 42,           :result => "42"   } ,
+      "double"    => { :value => 3.14,         :result => "3.14" }  ,
+      "varchar"   => { :value => "foobarbaz",  :result => "foobarbaz" },
+      "boolean"   => { :value => true,         :result => "true" },
+      "varchar(2)"=> { :value => nil,          :result => "" }
+    }.each_pair do |sql_type, ruby_info|
+      it "converts a ruby obj (#{ruby_info[:value].to_s}) of class #{ruby_info[:value].class.name} to an SQL type of #{sql_type} and back to text" do
+        db = Amalgalite::Database.new( SpecInfo.test_db )
+        db.type_map = Amalgalite::TypeMaps::TextMap.new
+        db.execute "CREATE TABLE t( c #{sql_type} )"
+        db.execute "insert into t (c) values ( ? )", ruby_info[:value]
+        rows = db.execute "select * from t"
+        rows.first['c'].should == ruby_info[:result]
+        db.close
+      end
+    end
+  end
+end
+