libsql 0.1.0-x86-mingw32

data/spec/integeration_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+require 'date'
+require 'time'
+
+describe "Integration specifications" do
+
+  describe " - invalid queries" do
+    it "raises error with an invalid syntax" do
+      lambda{ @iso_db.prepare "SELECT from country" }.should raise_error( ::Libsql::SQLite3::Error )
+    end
+
+    it "raises error with invalid table" do
+      lambda{ @iso_db.prepare "SELECT * FROM foo" }.should raise_error( ::Libsql::SQLite3::Error )
+    end
+    
+    it "raises error with invalid column" do
+      lambda{ @iso_db.prepare "SELECT foo FROM country" }.should raise_error( ::Libsql::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 => Integer },
+      "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 = ::Libsql::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'].should be_kind_of(ruby_info[:klass])
+
+        if [ DateTime, Time ].include?( ruby_info[:klass] ) then
+          rows.first['c'].strftime("%Y-%m-%d %H:%M:%S").should eql(ruby_info[:value].strftime("%Y-%m-%d %H:%M:%S"))
+        else
+          rows.first['c'].should eql(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 = ::Libsql::Database.new( SpecInfo.test_db )
+        db.type_map = ::Libsql::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 eql(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 = ::Libsql::Database.new( SpecInfo.test_db )
+        db.type_map = ::Libsql::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 eql(ruby_info[:result])
+        db.close
+      end
+    end
+  end
+end
+

data/spec/iso_3166_database.rb

@@ -0,0 +1,58 @@
+require 'libsql'
+
+module ::Libsql
+  class Iso3166Database < Database
+    def self.country_data_file
+      @country_data_file ||= File.expand_path( File.join( File.dirname(__FILE__), "data", "iso-3166-country.txt" ) )
+    end
+
+    def self.subcountry_data_file
+      @subcountry_data_file ||= File.expand_path( File.join( File.dirname(__FILE__), "data", "iso-3166-subcountry.txt" ) )
+    end
+
+    def self.schema_file
+      @schema_file ||= File.expand_path(File.join(File.dirname(__FILE__), "data", "iso-3166-schema.sql"))
+    end
+
+    def self.default_db_file
+      @db_file ||= File.expand_path(File.join(File.dirname(__FILE__), "data", "iso-3166.db"))
+
+    end
+
+    def self.memory
+      Iso3166Database.new( ":memory:" )
+    end
+
+    def initialize( path = Iso3166Database.default_db_file )
+      @path = path 
+      super( @path )
+      install_schema( self )
+      populate( self )
+    end
+
+    def duplicate( slug )
+      dirname = File.dirname( @path )
+      bname = File.basename( @path, ".db" )
+      new_name = File.join( dirname, "#{bname}_#{slug}.db" )
+      File.unlink( new_name ) if File.exist?( new_name )
+      new_db = replicate_to( new_name )
+      new_db.close
+      return new_name
+    end
+
+    def install_schema( db )
+      db.execute_batch( IO.read( Iso3166Database.schema_file ) );
+    end
+
+    def populate( db )
+      db.import_csv_to_table( Iso3166Database.country_data_file, "country", :col_sep => "|" )
+      db.import_csv_to_table( Iso3166Database.subcountry_data_file, "subcountry", :col_sep => "|" )
+    end
+
+    def remove
+      File.unlink( @path ) if File.exist?( @path )
+    end
+  end
+end
+
+

data/spec/json_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'libsql/sqlite3'
+require 'rbconfig'
+
+describe "::Libsql handles the JSON extension" do
+  it "can parse a `json_each` call" do
+    db = ::Libsql::Database.new( ":memory:" )
+    values = %w[ a b c d e f g ]
+    db.execute("CREATE TABLE jtest(id, json)")
+    db.execute("INSERT INTO jtest(id, json) values (1, json($json))", { "$json" => values })
+    rows = db.execute("SELECT jtest.id as i, value as v FROM jtest, json_each(jtest.json)")
+
+    rows.size.should eq(values.size)
+  end
+
+  it "can return a proper json column" do
+    db = ::Libsql::Database.new( ":memory:" )
+    values = %w[ a b c d e f g ]
+    db.execute("CREATE TABLE jtest(id INTEGER, json JSON)")
+    db.execute("INSERT INTO jtest(id, json) values (1, json($json))", { "$json" => values })
+
+    db.execute("select * from jtest")
+  end
+end

data/spec/libsql_spec.rb

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

data/spec/paths_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe ::Libsql::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
+    ::Libsql::Paths.root_dir.should == @root_dir
+  end
+
+  it "config_path should be correct" do
+    ::Libsql::Paths.config_path.should == File.join(@root_dir, "config/")
+  end
+
+  it "data path should be correct" do
+    ::Libsql::Paths.data_path.should == File.join(@root_dir, "data/")
+  end
+
+  it "lib path should be correct" do
+    ::Libsql::Paths.lib_path.should == File.join(@root_dir, "lib/")
+  end
+
+  it "ext path should be correct" do
+    ::Libsql::Paths.ext_path.should == File.join(@root_dir, "ext/")
+  end
+end

data/spec/progress_handler_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+class PH < ::Libsql::ProgressHandler
+  attr_reader :call_count
+  def initialize( max = nil )
+    @call_count = 0
+    @max = max
+  end
+
+  def call
+    @call_count += 1
+    if @max && ( @call_count >= @max ) then
+      return false
+    end
+    return true
+  end
+end
+
+def query_thread( database )
+  Thread.new( database ) do |db|
+    begin
+      db.execute("select count(id) from country")
+    rescue => e
+      Thread.current[:exception] = e
+    end
+  end
+end
+
+describe "Progress Handlers" do
+
+  it "raises NotImplemented if #call is not overwritten" do
+    bh = ::Libsql::ProgressHandler.new
+    lambda { bh.call }.should raise_error( ::NotImplementedError, /The progress handler call\(\) method must be implemented/ )
+  end
+
+  it "can be registered as block" do
+    call_count = 0
+    @iso_db.progress_handler( 50 ) do ||
+      call_count += 1
+    true
+    end
+    qt = query_thread( @iso_db )
+    qt.join
+    call_count.should > 10
+  end
+
+  it "can be registered as lambda" do
+    call_count = 0
+    callable = lambda { || call_count += 1; true }
+    @iso_db.progress_handler( 42, callable ) 
+    qt = query_thread( @iso_db )
+    qt.join
+    call_count.should > 10
+  end
+
+  it "can be registered as a class" do
+    ph = PH.new 
+    @iso_db.progress_handler( 5, ph )
+    qt = query_thread( @iso_db )
+    qt.join
+    ph.call_count.should > 100
+  end
+
+  it "behaves like #interrupt! if returning a false value" do
+    ph = PH.new( 25 )
+    @iso_db.progress_handler( 5, ph )
+    qt = query_thread( @iso_db )
+    qt.join
+    ph.call_count.should eql(25)
+    qt[:exception].should be_instance_of( ::Libsql::SQLite3::Error )
+    @iso_db.api.last_error_code.should be == 9
+    @iso_db.api.last_error_message.should  =~ /interrupted/
+    qt[:exception].message.should =~ /interrupted/
+  end
+
+  it "cannot register a block with the wrong arity" do
+    lambda do 
+      @iso_db.define_progress_handler { |x,y| puts "What!" }
+    end.should raise_error( ::Libsql::Database::ProgressHandlerError, /A progress handler expects 0 arguments, not 2/)
+  end
+
+  it "can remove a progress handler" do
+    ph = PH.new 
+    @iso_db.progress_handler( 5, ph )
+    @iso_db.remove_progress_handler
+    qt = query_thread( @iso_db )
+    qt.join
+    ph.call_count.should eql(0)
+    qt[:exception].should be_nil
+  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 = ::Libsql::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 'libsql'
+require 'libsql/schema'
+
+describe ::Libsql::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 'libsql'
+require ::Libsql::Paths.spec_path( "iso_3166_database.rb" )
+
+class SpecInfo
+  class << self
+    def test_db
+      @test_db ||= ::Libsql::Paths.spec_path("data", "test.db")
+    end
+
+    def make_master_iso_db
+      @master_db ||= ::Libsql::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( ::Libsql::Iso3166Database.default_db_file ) if File.exist?( ::Libsql::Iso3166Database.default_db_file )
+  end
+
+  config.before( :each ) do
+    @iso_db_path = SpecInfo.make_clone_iso_db
+    @iso_db      = ::Libsql::Database.new( @iso_db_path )
+    @schema      = IO.read( ::Libsql::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 'libsql/sqlite3/constants'
+
+describe ::Libsql::SQLite3::Constants do
+
+  it "has Open constants" do
+    ::Libsql::SQLite3::Constants::Open::READONLY.should > 0
+  end
+
+  describe 'ResultCode' do 
+    it "has constants" do
+      ::Libsql::SQLite3::Constants::ResultCode::OK.should == 0
+    end
+
+    it "can return the constant from a number" do
+      c = ::Libsql::SQLite3::Constants::ResultCode.name_from_value( 21 )
+      c.should == "MISUSE"
+    end
+
+    it "can return the number from a name" do
+      v = ::Libsql::SQLite3::Constants::ResultCode.value_from_name( "MISUSE" )
+      v.should == 21
+    end
+  end
+
+  describe "DataType" do
+    it "has constants" do
+      ::Libsql::SQLite3::Constants::DataType::NULL.should == 5
+    end
+
+    it "can return the constant from a number" do
+      c = ::Libsql::SQLite3::Constants::DataType.name_from_value( 5 )
+      c.should == "NULL"
+    end
+
+    it "can return the number from a name" do
+      v = ::Libsql::SQLite3::Constants::DataType.value_from_name( "Null" )
+      v.should == 5
+    end
+
+  end
+
+  describe "Config" do
+    it "has constants" do
+      ::Libsql::SQLite3::Constants::Config::HEAP.should == 8
+    end
+
+    it "can return the constant from a number" do
+      c = ::Libsql::SQLite3::Constants::Config.name_from_value( 8 )
+      c.should == "HEAP"
+    end
+
+    it "can return the number from a name" do
+      v = ::Libsql::SQLite3::Constants::Config.value_from_name( "heap" )
+      v.should == 8
+    end
+
+  end
+
+  describe 'Status' do
+    it "has constants" do
+      ::Libsql::SQLite3::Constants::Status::MEMORY_USED.should == 0
+    end
+
+    it "can return the constant from a number" do
+      c = ::Libsql::SQLite3::Constants::Status.name_from_value( 3 )
+      c.should == "SCRATCH_USED"
+    end
+
+    it "can return the number from a name" do
+      v = ::Libsql::SQLite3::Constants::Status.value_from_name( "memory_used" )
+      v.should == 0
+    end
+  end
+
+  describe 'DBStatus' do
+    it "has constants" do
+      ::Libsql::SQLite3::Constants::DBStatus::LOOKASIDE_USED.should == 0
+    end
+
+    it "can return the constant from a number" do
+      c = ::Libsql::SQLite3::Constants::DBStatus.name_from_value( 0 )
+      c.should == "LOOKASIDE_USED"
+    end
+
+    it "can return the number from a name" do
+      v = ::Libsql::SQLite3::Constants::DBStatus.value_from_name( "lookaside_used" )
+      v.should == 0
+    end
+  end
+
+  describe "StatementStatus" do
+    it "has constants" do
+      ::Libsql::SQLite3::Constants::StatementStatus::AUTOINDEX.should == 3
+    end
+
+    it "can return the constant from a number" do
+      c = ::Libsql::SQLite3::Constants::StatementStatus.name_from_value( 3 )
+      c.should == "AUTOINDEX"
+    end
+
+    it "can return the number from a name" do
+      v = ::Libsql::SQLite3::Constants::StatementStatus.value_from_name( "autoindex" )
+      v.should == 3
+    end
+  end
+end