amalgalite 1.6.0-x64-mingw32

data/spec/requires_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'amalgalite/requires'
+
+#describe Amalgalite::Requires do
+#  it "#require_order has all files in 'lib' and no more" do
+#    dir_files = Dir.glob( File.join( Amalgalite::Paths.lib_path , "**", "*.rb" ) )
+#    require_files = Amalgalite::Requires.require_order.collect { |r| Amalgalite::Paths.lib_path r }
+#    dir_files.size.should == require_files.size
+#    (dir_files - require_files).size.should == 0
+#    (require_files - dir_files).size.should == 0
+#  end
+#
+#  it "can compress and uncompress data" do
+#    s = IO.read( __FILE__ )
+#    s_gz = Amalgalite::Requires.gzip( s )
+#    s.should == Amalgalite::Requires.gunzip( s_gz )
+#  end
+#end
+
+
+describe Amalgalite::Requires do
+  it "can import to an in-memory database" do
+    sql = <<-SQL
+CREATE TABLE rubylibs (
+      id                   INTEGER PRIMARY KEY AUTOINCREMENT,
+      filename   TEXT UNIQUE,
+      compressed BOOLEAN,
+      contents   BLOB
+      );
+INSERT INTO "rubylibs" VALUES(1, "application", "false", 'A=1');
+SQL
+    r = Amalgalite::Requires.new(:dbfile_name => ":memory:")
+    r.import(sql)
+    r.file_contents( "application" ).should == "A=1"
+  end
+
+
+  it "gives equal instances for file databases" do
+    a = Amalgalite::Requires.new( :dbfile_name => SpecInfo.test_db )
+    b = Amalgalite::Requires.new( :dbfile_name => SpecInfo.test_db )    
+
+    a.db_connection.should equal( b.db_connection )
+  end
+
+
+  it "gives separate instances for in-memory databases" do
+    a = Amalgalite::Requires.new( :dbfile_name => ":memory:" )
+    b = Amalgalite::Requires.new( :dbfile_name => ":memory:" )
+
+    a.db_connection.should_not equal(b.db_connection)
+  end
+
+  
+end

data/spec/rtree_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+#
+# Example from http://sqlite.org/rtree.html
+#
+describe "SQLite3 R*Tree extension" do
+  before( :each ) do
+    @db = Amalgalite::Database.new( ":memory:" )
+    x = @db.execute_batch <<-sql
+    CREATE VIRTUAL TABLE demo_index USING rtree(
+       id,              -- Integer primary key
+       minX, maxX,      -- Minimum and maximum X coordinate
+       minY, maxY       -- Minimum and maximum Y coordinate
+    );
+    -- 
+    INSERT INTO demo_index VALUES(
+        1,                   -- Primary key
+        -80.7749, -80.7747,  -- Longitude range
+        30.3776, 30.3778     -- Latitude range
+    );
+    INSERT INTO demo_index VALUES(
+        2,
+        -81.0, -79.6,
+        35.0, 36.2
+    );
+    sql
+    x.should == 3
+  end
+
+  after( :each ) do
+    @db.close
+  end
+
+  it "has 2 rows" do
+    r = @db.first_value_from( "SELECT count(*) FROM demo_index")
+    r.should == 2
+  end
+
+  it "queries normally" do
+    r = @db.execute "SELECT * FROM demo_index WHERE id=1;"
+    r.size.should be == 1
+    row = r.first
+    row['id'].should be == 1
+  end
+
+  it "does a 'contained within' query" do
+    r = @db.execute <<-sql
+    SELECT id FROM demo_index
+     WHERE minX>=-81.08 AND maxX<=-80.58
+       AND minY>=30.00  AND maxY<=30.44;
+    sql
+
+    r.size.should be == 1
+    r.first['id'].should be == 1
+  end
+
+  it "does an 'overlapping' query" do
+    r = @db.execute <<-sql
+    SELECT id FROM demo_index
+     WHERE maxX>=-81.08 AND minX<=-80.58
+       AND maxY>=30.00  AND minY<=35.44;
+    sql
+    r.size.should == 2
+  end
+end
+

data/spec/schema_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+require 'amalgalite'
+require 'amalgalite/schema'
+
+describe Amalgalite::Schema do
+
+  it "loads the schema of a database" do
+    schema = @iso_db.schema
+    schema.load_tables
+    schema.tables.size.should eql(2)
+  end
+
+  it "loads the views in the database" do
+    s = @iso_db.schema
+    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 )
+    s.dirty?.should be == true
+    @iso_db.schema.load_views
+    @iso_db.schema.views.size.should eql(1)
+    @iso_db.schema.views["v1"].sql.should eql(sql)
+  end
+
+  it "removes quotes from around default values in columns" do
+    s = @iso_db.schema
+    sql = "CREATE TABLE t1( d1 default 't' )"
+    @iso_db.execute( sql )
+    s.dirty?.should be == true
+    tt = @iso_db.schema.tables['t1']
+    tt.columns['d1'].default_value.should be == "t"
+  end
+
+  it "loads the tables and columns" do
+    ct = @iso_db.schema.tables['country']
+    ct.name.should eql("country")
+    ct.columns.size.should eql(3)
+    ct.indexes.size.should eql(2)
+    ct.column_names.should eql(%w[ name two_letter id ])
+    @iso_db.schema.tables.size.should eql(2)
+
+
+    ct.columns['two_letter'].should be_primary_key
+    ct.columns['two_letter'].declared_data_type.should eql("TEXT")
+    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 "knows what the primary key of a table is" do
+    ct = @iso_db.schema.tables['country']
+    ct.primary_key.should == [ ct.columns['two_letter'] ]
+  end
+
+  it "knows the primary key of a table even without an explicity unique index" do
+    s = @iso_db.schema
+    sql = "CREATE TABLE u( id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL , other text )"
+    @iso_db.execute( sql )
+    s.dirty?.should be == true
+    ut = @iso_db.schema.tables['u']
+    ut.primary_key.should == [ ut.columns['id'] ]
+  end
+
+  it "knows the primary key of a temporary table" do
+    @iso_db.execute "CREATE TEMPORARY TABLE tt( a, b INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, c )"
+    tt = @iso_db.schema.tables[ 'tt' ]
+    tt.primary_key.should == [ tt.columns['b'] ]
+  end
+
+  it "knows what the primary key of a table is when it is a multiple column primary key" do
+    sql = "CREATE TABLE m ( id1, id2, PRIMARY KEY (id2, id1) )"
+    s = @iso_db.schema
+    @iso_db.execute( sql )
+    s.dirty?.should be == true
+    mt = @iso_db.schema.tables['m']
+    mt.primary_key.should == [ mt.columns['id2'], mt.columns['id1'] ]
+  end
+
+  it "loads the indexes" do
+    c = @iso_db.schema.tables['country']
+    c.indexes.size.should eql(2)
+    c.indexes['country_name'].columns.size.should eql(1)
+    c.indexes['country_name'].should_not be_unique
+    c.indexes['country_name'].sequence_number.should eql(0)
+    c.indexes['country_name'].columns.first.should eql(@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 eql(3)
+    subc.indexes['subcountry_country'].columns.first.should eql(@iso_db.schema.tables['subcountry'].columns['country'])
+  end
+
+  it "knows the schema is dirty when a table is created" do
+    s = @iso_db.schema
+    s.tables['country']
+    s.dirty?.should be == false
+    @iso_db.execute( "create table x1( a, b )" )
+    s.dirty?.should be == true
+  end
+
+  it "knows the schema is dirty when a table is dropped" do
+    s = @iso_db.schema
+    s.tables['country']
+    @iso_db.execute( "create table x1( a, b )" )
+    s.dirty?.should be == true
+
+    @iso_db.schema.load_schema!
+    s = @iso_db.schema
+
+    s.dirty?.should be == false
+    @iso_db.execute("drop table x1")
+    s.dirty?.should be == true
+  end
+
+  it "knows if a temporary table exists" do
+    @iso_db.execute "CREATE TEMPORARY TABLE tt(a,b,c)"
+    @iso_db.schema.tables.keys.include?('tt').should be == true
+    @iso_db.schema.tables['tt'].temporary?.should be == true
+  end
+
+  it "sees that temporary tables shadow real tables" do
+    @iso_db.execute "CREATE TABLE tt(x)"
+    @iso_db.schema.tables['tt'].temporary?.should be == false
+    @iso_db.execute "CREATE TEMP TABLE tt(a,b,c)"
+    @iso_db.schema.tables['tt'].temporary?.should be == true
+    @iso_db.execute "DROP TABLE tt"
+    @iso_db.schema.tables['tt'].temporary?.should be == false
+    @iso_db.schema.tables['tt'].columns.size.should be == 1
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+require 'rspec'
+require 'fileutils'
+
+require 'amalgalite'
+require Amalgalite::Paths.spec_path( "iso_3166_database.rb" )
+
+class SpecInfo
+  class << self
+    def test_db
+      @test_db ||= Amalgalite::Paths.spec_path("data", "test.db")
+    end
+
+    def make_master_iso_db
+      @master_db ||= Amalgalite::Iso3166Database.new
+    end
+
+    def make_clone_iso_db
+      make_master_iso_db.duplicate( 'testing' )
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+
+  config.before(:all) do 
+    SpecInfo.make_master_iso_db
+  end
+
+  config.after(:all) do
+    File.unlink( Amalgalite::Iso3166Database.default_db_file ) if File.exist?( Amalgalite::Iso3166Database.default_db_file )
+  end
+
+  config.before( :each ) do
+    @iso_db_path = SpecInfo.make_clone_iso_db
+    @iso_db      = Amalgalite::Database.new( @iso_db_path )
+    @schema      = IO.read( Amalgalite::Iso3166Database.schema_file )
+  end
+
+  config.after( :each ) do
+    @iso_db.close
+    File.unlink( @iso_db_path ) if File.exist?( @iso_db_path )
+    File.unlink( SpecInfo.test_db ) if File.exist?( SpecInfo.test_db )
+  end
+end
+

data/spec/sqlite3/constants_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+require 'amalgalite/sqlite3/constants'
+
+describe Amalgalite::SQLite3::Constants do
+
+  it "has Open constants" do
+    Amalgalite::SQLite3::Constants::Open::READONLY.should > 0
+  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 "DataType" do
+    it "has constants" do
+      Amalgalite::SQLite3::Constants::DataType::NULL.should == 5
+    end
+
+    it "can return the constant from a number" do
+      c = Amalgalite::SQLite3::Constants::DataType.name_from_value( 5 )
+      c.should == "NULL"
+    end
+
+    it "can return the number from a name" do
+      v = Amalgalite::SQLite3::Constants::DataType.value_from_name( "Null" )
+      v.should == 5
+    end
+
+  end
+
+  describe "Config" do
+    it "has constants" do
+      Amalgalite::SQLite3::Constants::Config::HEAP.should == 8
+    end
+
+    it "can return the constant from a number" do
+      c = Amalgalite::SQLite3::Constants::Config.name_from_value( 8 )
+      c.should == "HEAP"
+    end
+
+    it "can return the number from a name" do
+      v = Amalgalite::SQLite3::Constants::Config.value_from_name( "heap" )
+      v.should == 8
+    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
+
+  describe "StatementStatus" do
+    it "has constants" do
+      Amalgalite::SQLite3::Constants::StatementStatus::AUTOINDEX.should == 3
+    end
+
+    it "can return the constant from a number" do
+      c = Amalgalite::SQLite3::Constants::StatementStatus.name_from_value( 3 )
+      c.should == "AUTOINDEX"
+    end
+
+    it "can return the number from a name" do
+      v = Amalgalite::SQLite3::Constants::StatementStatus.value_from_name( "autoindex" )
+      v.should == 3
+    end
+  end
+end

data/spec/sqlite3/database_status_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+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 be > 0
+    @db.api.status.lookaside_used.current.should be >= 0
+  end
+
+  it "can reset the highwater value" do
+    stat = @db.api.status.lookaside_used
+    before = stat.highwater
+    before.should be > 0
+
+    stat.reset!
+    after = stat.highwater
+
+    after.should eql(0)
+    after.should_not eql(before)
+  end
+end