dbd-odbc 0.2.2

data/lib/dbd/odbc/driver.rb

@@ -0,0 +1,38 @@
+#
+# See DBI::BaseDriver
+#
+class DBI::DBD::ODBC::Driver < DBI::BaseDriver
+    def initialize
+        super("0.4.0")
+    end
+
+    def data_sources
+        ::ODBC.datasources.collect {|dsn| "dbi:ODBC:" + dsn.name }
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    def connect(dbname, user, auth, attr)
+        driver_attrs = dbname.split(';')
+
+        if driver_attrs.size > 1
+            # DNS-less connection
+            drv = ::ODBC::Driver.new
+            drv.name = 'Driver1'
+            driver_attrs.each do |param|
+                pv = param.split('=')
+                next if pv.size < 2
+                drv.attrs[pv[0]] = pv[1]
+            end
+            db = ::ODBC::Database.new
+            handle = db.drvconnect(drv)
+        else
+            # DNS given
+            handle = ::ODBC.connect(dbname, user, auth)
+        end
+
+        return DBI::DBD::ODBC::Database.new(handle, attr)
+    rescue ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+end

data/lib/dbd/odbc/statement.rb

@@ -0,0 +1,131 @@
+#
+# See DBI::BaseStatement.
+#
+class DBI::DBD::ODBC::Statement < DBI::BaseStatement
+    def initialize(handle, statement)
+        @statement = statement
+        @handle = handle
+        @params = []
+        @arr = []
+    end
+
+    #
+    # See DBI::BaseStatement#bind_param. This method will also raise
+    # DBI::InterfaceError if +param+ is not a Fixnum, to prevent incorrect
+    # binding.
+    #
+    def bind_param(param, value, attribs)
+        raise DBI::InterfaceError, "only ? parameters supported" unless param.is_a? Fixnum
+        @params[param-1] = value
+    end
+
+    def execute
+        @handle.execute(*@params)
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    def finish
+        @handle.drop
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    def cancel
+        @handle.cancel
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    def fetch
+        convert_row(@handle.fetch)
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    #
+    # See DBI::BaseStatement#fetch_scroll.
+    #
+    # ODBC has a native version of this method and the constnats in the ODBC
+    # driver themselves are supported. If you'd prefer to use DBI constants
+    # (recommended), you can use these which map to the ODBC functionality:
+    #
+    # * DBI::SQL_FETCH_FIRST
+    # * DBI::SQL_FETCH_LAST
+    # * DBI::SQL_FETCH_NEXT
+    # * DBI::SQL_FETCH_PRIOR
+    # * DBI::SQL_FETCH_ABSOLUTE
+    # * DBI::SQL_FETCH_RELATIVE
+    #
+    def fetch_scroll(direction, offset)
+        direction = case direction
+                    when DBI::SQL_FETCH_FIRST    then ::ODBC::SQL_FETCH_FIRST
+                    when DBI::SQL_FETCH_LAST     then ::ODBC::SQL_FETCH_LAST
+                    when DBI::SQL_FETCH_NEXT     then ::ODBC::SQL_FETCH_NEXT
+                    when DBI::SQL_FETCH_PRIOR    then ::ODBC::SQL_FETCH_PRIOR
+                    when DBI::SQL_FETCH_ABSOLUTE then ::ODBC::SQL_FETCH_ABSOLUTE
+                    when DBI::SQL_FETCH_RELATIVE then ::ODBC::SQL_FETCH_RELATIVE
+                    else
+                        direction
+                    end
+
+        convert_row(@handle.fetch_scroll(direction, offset))
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    #
+    # See DBI::BaseStatement#column_info. These additional attributes are also
+    # supported:
+    #
+    # * table: the table this column came from, if available.
+    # * nullable: boolean, true if NULL is accepted as a value in this column.
+    # * searchable: FIXME DOCUMENT
+    # * length: FIXME DOCUMENT
+    # * unsigned: For numeric columns, whether or not the result value is signed.
+    #
+    def column_info
+        info = []
+        @handle.columns(true).each do |col|
+            info << {
+                'name'       => col.name, 
+                'table'      => col.table,
+                'nullable'   => col.nullable,
+                'searchable' => col.searchable,
+                'precision'  => col.precision,
+                'scale'      => col.scale,
+                'sql_type'   => col.type,
+                'type_name'  => DBI::SQL_TYPE_NAMES[col.type],
+                'length'     => col.length,
+                'unsigned'   => col.unsigned
+            }
+        end
+        info
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    #
+    # See DBI::BaseStatement#rows.
+    #
+    # For queries which DBI::SQL.query? returns true, will explicitly return 0.
+    # Otherwise, it will return the row processed count.
+    #
+    def rows
+        return 0 if DBI::SQL.query?(@statement)
+        return @handle.nrows
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    private # -----------------------------------
+
+    # convert the ODBC datatypes to DBI datatypes
+    def convert_row(row)
+        return nil if row.nil?
+        row.collect do |col|
+            col = col.to_s unless col.nil?
+            col
+        end
+    end 
+end

data/test/DBD_TESTS

@@ -0,0 +1,48 @@
+================================================================================
+Using DBD tests
+================================================================================
+
+Create a YAML file named .ruby-dbi.test-config.yaml in your home directory.
+
+This file is a hash of keys that determine what you want to test and how you
+access the databases related to those tests.
+
+The key 'dbtypes' is an array which determines what tests you want to run. They
+*do not* correspond to the driver names, they correspond to the test
+directories that were made for them.
+
+Each 'dbtype' has a key that contains a hash of values:
+    - username: the username of your account
+    - password: the password for your account
+    - dbname: the name of the database to connect to
+
+NOTE that tests expect to connect to a database on localhost currently. This
+may be fixed in the future, especially when we start writing Oracle and
+SQLServer tests.
+
+Each DBD test relies on database semantics which may not match up entirely with
+this configuration. For instance, the postgresql tests expect you to be able to
+work with the database directly via the `psql' client. This is something which
+will eventually be remedied as time and ability allows.
+
+Here is a sample configuration to get you started with the postgresql tests:
+
+################################################################################
+
+---
+dbtypes:
+    - postgresql
+postgresql:
+    username: erikh
+    password: monkeys
+    dbname: rubytest 
+
+################################################################################
+
+NOTE the --- is part of the file and is not a separator.
+
+================================================================================
+Writing DBD tests
+================================================================================
+
+Coming soon.

data/test/dbd/general/test_database.rb

@@ -0,0 +1,157 @@
+@class = Class.new(DBDConfig.testbase(DBDConfig.current_dbtype)) do
+    def test_ping
+        assert @dbh.ping
+        # XXX if it isn't obvious, this should be tested better. Not sure what
+        # good behavior is yet.
+    end
+
+    def test_columns
+        assert_nothing_raised do
+            cols = @dbh.columns("precision_test")
+
+            assert(cols)
+            assert_kind_of(Array, cols)
+            assert_equal(2, cols.length)
+
+            # the first column should always be "text_field" and have the following
+            # properties:
+            assert_equal("text_field", cols[0]["name"])
+            assert(!cols[0]["nullable"])
+
+            assert_equal(20, cols[0]["precision"])
+            # scale can be either nil or 0 for character types.
+            case cols[0]["scale"]
+            when nil
+                assert_equal(nil, cols[0]["scale"])
+            when 0
+                assert_equal(0, cols[0]["scale"])
+            else
+                flunk "scale can be either 0 or nil for character types"
+            end
+
+            assert_equal(
+                DBI::Type::Varchar, 
+                DBI::TypeUtil.type_name_to_module(cols[0]["type_name"])
+            )
+
+            # the second column should always be "integer_field" and have the following
+            # properties:
+            assert_equal("integer_field", cols[1]["name"])
+            assert(cols[1]["nullable"])
+            assert_equal(1, cols[1]["scale"])
+            assert_equal(2, cols[1]["precision"])
+            assert_equal(
+                DBI::Type::Decimal, 
+                DBI::TypeUtil.type_name_to_module(cols[1]["type_name"])
+            )
+
+            # finally, we ensure that every column in the array is a ColumnInfo
+            # object
+            cols.each { |col| assert_kind_of(DBI::ColumnInfo, col) }
+        end
+    end
+
+    def test_prepare
+        @sth = @dbh.prepare('select * from names')
+
+        assert @sth
+        assert_kind_of DBI::StatementHandle, @sth
+
+        @sth.finish
+    end
+
+    def test_do
+        assert_equal 1, @dbh.do("insert into names (name, age) values (?, ?)", "Billy", 21)
+        @sth = @dbh.prepare("select * from names where name = ?")
+        @sth.execute("Billy")
+        assert_equal ["Billy", 21], @sth.fetch
+        @sth.finish
+    end
+
+    def test_tables
+        tables = @dbh.tables.sort
+
+        # since this is a general test, let's prune the system tables
+        # FIXME not so sure if this should be a general test anymore.
+        if dbtype == "odbc"
+            tables -= [
+                "administrable_role_authorizations",
+                "applicable_roles",
+                "attributes",
+                "check_constraint_routine_usage",
+                "check_constraints",
+                "column_domain_usage",
+                "column_privileges",
+                "column_udt_usage",
+                "columns",
+                "constraint_column_usage",
+                "constraint_table_usage",
+                "data_type_privileges",
+                "domain_constraints",
+                "domain_udt_usage",
+                "domains",
+                "element_types",
+                "enabled_roles",
+                "information_schema_catalog_name",
+                "key_column_usage",
+                "parameters",
+                "referential_constraints",
+                "role_column_grants",
+                "role_routine_grants",
+                "role_table_grants",
+                "role_usage_grants",
+                "routine_privileges",
+                "routines",
+                "schemata",
+                "sequences",
+                "sql_features",
+                "sql_implementation_info",
+                "sql_languages",
+                "sql_packages",
+                "sql_parts",
+                "sql_sizing",
+                "sql_sizing_profiles",
+                "table_constraints",
+                "table_privileges",
+                "tables",
+                "triggered_update_columns",
+                "triggers",
+                "usage_privileges",
+                "view_column_usage",
+                "view_routine_usage",
+                "view_table_usage",
+                "views"
+            ]
+        end
+        
+        case dbtype 
+        when "postgresql"
+            tables.reject! { |x| x =~ /^pg_/ }
+            assert_equal %w(array_test bit_test blob_test boolean_test bytea_test field_types_test names precision_test time_test timestamp_test view_names), tables
+        else
+            assert_equal %w(bit_test blob_test boolean_test field_types_test names precision_test time_test timestamp_test view_names), tables
+        end
+    end
+
+    def test_attrs
+        # test defaults
+        assert @dbh["AutoCommit"] # should be true
+
+        # test setting
+        assert !(@dbh["AutoCommit"] = false)
+        assert !@dbh["AutoCommit"]
+
+        # test committing an outstanding transaction
+        
+        @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
+        @sth.execute("Billy", 22)
+        @sth.finish
+
+        assert @dbh["AutoCommit"] = true # should commit at this point
+        
+        @sth = @dbh.prepare("select * from names where name = ?")
+        @sth.execute("Billy")
+        assert_equal [ "Billy", 22 ], @sth.fetch
+        @sth.finish
+    end
+end

data/test/dbd/general/test_statement.rb

@@ -0,0 +1,240 @@
+@class = Class.new(DBDConfig.testbase(DBDConfig.current_dbtype)) do
+    def test_quoting # FIXME breaks sqlite-ruby to a segfault - research
+        @sth = nil
+
+        assert_nothing_raised do
+            if dbtype == "postgresql"
+                @sth = @dbh.prepare('select E\'\\\\\'')
+            else
+                @sth = @dbh.prepare('select \'\\\\\'')
+            end
+            @sth.execute
+            row = @sth.fetch
+            assert_equal ['\\'], row
+            @sth.finish
+        end
+    end
+
+    def test_duplicate_columns
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select name, name from names where name = ?")
+            @sth.execute("Bob")
+            assert_equal [["Bob", "Bob"]], @sth.fetch_all
+            @sth.finish
+        end
+    end
+
+    def test_columninfo
+        @sth = nil
+        
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from precision_test")
+            @sth.execute
+
+            cols = @sth.column_info
+
+            assert(cols)
+            assert_kind_of(Array, cols)
+            assert_equal(2, cols.length)
+            
+            # the first column should always be "text_field" and have the following
+            # properties:
+            assert_equal("text_field", cols[0]["name"])
+            assert_equal(20, cols[0]["precision"])
+            # scale can be either nil or 0 for character types.
+            case cols[0]["scale"]
+            when nil
+                assert_equal(nil, cols[0]["scale"])
+            when 0
+                assert_equal(0, cols[0]["scale"])
+            else
+                flunk "scale can be either 0 or nil for character types"
+            end
+                
+            assert_equal(
+                DBI::Type::Varchar, 
+                DBI::TypeUtil.type_name_to_module(cols[0]["type_name"])
+            )
+
+            # the second column should always be "integer_field" and have the following
+            # properties:
+            assert_equal("integer_field", cols[1]["name"])
+            assert_equal(1, cols[1]["scale"])
+            assert_equal(2, cols[1]["precision"])
+            assert_equal(
+                DBI::Type::Decimal, 
+                DBI::TypeUtil.type_name_to_module(cols[1]["type_name"])
+            )
+
+            cols.each { |col| assert_kind_of(DBI::ColumnInfo, col) }
+            @sth.finish
+        end
+    end
+
+    def test_duplicate_columns
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select name, name from names where name = ?")
+            @sth.execute("Bob")
+            assert_equal [["Bob", "Bob"]], @sth.fetch_all
+            @sth.finish
+        end
+    end
+
+    def test_rows
+        @sth = nil
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
+            @sth.execute("Bill", 22);
+        end
+
+        assert 1, @sth.rows
+
+        @sth.finish
+        @sth = nil
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("delete from names where name = ?")
+            @sth.execute("Bill");
+        end
+
+        assert 1, @sth.rows
+
+        @sth.finish
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from names")
+            @sth.execute
+        end
+
+        assert_equal 0, @sth.rows
+        assert @sth.fetchable?
+        assert @sth.any?
+        assert @sth.rows.zero?
+        @sth.finish
+    end
+
+    def test_execute
+        assert_nothing_raised do 
+            @sth = @dbh.prepare("select * from names")
+            @sth.execute
+            @sth.finish
+        end
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from names where name = ?")
+            @sth.execute("Bob")
+            @sth.finish
+        end
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
+            @sth.execute("Bill", 22);
+            @sth.finish
+        end
+    end
+
+    def test_execute_with_transactions
+        @dbh["AutoCommit"] = false 
+        config = DBDConfig.get_config['sqlite3']
+
+        # rollback 1 (the right way)
+        @sth = nil
+        @sth2 = nil
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
+            @sth.execute("Billy", 23)
+            @sth2 = @dbh.prepare("select * from names where name = ?")
+            @sth2.execute("Billy")
+        end
+        assert_equal ["Billy", 23 ], @sth2.fetch
+        @sth2.finish
+        @sth.finish
+        assert_nothing_raised { @dbh.rollback }
+
+        @sth = @dbh.prepare("select * from names where name = ?")
+        @sth.execute("Billy")
+        assert_nil @sth.fetch
+        @sth.finish
+       
+        # rollback 2 (without closing statements first)
+
+        @sth = nil
+        @sth2 = nil
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
+            @sth.execute("Billy", 23)
+            @sth2 = @dbh.prepare("select * from names where name = ?")
+            @sth2.execute("Billy")
+        end
+
+        assert_equal ["Billy", 23], @sth2.fetch
+
+        # FIXME some throw here, some don't. we should probably normalize this
+        @dbh.rollback rescue true
+        
+        @sth2.finish
+        @sth.finish
+        assert_nothing_raised { @dbh.rollback }
+        
+        @sth = @dbh.prepare("select * from names where name = ?")
+        @sth.execute("Billy")
+        assert_nil @sth.fetch
+        @sth.finish
+
+        # commit
+
+        @sth = nil
+        @sth2 = nil
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
+            @sth.execute("Billy", 23)
+            @sth2 = @dbh.prepare("select * from names where name = ?")
+            @sth2.execute("Billy")
+        end
+        assert_equal ["Billy", 23 ], @sth2.fetch
+        @sth2.finish
+        @sth.finish
+        assert_nothing_raised { @dbh.commit }
+
+        @sth = @dbh.prepare("select * from names where name = ?")
+        @sth.execute("Billy")
+        assert_equal ["Billy", 23 ], @sth.fetch
+        @sth.finish
+    end
+
+    def test_fetch
+        @sth = nil
+        assert_nothing_raised do 
+            @sth = @dbh.prepare("select * from names order by age")
+            @sth.execute
+        end
+
+        # this tests that we're getting the rows in the right order,
+        # and that the types are being converted. 
+        assert_equal ["Joe", 19], @sth.fetch
+        assert_equal ["Bob", 21], @sth.fetch
+        assert_equal ["Jim", 30], @sth.fetch
+        assert_nil @sth.fetch
+
+        @sth.finish
+    end
+
+    def test_transaction_block
+        @dbh["AutoCommit"] = false
+        # this transaction should not fail because it called return early
+        @dbh.transaction do |dbh|
+            dbh.do('INSERT INTO names (name, age) VALUES (?, ?)', "Cooter", 69)
+            return 42
+        end 
+        @sth = @dbh.prepare("select * from names where name = ?")
+        @sth.execute("Cooter")
+        row = @sth.fetch
+        assert row
+        assert_equal ["Cooter", 69], row
+        @sth.finish
+    end
+end