ydbi 0.5.2 → 0.5.7

data/test/dbd/postgresql/up.sql

@@ -0,0 +1,60 @@
+create table names (
+    name varchar(255),
+    age integer
+);
+---
+insert into names (name, age) values ('Joe', 19);
+---
+insert into names (name, age) values ('Jim', 30);
+---
+insert into names (name, age) values ('Bob', 21);
+---
+create table precision_test (text_field varchar(20) primary key not null, integer_field integer, decimal_field decimal(2,1), numeric_field numeric(30,6));
+---
+CREATE TABLE blob_test (name VARCHAR(30), data OID);
+---
+create view view_names as select * from names;
+---
+create or replace function test_insert (varchar(255), integer) 
+    returns integer 
+    language sql 
+    as 'insert into names (name, age) values ($1, $2); select age from names where name = $1';
+---
+create table boolean_test (num integer, mybool boolean);
+---
+create table time_test (mytime time);
+---
+create table timestamp_test (mytimestamp timestamp);
+---
+create table bit_test (mybit bit);
+---
+create table field_types_test (foo integer not null primary key default 1);
+---
+create type enum_test as ENUM ('one', 'two', 'three');
+---
+create table enum_type_test (foo enum_test);
+---
+create table db_specific_types_test (foo integer);
+---
+create table array_test (foo integer[], bar integer[3], baz integer[3][3], quux varchar[2]);
+---
+create table bytea_test (foo bytea);
+---
+create schema schema1;
+---
+create schema schema2;
+---
+create table schema1.tbl (foo integer);
+---
+create table schema2.tbl (bar integer);
+---
+create or replace function 
+    select_subproperty(value names.age%TYPE, sub names.age%TYPE, out retval names.age%TYPE) 
+    as $$ 
+        select 
+            case 
+            when $2 is not null 
+                then $1 
+            else null 
+        end 
+    $$ language sql;

data/test/dbd/sqlite/base.rb

@@ -0,0 +1,32 @@
+require 'fileutils'
+
+DBDConfig.set_testbase(:sqlite, Class.new(Test::Unit::TestCase) do
+
+        def dbtype
+            "sqlite"
+        end
+
+        def test_base
+            if @dbh # FIXME for some reason, @dbh isn't initialized in some cases. investigate.
+                assert_equal(@dbh.driver_name, "SQLite")
+                assert_kind_of(DBI::DBD::SQLite::Database, @dbh.instance_variable_get(:@handle))
+            end
+        end
+
+        def set_base_dbh
+            config = DBDConfig.get_config['sqlite']
+            @dbh = DBI.connect('dbi:SQLite:'+config['dbname'], nil, nil, { }) 
+        end
+
+        def setup
+            set_base_dbh
+            DBDConfig.inject_sql(@dbh, dbtype, "dbd/sqlite/up.sql")
+        end
+
+        def teardown
+            @dbh.disconnect if @dbh.connected?
+            config = DBDConfig.get_config['sqlite']
+            FileUtils.rm_f(config['dbname'])
+        end
+    end
+)

data/test/dbd/sqlite/test_database.rb

@@ -0,0 +1,30 @@
+class TestSQLiteDatabase < DBDConfig.testbase(:sqlite)
+    def test_database_name
+        assert_nothing_raised do
+            assert_equal DBDConfig.get_config[dbtype]['dbname'], @dbh.database_name
+        end
+    end
+
+    def test_disconnect
+        assert_nil @dbh.disconnect
+        assert_nil @dbh.instance_variable_get("@db")
+    end
+    
+    def test_columns
+        assert_equal [
+            {
+                :name       => "name",
+                :default    => nil,
+                :nullable   => true,
+                :precision  => 255,
+                :type_name  => "varchar"
+            },
+            {
+                :name       => "age",
+                :default    => nil,
+                :nullable   => true,
+                :type_name  => "integer"
+            }
+        ], @dbh.columns("names")  
+    end
+end

data/test/dbd/sqlite/test_driver.rb

@@ -0,0 +1,68 @@
+class TestSQLiteDriver < DBDConfig.testbase(:sqlite)
+    def test_require
+        require 'dbd/SQLite'
+        assert_kind_of Module, DBI
+        assert_kind_of Module, DBI::DBD
+        assert_kind_of Class, DBI::DBD::SQLite
+        assert_kind_of Class, DBI::DBD::SQLite::Driver
+        assert_kind_of Class, DBI::DBD::SQLite::Database
+        assert_kind_of Class, DBI::DBD::SQLite::Statement
+    end
+
+    def test_connect
+        config = DBDConfig.get_config['sqlite']
+
+        # this tests DBI more than SQLite, but makes sure our chain works with it.
+        dbh = DBI.connect("dbi:SQLite:" + config['dbname'], nil, nil, {})
+        assert dbh
+        assert_kind_of DBI::DatabaseHandle, dbh
+
+        # first argument should be a string
+        assert_raises(DBI::InterfaceError) do
+            DBI::DBD::SQLite::Driver.new.connect(nil, nil, nil, { })
+        end
+
+        # that string should have some frackin' length
+        assert_raises(DBI::InterfaceError) do
+            DBI::DBD::SQLite::Driver.new.connect("", nil, nil, { })
+        end
+
+        # last argument should be a hash
+        assert_raises(DBI::InterfaceError) do
+            DBI::DBD::SQLite::Driver.new.connect(config['dbname'], nil, nil, nil)
+        end
+
+        dbh = nil
+        driver = nil
+        assert_nothing_raised do
+            driver = DBI::DBD::SQLite::Driver.new
+            dbh = driver.connect(config['dbname'], nil, nil, { })
+        end
+
+        assert_kind_of DBI::DBD::SQLite::Driver, driver
+        assert_kind_of DBI::DBD::SQLite::Database, dbh
+
+        assert !dbh.instance_variable_get("@autocommit")
+
+        dbh = nil 
+        driver = nil
+        assert_nothing_raised do
+            dbh = DBI::DBD::SQLite::Driver.new.connect(config['dbname'], nil, nil, { "AutoCommit" => true, "sqlite_full_column_names" => true })
+        end
+       
+        assert dbh
+        assert dbh.instance_variable_get("@attr_hash")
+        assert_equal 0, dbh.instance_variable_get("@open_handles")
+        assert_kind_of SQLite::Database, dbh.instance_variable_get("@db")
+
+        assert File.exists?(config['dbname'])
+    end
+
+    def setup
+    end
+
+    def teardown
+        config = DBDConfig.get_config['sqlite']
+        FileUtils.rm_f(config['dbname'])
+    end
+end

data/test/dbd/sqlite/test_statement.rb

@@ -0,0 +1,112 @@
+class TestSQLiteStatement < DBDConfig.testbase(:sqlite)
+    def test_constructor
+        sth = DBI::DBD::SQLite::Statement.new("select * from foo", @dbh.instance_variable_get("@handle"))
+
+        assert_kind_of DBI::DBD::SQLite::Statement, sth
+        assert sth.instance_variable_get("@dbh")
+        assert_kind_of DBI::DBD::SQLite::Database, sth.instance_variable_get("@dbh")
+        assert_equal(@dbh.instance_variable_get("@handle"), sth.instance_variable_get("@dbh"))
+        assert_kind_of DBI::SQL::PreparedStatement, sth.instance_variable_get("@statement")
+        assert_equal({ }, sth.instance_variable_get("@attr"))
+        assert_equal([ ], sth.instance_variable_get("@params"))
+        assert_nil(sth.instance_variable_get("@result_set"))
+        assert_equal([ ], sth.instance_variable_get("@rows"))
+
+        sth = @dbh.prepare("select * from foo")
+
+        assert_kind_of DBI::StatementHandle, sth
+    end
+
+    def test_bind_param
+        sth = DBI::DBD::SQLite::Statement.new("select * from foo", @dbh.instance_variable_get("@handle"))
+
+        assert_raises(DBI::InterfaceError) do
+            sth.bind_param(:foo, "monkeys")
+        end
+
+        # XXX this is fairly ugly, but...
+        # what i've attempted to do here is normalize what is tested, even
+        # though the data differs subtly.  you'll notice that there are two
+        # arrays that get passed to the each block for evaluation.  the first
+        # argument is the statment handle (raw from SQLite DBD or the facade
+        # from DBI), the second is how we access the @params internally held
+        # variable, and the third is how these params are scrubbed before we
+        # assert against them.
+        #
+        # the @params variable is in different spots in both statement handles
+        # and the values of the params are quoted differently. However, the
+        # full pipe works and I'd like to ensure that both do their job as a
+        # team.
+        #
+        [ 
+          [ 
+              sth, 
+              proc { |x| x.instance_variable_get("@params") }, 
+              proc { |x| x } 
+          ],
+          [ 
+              @dbh.prepare("select * from foo"), 
+              proc { |x| x.instance_variable_get("@handle").instance_variable_get("@params") },
+              proc { |x| x.gsub(/(^')|('$)/, '') }
+          ]
+        ].each do |sthpack|
+            sthpack[0].bind_param(1, "monkeys", nil)
+
+            params = sthpack[1].call(sthpack[0])
+            
+            assert_equal "monkeys", sthpack[2].call(params[0])
+
+            # set a bunch of stuff.
+            %w(I like monkeys).each_with_index { |x, i| sthpack[0].bind_param(i+1, x) }
+
+            params = sthpack[1].call(sthpack[0])
+            
+            assert_equal %w(I like monkeys), params.collect { |x| sthpack[2].call(x) }
+
+            # FIXME what to do with attributes? are they important in SQLite?
+        end
+    end
+    
+    def test_column_info
+        sth = nil
+        
+        assert_nothing_raised do 
+            sth = @dbh.prepare("select * from names")
+            sth.execute
+        end
+
+        assert_kind_of Array, sth.column_info 
+        assert_kind_of DBI::ColumnInfo, sth.column_info[0]
+        assert_kind_of DBI::ColumnInfo, sth.column_info[1]
+        assert_equal [ 
+            { 
+                :name  => "name",
+                :sql_type  => 12,
+                :precision  => 255,
+                :type_name  => "varchar"
+            }, 
+            { 
+                :name  => "age",
+                :sql_type  => 4,
+                :type_name  => "integer"
+            } 
+        ], sth.column_info
+
+        sth.finish
+    end
+
+    def test_specific_types
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into db_specific_types_test (dbl) values (?)")
+            @sth.execute(11111111.111111)
+            @sth.finish
+        end
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from db_specific_types_test")
+            @sth.execute
+            assert_equal([11111111.111111], @sth.fetch)
+            @sth.finish
+        end
+    end
+end

data/test/dbd/sqlite/up.sql

@@ -0,0 +1,25 @@
+create table names (name varchar(255), age integer);
+---
+insert into names (name, age) values ("Bob", 21);
+---
+insert into names (name, age) values ("Joe", 19);
+---
+insert into names (name, age) values ("Jim", 30);
+---
+create table precision_test (text_field varchar(20) primary key not null, integer_field integer, decimal_field decimal(2,1), numeric_field numeric(30,6));
+---
+create view view_names as select * from names;
+---
+create table blob_test (name varchar(255));
+---
+create table boolean_test (num integer, mybool boolean);
+---
+create table time_test (mytime time);
+---
+create table timestamp_test (mytimestamp timestamp);
+---
+create table bit_test (mybit bit);
+---
+create table field_types_test (foo integer not null primary key default 1);
+---
+create table db_specific_types_test (dbl double);

data/test/dbd/sqlite3/base.rb

@@ -0,0 +1,32 @@
+require 'fileutils'
+
+DBDConfig.set_testbase(:sqlite3, Class.new(Test::Unit::TestCase) do
+        def dbtype 
+            "sqlite3"
+        end
+
+        def test_base
+            if @dbh # FIXME for some reason, @dbh isn't initialized in some cases. investigate.
+                assert_equal(@dbh.driver_name, "SQLite3")
+                assert_kind_of(DBI::DBD::SQLite3::Database, @dbh.instance_variable_get(:@handle))
+            end
+        end
+
+        def set_base_dbh
+            config = DBDConfig.get_config['sqlite3']
+            @dbh = DBI.connect('dbi:SQLite3:'+config['dbname'], nil, nil, { }) 
+        end
+
+        def setup
+            set_base_dbh
+            DBDConfig.inject_sql(@dbh, dbtype, "dbd/sqlite3/up.sql")
+        end
+
+        def teardown
+            @sth.finish if(@sth && !@sth.finished?)
+            @dbh.disconnect if @dbh.connected?
+            config = DBDConfig.get_config['sqlite3']
+            FileUtils.rm_f(config['dbname'])
+        end
+    end
+)

data/test/dbd/sqlite3/test_database.rb

@@ -0,0 +1,77 @@
+class TestDatabase < DBDConfig.testbase(:sqlite3)
+    def test_database_name
+        assert_nothing_raised do
+            assert_equal DBDConfig.get_config[dbtype]['dbname'], @dbh.database_name
+        end
+    end
+
+    def test_disconnect
+        assert_nil @dbh.disconnect
+        assert_nil @dbh.instance_variable_get("@db")
+    end
+
+    def test_columns
+        assert_equal [
+            {
+                :name      => "name",
+                :default   => nil,
+                :nullable  => true,
+                :sql_type  => 100,
+                :precision => 255,
+                :type_name => "varchar"
+            },
+            {
+                :name      => "age",
+                :default   => nil,
+                :nullable  => true,
+                :sql_type  => 4,
+                :type_name => "integer"
+            }
+        ], @dbh.columns("names")
+
+        assert_equal [
+            {
+                :name      => "name",
+                :default   => nil,
+                :nullable  => true,
+                :sql_type  => 100,
+                :precision => 255,
+                :type_name => "varchar"
+            },
+            {
+                :name      => "age",
+                :default   => nil,
+                :nullable  => true,
+                :sql_type  => 4,
+                :type_name => "integer"
+            }
+        ], @dbh.columns("names_defined_with_spaces")
+    end
+    
+    def test_parse_type
+      # Some tests to ensure various whitespace and case styles don't confuse parse_type.
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR(4096)' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'varchar(4096)' )
+      assert_equal 'varchar', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR( 4096 )' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR ( 4096 )' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR (4096)' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+    end
+end

data/test/dbd/sqlite3/test_driver.rb

@@ -0,0 +1,67 @@
+class TestDriver < DBDConfig.testbase(:sqlite3)
+    def test_require
+        require 'dbd/SQLite3'
+        assert_kind_of Module, DBI
+        assert_kind_of Module, DBI::DBD
+        assert_kind_of Module, DBI::DBD::SQLite3
+        assert_kind_of Class, DBI::DBD::SQLite3::Driver
+        assert_kind_of Class, DBI::DBD::SQLite3::Database
+        assert_kind_of Class, DBI::DBD::SQLite3::Statement
+    end
+
+    def test_connect
+        config = DBDConfig.get_config['sqlite3']
+
+        # this tests DBI more than SQLite, but makes sure our chain works with it.
+        dbh = DBI.connect("dbi:SQLite3:" + config['dbname'], nil, nil, {})
+        assert dbh
+        assert_kind_of DBI::DatabaseHandle, dbh
+
+        # first argument should be a string
+        assert_raises(DBI::InterfaceError) do
+            DBI::DBD::SQLite3::Driver.new.connect(nil, nil, nil, { })
+        end
+
+        # that string should have some frackin' length
+        assert_raises(DBI::InterfaceError) do
+            DBI::DBD::SQLite3::Driver.new.connect("", nil, nil, { })
+        end
+
+        # last argument should be a hash
+        assert_raises(DBI::InterfaceError) do
+            DBI::DBD::SQLite3::Driver.new.connect(config['dbname'], nil, nil, nil)
+        end
+
+        dbh = nil
+        driver = nil
+        assert_nothing_raised do
+            driver = DBI::DBD::SQLite3::Driver.new
+            dbh = driver.connect(config['dbname'], nil, nil, { })
+        end
+
+        assert_kind_of DBI::DBD::SQLite3::Driver, driver
+        assert_kind_of DBI::DBD::SQLite3::Database, dbh
+
+        assert !dbh.instance_variable_get("@autocommit")
+
+        dbh = nil 
+        driver = nil
+        assert_nothing_raised do
+            dbh = DBI::DBD::SQLite3::Driver.new.connect(config['dbname'], nil, nil, { "AutoCommit" => true, "sqlite_full_column_names" => true })
+        end
+       
+        assert dbh
+        assert dbh.instance_variable_get("@attr")
+        assert_kind_of SQLite3::Database, dbh.instance_variable_get("@db")
+
+        assert File.exists?(config['dbname'])
+    end
+
+    def setup
+    end
+
+    def teardown
+        config = DBDConfig.get_config['sqlite3']
+        FileUtils.rm_f(config['dbname'])
+    end
+end