rails-dbd-mysql 0.1.0

data/lib/dbd/mysql/driver.rb

@@ -0,0 +1,125 @@
+module DBI::DBD::Mysql
+    #
+    # Models the DBI::BaseDriver API to create DBI::DriverHandle objects.
+    #
+    class Driver < DBI::BaseDriver
+        include Util
+
+        def initialize
+            super("0.4.0")
+        end
+
+        def default_user
+            ['', nil]
+        end
+
+        #
+        # Parameters in the dbname as follows:
+        #
+        # * host: host to connect to
+        # * port: port to connect to
+        # * socket: connect to a specific unix socket instead of a TCP socket.
+        # * flag: an OR'd collection of flags to pass to the lower-level
+        #   connection attempt.
+        # * mysql_read_default_file: FIXME
+        # * mysql_read_default_group: FIXME
+        # * mysql_compression: FIXME
+        # * mysql_local_infile: FIXME
+        # * mysql_client_found_rows: FIXME boolean, modifies the 'flag'
+        #   setting above.
+        def connect(dbname, user, auth, attr)
+            # connect to database server
+            hash = DBI::Utils.parse_params(dbname)
+
+            hash['host'] ||= 'localhost'
+
+            # these two connection parameters should be passed as numbers
+            hash['port'] = hash['port'].to_i unless hash['port'].nil?
+            hash['flag'] = hash['flag'].nil? ? 0 : hash['flag'] = hash['flag'].to_i
+
+            handle = ::Mysql.init
+
+            # Look for options in connect string to be handled
+            # through mysql_options() before connecting
+            !hash['mysql_read_default_file'].nil? and
+            handle.options(::Mysql::READ_DEFAULT_FILE,
+                           hash['mysql_read_default_file'])
+            !hash['mysql_read_default_group'].nil? and
+            handle.options(::Mysql::READ_DEFAULT_GROUP,
+                           hash['mysql_read_default_group'])
+            # The following options can be handled either using mysql_options()
+            # or in the flag argument to connect().
+            hash['mysql_compression'].to_i != 0 and
+            handle.options(::Mysql::OPT_COMPRESS, nil)
+            hash['mysql_local_infile'].to_i != 0 and
+            handle.options(::Mysql::OPT_LOCAL_INFILE, true)
+
+            # Look for options to be handled in the flags argument to connect()
+            if !hash['mysql_client_found_rows'].nil?
+                if hash['mysql_client_found_rows'].to_i != 0
+                    hash['flag'] |= ::Mysql::CLIENT_FOUND_ROWS
+                else
+                    hash['flag'] &= ~::Mysql::CLIENT_FOUND_ROWS
+                end
+            end
+
+            handle.connect(hash['host'], user, auth, hash['database'], hash['port'], hash['socket'], hash['flag'])
+
+            return Database.new(handle, attr)
+        rescue MyError => err
+            error(err)
+        end
+
+        def data_sources
+            handle = ::Mysql.new
+            res = handle.list_dbs.collect {|db| "dbi:Mysql:database=#{db}" }
+            handle.close
+            return res
+        rescue MyError => err
+            error(err)
+        end
+
+        #--
+        # Driver-specific functions ------------------------------------------------
+        #++
+
+        public
+
+        def __createdb(db, host, user, password, port=nil, sock=nil, flag=nil)
+            handle = ::Mysql.connect(host, user, password, nil, port, sock, flag)
+            begin
+                handle.create_db(db)
+            ensure
+                handle.close if handle
+            end
+        end
+
+        def __dropdb(db, host, user, password, port=nil, sock=nil, flag=nil)
+            handle = ::Mysql.connect(host, user, password, nil, port, sock, flag)
+            begin
+                handle.drop_db(db)
+            ensure
+                handle.close if handle
+            end
+        end
+
+        def __shutdown(host, user, password, port=nil, sock=nil, flag=nil)
+            handle = ::Mysql.connect(host, user, password, nil, port, sock, flag)
+            begin
+                handle.shutdown
+            ensure
+                handle.close if handle
+            end
+        end
+
+        def __reload(host, user, password, port=nil, sock=nil, flag=nil)
+            handle = ::Mysql.connect(host, user, password, nil, port, sock, flag)
+            begin
+                handle.reload
+            ensure
+                handle.close if handle
+            end
+        end
+
+    end # class Driver
+end

data/lib/dbd/mysql/statement.rb

@@ -0,0 +1,188 @@
+module DBI::DBD::Mysql
+    #
+    # Models the DBI::BaseStatement API to create DBI::StatementHandle objects.
+    # 
+    class Statement < DBI::BaseStatement
+        include Util
+
+        def initialize(parent, handle, statement, mutex)
+            super(nil)
+
+            @parent, @handle, @mutex = parent, handle, mutex
+            @params = []
+
+            @prep_stmt = DBI::SQL::PreparedStatement.new(@parent, statement)
+        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 InterfaceError, "only ? parameters supported" unless param.is_a? Fixnum
+            @params[param-1] = value 
+        end
+
+        #
+        # See DBI::BaseStatement#execute. If DBI thinks this is a query via DBI::SQL.query?(), 
+        # it will force the row processed count to 0. Otherwise, it will return
+        # what MySQL thinks is the row processed count.
+        #
+        def execute
+            sql = @prep_stmt.bind(@params)
+            @mutex.synchronize {
+                @handle.query_with_result = true
+                @res_handle = @handle.query(sql)
+                @column_info = self.column_info
+                @current_row = 0
+                @rows = DBI::SQL.query?(sql) ? 0 : @handle.affected_rows 
+            }
+        rescue MyError => err
+            error(err)
+        end
+
+        def finish
+            @res_handle.free if @res_handle
+        rescue MyError => err
+            error(err)
+        end
+
+        #
+        # Helper method to aid #fetch. Do not call directly.
+        #
+        def fill_array(rowdata)
+            return nil if rowdata.nil?
+            return rowdata.dup
+        end
+
+        def fetch
+            @current_row += 1
+            fill_array(@res_handle.fetch_row)
+        rescue MyError => err
+            error(err)
+        end
+
+        # 
+        # See DBI::BaseStatement#fetch_scroll. These additional constants are also supported:
+        #
+        # * DBI::SQL_FETCH_PRIOR: Fetch the row previous to the current one.
+        # * DBI::SQL_FETCH_FIRST: Fetch the first row.
+        # * DBI::SQL_FETCH_ABSOLUTE: Fetch the row at the offset provided.
+        # * DBI::SQL_FETCH_RELATIVE: Fetch the row at the current point + offset.
+        #
+        def fetch_scroll(direction, offset)
+            case direction
+            when DBI::SQL_FETCH_NEXT
+                @current_row += 1
+                fill_array(@res_handle.fetch_row)
+            when DBI::SQL_FETCH_PRIOR
+                @res_handle.data_seek(@current_row - 1)
+                fill_array(@res_handle.fetch_row)
+            when DBI::SQL_FETCH_FIRST
+                @current_row = 1
+                @res_handle.data_seek(@current_row - 1)
+                fill_array(@res_handle.fetch_row)
+            when DBI::SQL_FETCH_LAST
+                @current_row = @res_handle.num_rows
+                @res_handle.data_seek(@current_row - 1)
+                fill_array(@res_handle.fetch_row)
+            when DBI::SQL_FETCH_ABSOLUTE
+                @current_row = offset + 1
+                @res_handle.data_seek(@current_row - 1)
+                fill_array(@res_handle.fetch_row)
+            when DBI::SQL_FETCH_RELATIVE
+                @current_row += offset + 1
+                @res_handle.data_seek(@current_row - 1)
+                fill_array(@res_handle.fetch_row)
+            else
+                raise NotSupportedError
+            end
+            #end
+        end
+
+        #
+        # See DBI::BaseStatement#column_info, and DBI::DBD::Mysql::Database#columns.
+        #
+        # This method provides all the attributes the +columns+ method
+        # provides, and a few others:
+        #
+        # * mysql_type: These correspond to constants in the Mysql::Types
+        #   package, in the lower-level 'mysql' package.
+        # * mysql_type_name: A text representation of +mysql_type+. 
+        # * mysql_length: The length of the column.
+        # * mysql_max_length: The max length of the column. FIXME DESCRIBE
+        #   DIFFERENCE
+        # * mysql_flags: Internal MySQL flags on this column.
+        #
+        def column_info
+            retval = []
+
+            return [] if @res_handle.nil?
+
+            unique_key_flag = MysqlField.const_get(:UNIQUE_KEY_FLAG)
+            multiple_key_flag = MysqlField.const_get(:MULTIPLE_KEY_FLAG)
+            indexed = (unique_key_flag | multiple_key_flag)
+
+            # Note: Cannot get 'default' column attribute because MysqlField.def
+            # is set only by mysql_list_fields()
+
+            @res_handle.fetch_fields.each {|col| 
+                mysql_type_name, dbi_type = Database::TYPE_MAP[col.type] rescue [nil, nil]
+                xopen_info = Database::MYSQL_to_XOPEN[mysql_type_name] ||
+                    Database::MYSQL_to_XOPEN[nil]
+                sql_type = xopen_info[0]
+                type_name = DBI::SQL_TYPE_NAMES[sql_type]
+
+                retval << {
+                    # Standard Ruby DBI column attributes
+                    'name'        => col.name,
+                    'sql_type'    => sql_type,
+                    'type_name'   => type_name,
+                    # XXX it seems mysql counts the literal decimal point when weighing in the "length".
+                    'precision'   => type_name == "NUMERIC" ? col.length - 2 : col.length,
+                    'scale'       => col.decimals,
+                    'nullable'    => !col.is_not_null?,
+                    'indexed'     => ((col.flags & indexed) != 0) ||
+                                        col.is_pri_key?,
+                    'primary'     => col.is_pri_key?,
+                    'unique'      => ((col.flags & unique_key_flag) != 0) ||
+                                        col.is_pri_key?,
+                    # MySQL-specific attributes (signified by leading "mysql_")
+                    'mysql_type'       => col.type,
+                    'mysql_type_name'  => mysql_type_name,
+                    'mysql_length'     => col.length,
+                    'mysql_max_length' => col.max_length,
+                    'mysql_flags'      => col.flags
+                }
+
+                if retval[-1]['sql_type'] == DBI::SQL_TINYINT and retval[-1]['precision'] == 1
+                    retval[-1]['dbi_type'] = DBI::Type::Boolean
+                elsif dbi_type
+                    retval[-1]['dbi_type'] = dbi_type
+                end
+            }
+            retval
+        rescue MyError => err
+            error(err)
+        end
+
+        def rows
+            @rows
+        end
+
+#                 def []=(attr, value)
+#                     case attr
+#                     when 'mysql_use_result'
+#                         @attr['mysql_store_result'] = ! value
+#                         @attr['mysql_use_result']   = value
+#                     when 'mysql_store_result'
+#                         @attr['mysql_use_result']   = ! value
+#                         @attr['mysql_store_result'] = value
+#                     else
+#                         raise NotSupportedError
+#                     end
+#                 end
+
+    end # class Statement
+end

data/test/DBD_TESTS

@@ -0,0 +1,50 @@
+================================================================================
+Using DBD tests
+================================================================================
+
+Before you do anything, read the TESTING file.
+
+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,206 @@
+@class = Class.new(DBDConfig.testbase(DBDConfig.current_dbtype)) do
+
+    def test_last_statement
+        @sth = @dbh.prepare("select * from names")
+        @sth.finish
+        assert_equal "select * from names", @dbh.last_statement
+
+        @sth = @dbh.execute("select * from names")
+        @sth.finish
+        assert_equal "select * from names", @dbh.last_statement
+         
+        @dbh.do("select * from names")
+        assert_equal "select * from names", @dbh.last_statement
+    end
+
+    def test_empty_query
+        ["", " ", "\t"].each do |str|
+            [:do, :prepare, :execute, :select_one, :select_all].each do |call|
+                assert_raises(DBI::InterfaceError) do
+                    @dbh.send(call, str)
+                end
+            end
+        end
+    end
+
+    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(4, 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.object_id,
+                DBI::TypeUtil.type_name_to_module(cols[0]["type_name"]).object_id
+            )
+
+            # 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[2]["scale"])
+            assert_equal(2, cols[2]["precision"])
+
+            assert_equal(
+                DBI::Type::Integer.object_id,
+                DBI::TypeUtil.type_name_to_module(cols[1]["type_name"]).object_id
+            )
+
+            # the second column should always be "integer_field" and have the following
+            # properties:
+            assert_equal("decimal_field", cols[2]["name"])
+            assert(cols[2]["nullable"])
+            assert_equal(1, cols[2]["scale"])
+            assert_equal(2, cols[2]["precision"])
+            assert_equal(
+                DBI::Type::Decimal.object_id,
+                DBI::TypeUtil.type_name_to_module(cols[2]["type_name"]).object_id
+            )
+
+            # the second column should always be "numeric_field" and have the following
+            # properties:
+            assert_equal("numeric_field", cols[3]["name"])
+            assert(cols[3]["nullable"])
+            assert_equal(6, cols[3]["scale"])
+            assert_equal(30, cols[3]["precision"])
+            assert_equal(
+                DBI::Type::Decimal.object_id,
+                DBI::TypeUtil.type_name_to_module(cols[3]["type_name"]).object_id
+            )
+
+            # 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 db_specific_types_test enum_type_test field_types_test names precision_test time_test timestamp_test view_names), tables
+        when 'sqlite3'
+            assert_equal %w(bit_test blob_test boolean_test db_specific_types_test field_types_test names names_defined_with_spaces precision_test time_test timestamp_test view_names), tables
+        else
+            assert_equal %w(bit_test blob_test boolean_test db_specific_types_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