ydbi 0.5.0

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/lib/dbd/odbc/database.rb

@@ -0,0 +1,128 @@
+#
+# See DBI::BaseDatabase.
+#
+class DBI::DBD::ODBC::Database < DBI::BaseDatabase
+    def disconnect
+        @handle.rollback
+        @handle.disconnect 
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    def database_name
+        @handle.get_info('SQL_DATABASE_NAME')
+    end
+
+    def ping
+        @handle.connected?
+    end
+
+    #
+    # See DBI::BaseDatabase#columns. Additional Attributes:
+    #
+    # * nullable: boolean, true if NULLs are allowed in this column.
+    #
+    def columns(table)
+        cols = []
+
+        stmt = @handle.columns(table)
+        stmt.ignorecase = true
+
+        stmt.each_hash do |row|
+            info = Hash.new
+            cols << info
+
+            info['name']      = row['COLUMN_NAME']
+            info['type_name'] = row['TYPE_NAME']
+            info['sql_type']  = row['DATA_TYPE']
+            info['nullable']  = 
+                case row['NULLABLE']
+                when 1
+                    true
+                when 0
+                    false
+                else
+                    nil
+                end
+            info['precision'] = row['PRECISION']
+            info['scale']     = row['SCALE']
+        end
+
+        stmt.drop
+        cols
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    def tables
+        stmt = @handle.tables
+        stmt.ignorecase = true
+        tabs = [] 
+        stmt.each_hash {|row|
+            tabs << row["TABLE_NAME"]
+        }
+        stmt.drop
+        tabs
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    def prepare(statement)
+        DBI::DBD::ODBC::Statement.new(@handle.prepare(statement), statement)
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    def do(statement, *bindvars)
+        @handle.do(statement, *bindvars) 
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    def execute(statement, *bindvars)
+        stmt = @handle.run(statement, *bindvars) 
+        DBI::DBD::ODBC::Statement.new(stmt, statement)
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    #
+    # Additional Attributes on the DatabaseHandle:
+    #
+    # * AutoCommit: force a commit after each statement execution.
+    # * odbc_ignorecase: Be case-insensitive in operations. 
+    # * odbc_timeout: Return after a certain time regardless of whether the operation returned anything.
+    #
+    def []=(attr, value)
+        case attr
+        when 'AutoCommit'
+            @handle.autocommit(value)
+        when 'odbc_ignorecase'
+            @handle.ignorecase(value)
+        when 'odbc_timeout'
+            @handle.timeout(value)
+        else
+            if attr =~ /^odbc_/ or attr != /_/
+                raise DBI::NotSupportedError, "Option '#{attr}' not supported"
+            else # option for some other driver - quitly ignore
+                return
+            end
+        end
+        @attr[attr] = value
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    def commit
+        @handle.commit
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    def rollback
+        @handle.rollback
+    rescue DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+end # class Database

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 DBI::DBD::ODBC::ODBCErr => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+end

data/lib/dbd/odbc/statement.rb

@@ -0,0 +1,137 @@
+#
+# 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|
+            case col
+            when nil
+                nil
+            when ODBC::TimeStamp
+                DBI::Type::Timestamp.create col.year, col.month, col.day, col.hour, col.minute, col.second
+            else
+                col.to_s
+            end
+        end
+    end 
+end