amalgalite 0.4.2-x86-mswin32-60

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
+

data/spec/paths_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+
+describe Amalgalite::Paths do
+  before(:each) do
+    @root_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+    @root_dir += "/"
+  end
+
+  it "root dir should be correct" do
+    Amalgalite::Paths.root_dir.should == @root_dir
+  end
+
+  it "config_path should be correct" do
+    Amalgalite::Paths.config_path.should == File.join(@root_dir, "config/")
+  end
+
+  it "data path should be correct" do
+    Amalgalite::Paths.data_path.should == File.join(@root_dir, "data/")
+  end
+
+  it "lib path should be correct" do
+    Amalgalite::Paths.lib_path.should == File.join(@root_dir, "lib/")
+  end
+
+  it "ext path should be correct" do
+    Amalgalite::Paths.ext_path.should == File.join(@root_dir, "ext/")
+  end
+end

data/spec/schema_spec.rb

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite'
+require 'amalgalite/schema'
+
+describe Amalgalite::Schema 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 "loads the schema of a database" do
+    schema = @iso_db.schema
+    schema.tables.size.should == 2
+  end
+
+  it "loads the views in the database" do
+    sql = "CREATE VIEW v1 AS SELECT c.name, c.two_letter, s.name, s.subdivision FROM country AS c JOIN subcountry AS s ON c.two_letter = s.country"
+    @iso_db.execute( sql )
+    @iso_db.schema.views.size.should == 1
+    @iso_db.schema.views["v1"].sql.should == sql
+  end
+
+  it "loads the tables and columns" do
+    @iso_db.schema.tables.size.should == 2
+    ct = @iso_db.schema.tables['country']
+    ct.name.should == "country"
+    ct.columns.size.should == 3
+    ct.indexes.size.should == 2
+
+    ct.columns['two_letter'].should be_primary_key
+    ct.columns['name'].should_not be_nullable
+    ct.columns['name'].should be_not_null_constraint
+    ct.columns['name'].should_not be_has_default_value
+    ct.columns['id'].should_not be_auto_increment
+  end
+
+  it "loads the indexes" do
+    c = @iso_db.schema.tables['country']
+    c.indexes.size.should == 2
+    c.indexes['country_name'].columns.size.should == 1
+    c.indexes['country_name'].should_not be_unique
+    c.indexes['country_name'].sequence_number.should == 0
+    c.indexes['country_name'].columns.first.should == @iso_db.schema.tables['country'].columns['name']
+    c.indexes['sqlite_autoindex_country_1'].should be_unique
+
+    subc = @iso_db.schema.tables['subcountry']
+    subc.indexes.size.should == 3
+    subc.indexes['subcountry_country'].columns.first.should == @iso_db.schema.tables['subcountry'].columns['country']
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite'
+
+class SpecInfo
+  class << self
+    def test_db
+      @test_db ||=  File.expand_path(File.join(File.dirname(__FILE__), "test.db"))
+    end
+
+    def test_schema_file
+      @test_schema_file ||= File.expand_path(File.join(File.dirname(__FILE__),"iso-3166-schema.sql"))
+    end
+
+    def make_iso_db
+      @iso_db ||= File.expand_path(File.join(File.dirname(__FILE__), "iso-3166.db"))
+      @new_is_db =  File.expand_path(File.join(File.dirname(__FILE__), "iso-3166-testing.db"))
+      FileUtils.cp @iso_db, @new_is_db
+      return @new_is_db
+    end
+  end
+end
+

data/spec/sqlite3/constants_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__),%w[ .. spec_helper.rb ]))
+
+require 'amalgalite/sqlite3/constants'
+
+describe Amalgalite::SQLite3::Constants do
+
+  it "has Open constants" do
+    Amalgalite::SQLite3::Constants::Open::READONLY.should > 0
+  end
+  
+  it "has DataType constants" do
+    Amalgalite::SQLite3::Constants::DataType::BLOB.should > 0
+  end
+
+  it "has ResultCode constants" do
+  end
+
+  describe 'ResultCode' do 
+    it "has constants" do
+      Amalgalite::SQLite3::Constants::ResultCode::OK.should == 0
+    end
+
+    it "can return the constant from a number" do
+      c = Amalgalite::SQLite3::Constants::ResultCode.name_from_value( 21 )
+      c.should == "MISUSE"
+    end
+
+    it "can return the number from a name" do
+      v = Amalgalite::SQLite3::Constants::ResultCode.value_from_name( "MISUSE" )
+      v.should == 21
+    end
+  end
+
+  describe 'Status' do
+    it "has constants" do
+      Amalgalite::SQLite3::Constants::Status::MEMORY_USED.should == 0
+    end
+
+    it "can return the constant from a number" do
+      c = Amalgalite::SQLite3::Constants::Status.name_from_value( 3 )
+      c.should == "SCRATCH_USED"
+    end
+    
+    it "can return the number from a name" do
+      v = Amalgalite::SQLite3::Constants::Status.value_from_name( "memory_used" )
+      v.should == 0
+    end
+  end
+
+  describe 'DBStatus' do
+    it "has constants" do
+      Amalgalite::SQLite3::Constants::DBStatus::LOOKASIDE_USED.should == 0
+    end
+
+    it "can return the constant from a number" do
+      c = Amalgalite::SQLite3::Constants::DBStatus.name_from_value( 0 )
+      c.should == "LOOKASIDE_USED"
+    end
+    
+    it "can return the number from a name" do
+      v = Amalgalite::SQLite3::Constants::DBStatus.value_from_name( "lookaside_used" )
+      v.should == 0
+    end
+  end
+end

data/spec/sqlite3/database_status_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..",  "spec_helper.rb"))
+require 'amalgalite/sqlite3'
+require 'rbconfig'
+
+describe "Amalgalite::SQLite3::Database::Status" do
+  before(:each) do
+    @db = Amalgalite::Database.new( "lookaside-test.db" )
+    @db.execute(" create table t(a, b)")
+    20.times do |x|
+      @db.execute("insert into t(a, b) values (?,?);", x, x+1)
+    end
+  end
+
+  after(:each) do
+    @db.close
+    FileUtils.rm_f "lookaside-test.db" 
+  end
+
+
+  it "knows how much lookaside memory it has used" do
+    @db.api.status.lookaside_used.highwater.should > 0
+    @db.api.status.lookaside_used.current.should >= 0
+  end
+
+  it "can reset the highwater value" do
+    stat = @db.api.status.lookaside_used
+    before = stat.highwater
+    before.should > 0
+
+    stat.reset!
+    after = stat.highwater
+
+    after.should == 0
+    after.should_not == before
+  end
+end

data/spec/sqlite3/status_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper.rb"))
+require 'amalgalite/sqlite3'
+require 'rbconfig'
+
+describe "Amalgalite::SQLite3::Status" do
+  it "knows how much memory it has used" do
+    Amalgalite::SQLite3.status.memory_used.current.should >= 0
+    Amalgalite::SQLite3.status.memory_used.highwater.should >= 0
+  end
+
+  it "can reset the highwater value" do
+    before = Amalgalite::SQLite3.status.memory_used.highwater
+    Amalgalite::SQLite3.status.memory_used.reset!
+    Amalgalite::SQLite3.status.memory_used.highwater.should > 0
+    after = Amalgalite::SQLite3.status.memory_used.highwater
+    after.should_not == before
+  end
+end

data/spec/sqlite3/version_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"..","spec_helper.rb"))
+require 'amalgalite/sqlite3/version'
+
+describe "Amalgalite::SQLite3::Version" do
+  it "should have the sqlite3 version" do
+    Amalgalite::SQLite3::VERSION.should =~ /\d\.\d\.\d/
+    Amalgalite::SQLite3::Version.to_s.should =~ /\d\.\d\.\d/
+    Amalgalite::SQLite3::Version.to_i.should == 3006003
+    Amalgalite::SQLite3::Version::MAJOR.should == 3
+    Amalgalite::SQLite3::Version::MINOR.should == 6
+    Amalgalite::SQLite3::Version::RELEASE.should == 3
+    Amalgalite::SQLite3::Version.to_a.should have(3).items
+  end
+end

data/spec/sqlite3_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+require 'amalgalite/sqlite3'
+require 'rbconfig'
+
+describe "Amalgalite::SQLite3" do
+  it "is threadsafe is ruby is compiled with pthread support, in this case that is (#{Config::CONFIG['configure_args'].include?( "--enable-pthread" )})" do
+    Amalgalite::SQLite3.threadsafe?.should == Config::CONFIG['configure_args'].include?( "--enable-pthread" )
+  end
+
+  it "knows if an SQL statement is complete" do
+    Amalgalite::SQLite3.complete?("SELECT * FROM sometable;").should == true
+    Amalgalite::SQLite3.complete?("SELECT * FROM sometable;", :utf16 => true).should == true
+  end
+  
+  it "knows if an SQL statement is not complete" do
+    Amalgalite::SQLite3.complete?("SELECT * FROM sometable ").should == false
+    Amalgalite::SQLite3.complete?("SELECT * FROM sometable WHERE ", :utf16 => true).should == false
+  end
+
+  it "can produce random data" do
+    Amalgalite::SQLite3.randomness( 42 ).size.should == 42
+  end
+end

data/spec/statement_spec.rb

@@ -0,0 +1,134 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite'
+
+describe Amalgalite::Statement do
+  before(:each) do
+    @db = Amalgalite::Database.new( SpecInfo.test_db )
+    @schema_sql = 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
+    @db.close
+    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 "a statement has a copy of the sql it was prepared with" do
+    stmt = @db.prepare( "SELECT strftime('%Y-%m-%d %H:%M:%S', 'now')")
+    stmt.sql.should == "SELECT strftime('%Y-%m-%d %H:%M:%S', 'now')"
+    stmt.close
+  end
+
+  it "steps through results" do
+    now = Time.new.utc.strftime("%Y-%m-%d %H:%M")
+    @db.prepare( "SELECT strftime('%Y-%m-%d %H:%M', 'now') as now") do |stmt|
+      stmt.should_not == nil
+      stmt.each do |row|
+        row['now'].should == now
+      end
+    end
+  end
+
+  it "can prepare a statement without a block" do
+    stmt = @iso_db.prepare("SELECT * FROM country WHERE two_letter = :two") 
+    rs = stmt.execute( ":two" => "JP" )
+    rs.size.should == 1
+    stmt.close
+  end
+
+  it "knows how many parameters are in the statement" do
+    @iso_db.prepare("SELECT * FROM country WHERE two_letter = :two") do |stmt|
+      stmt.check_parameter_count!( 1 ).should == 1
+    end
+  end
+
+  it "raises an error if there are not enough parameters are passed in a statement" do
+    @iso_db.prepare("SELECT * FROM country WHERE two_letter = :two") do |stmt|
+      lambda{ stmt.execute }.should raise_error( Amalgalite::Error )
+    end
+  end
+
+
+  it "can run a query with a named parameter" do
+    @iso_db.prepare("SELECT * FROM country WHERE two_letter = :two") do |stmt|
+      all_rows = stmt.execute( ":two" => "JP" )
+      all_rows.size.should == 1
+      all_rows.first['name'].should == "Japan"
+    end
+  end
+
+  it "it can execute a query with a named parameter and yield the rows" do 
+    @iso_db.prepare("SELECT * FROM country WHERE id = @id ORDER BY name") do |stmt|
+      rows = []
+      stmt.execute( "@id" => 891 ) do |row|
+        rows << row
+      end
+      rows.size.should == 2
+      rows.last['name'].should == "Yugoslavia"
+      rows.first['two_letter'].should == "CS"
+    end
+  end
+
+  it "can execute the same prepared statement multiple times" do
+    @db.execute(" CREATE TABLE t(x,y); ")
+    values = {}
+    @db.prepare("INSERT INTO t( x, y ) VALUES( $x, $y )" ) do |stmt|
+      20.times do |x|
+        y = rand( x )
+        stmt.execute( { "$x" => x, "$y" => y } )
+        values[x] = y
+      end
+    end
+    c = 0
+    @db.execute("SELECT * from t") do |row|
+      c += 1
+      values[ row['x'] ].should == row['y']
+    end
+    c.should == 20
+  end
+
+  it "binds a integer variable correctly" do
+    @iso_db.prepare("SELECT * FROM country WHERE id = ? ORDER BY name ") do |stmt|
+      all_rows = stmt.execute( 891 )
+      all_rows.size.should == 2
+      all_rows.last['name'].should == "Yugoslavia"
+      all_rows.first['two_letter'].should == "CS"
+    end
+  end
+
+  it "raises and error if an invaliding binding is attempted" do 
+    @iso_db.prepare("SELECT * FROM country WHERE id = :somevar ORDER BY name ") do |stmt|
+      lambda{ stmt.execute( "blah" => 42 ) }.should raise_error(Amalgalite::Error)
+    end
+  end
+
+  it "can reset the statement to the state it was before executing" do
+    stmt = @iso_db.prepare("SELECT * FROM country WHERE id = :somevar ORDER BY name ") 
+    stmt.reset_and_clear_bindings!
+    stmt.close
+  end
+
+  it "can execute a single sql command and say if there is remaining sql to execute" do
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    stmt = @db.prepare( @schema_sql )
+    stmt.execute
+    stmt.remaining_sql.size.should > 0
+    stmt.close
+  end
+
+  it "has index based access to the result set" do
+    @iso_db.prepare("SELECT * FROM country WHERE id = ? ORDER BY name ") do |stmt|
+      all_rows = stmt.execute( 891 )
+      all_rows.size.should == 2
+      all_rows.last.first.should == "Yugoslavia"
+      all_rows.first[1].should == "CS"
+    end
+  end
+end