ydbi 0.5.7 → 0.5.8

data/lib/dbd/SQLite.rb

@@ -1,97 +0,0 @@
-#--
-###############################################################################
-#
-# DBD::SQLite - a DBD for SQLite for versions < 3
-#
-# Uses Jamis Buck's 'sqlite-ruby' driver to interface with SQLite directly
-#
-# (c) 2008 Erik Hollensbe & Christopher Maujean.
-#
-# TODO
-#
-# fetch_scroll implementation?
-# columns and column_info differ too much and have too much copied code, refactor
-# there are probably some edge cases with transactions
-#
-################################################################################
-#++
-
-begin
-    require 'rubygems'
-    gem 'sqlite-ruby'
-    gem 'dbi'
-rescue Exception => e
-end
-
-require 'dbi'
-require 'sqlite'
-
-module DBI
-    module DBD
-        #
-        # DBD::SQLite - Database Driver for SQLite versions 2.x and lower.
-        #
-        # Requires DBI and the 'sqlite-ruby' gem to work.
-        #
-        # Only things that extend DBI's results are documented.
-        #
-        class SQLite
-            VERSION = "0.1.2"
-            DESCRIPTION = "SQLite 2.x DBI DBD"
-
-            #
-            # returns 'SQLite'
-            #
-            # See DBI::TypeUtil#convert for more information.
-            #
-            def self.driver_name
-                "SQLite"
-            end
-
-            #
-            # Validates that the SQL has no literal NUL characters. (ASCII 0)
-            #
-            # SQLite apparently really hates it when you do that.
-            #
-            # It will raise DBI::DatabaseError should it find any.
-            #
-            def self.check_sql(sql)
-                # XXX I'm starting to think this is less of a problem with SQLite
-                # and more with the old C DBD
-                raise DBI::DatabaseError, "Bad SQL: SQL cannot contain nulls" if sql =~ /\0/
-            end
-
-            #
-            # Split a type definition into parts via String#match and return the whole result.
-            #
-            def self.parse_type(type_name)
-                type_name.match(/^([^\(]+)(\((\d+)(,(\d+))?\))?$/)
-            end
-
-            #
-            # See DBI::BaseDriver.
-            #
-            class Driver < DBI::BaseDriver
-                def initialize
-                    super "0.4.0"
-                end
-
-                def connect(dbname, user, auth, attr_hash)
-                    return Database.new(dbname, user, auth, attr_hash)
-                end
-            end
-        end
-    end
-end
-
-require 'dbd/sqlite/database'
-require 'dbd/sqlite/statement'
-
-DBI::TypeUtil.register_conversion(DBI::DBD::SQLite.driver_name) do |obj|
-    case obj
-    when ::NilClass
-        ["NULL", false]
-    else 
-        [obj, true]
-    end
-end

data/lib/dbd/SQLite3.rb

@@ -1,124 +0,0 @@
-#--
-# DBD::SQLite3
-#
-# copyright (c) 2005 Jun Mukai <mukai@jmuk.org>
-# Compatibility patches by Erik Hollensbe <erik@hollensbe.org>
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the above copyright
-#    notice, this list of conditions and the following disclaimer in the
-#    documentation and/or other materials provided with the distribution.
-# 3. The name of the author may not be used to endorse or promote products
-#    derived from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
-# AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
-# THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#++
-
-begin
-  require 'rubygems'
-  gem 'sqlite3-ruby'
-  gem 'dbi'
-rescue LoadError
-end
-
-require 'dbi'
-require 'sqlite3'
-require 'sqlite3/version'
-
-module DBI
-    module DBD
-        #
-        # DBD::SQLite3 - Database Driver for SQLite versions 3.x
-        #
-        # Requires DBI and the 'sqlite3-ruby' gem to work.
-        #
-        # Only things that extend DBI's results are documented.
-        #
-        module SQLite3
-            VERSION = "1.2.5"
-            DESCRIPTION = "SQLite 3.x DBD for DBI"
-
-            #
-            # returns 'SQLite3'
-            #
-            # See DBI::TypeUtil#convert for more information.
-            #
-            def self.driver_name
-                "SQLite3"
-            end
-
-            #
-            # Validates that the SQL has no literal NUL characters. (ASCII 0)
-            #
-            # SQLite apparently really hates it when you do that.
-            #
-            # It will raise DBI::DatabaseError should it find any.
-            #
-            def self.parse_type(type_name)
-                # FIXME plucked from SQLite driver, this needs to be in DBI proper
-                return ['varchar'] unless type_name
-                type_name.match(/^([^\(\s]+)\s*(\(\s*(\d+)\s*(,\s*(\d+))?\s*\))?$/)
-            end
-
-            #
-            # See DBI::BaseDriver.
-            #
-            class Driver < DBI::BaseDriver
-                def initialize
-                    @dbs = []
-                    super "0.4.0"
-                end
-
-                def connect(dbname, user, auth, attr)
-                    raise DBI::InterfaceError, "dbname must be a string" unless dbname.kind_of? String
-                    raise DBI::InterfaceError, "dbname must have some length" unless dbname.length > 0
-                    raise DBI::InterfaceError, "attrs must be a hash" unless attr.kind_of? Hash
-                    db = DBI::DBD::SQLite3::Database.new(dbname, attr)
-                    @dbs.push(db)
-                    db
-                end
-
-                def disconnect_all()
-                    @dbs.each{|db| db.disconnect()}
-                end
-            end
-        end
-    end
-end
-
-require 'dbd/sqlite3/database'
-require 'dbd/sqlite3/statement'
-
-DBI::TypeUtil.register_conversion(DBI::DBD::SQLite3.driver_name) do |obj|
-    newobj = case obj
-             when ::TrueClass
-                '1'
-             when ::FalseClass
-                '0'
-             else
-                 # SQLite3 is managing its own conversion right now, until I'm happy let's keep it that way
-                 obj.dup rescue obj
-             end
-    if newobj.kind_of?(::Symbol)
-        newobj.to_s
-    elsif newobj.object_id == obj.object_id
-        [newobj, true]
-    else
-        [newobj, false]
-    end
-end

data/lib/dbd/mysql/database.rb

@@ -1,405 +0,0 @@
-module DBI::DBD::Mysql
-    #
-    # Models the DBI::BaseDatabase API to create DBI::DatabaseHandle objects.
-    #
-    class Database < DBI::BaseDatabase
-        include Util
-
-        #
-        # Hash to translate MySQL type names to DBI SQL type constants
-        #
-        # Only used in #mysql_type_info.
-        #
-        #--
-        # Eli Green:
-        #   The hope is that we don't ever need to just assume the default values.
-        #   However, in some cases (notably floats and doubles), I have seen
-        #   "show fields from table" return absolutely zero information about size
-        #   and precision. Sigh. I probably should have made a struct to store
-        #   this info in ... but I didn't.
-        #++
-        MYSQL_to_XOPEN = {
-                    "TINYINT"    => [DBI::SQL_TINYINT, 1, nil],
-                    "SMALLINT"   => [DBI::SQL_SMALLINT, 6, nil],
-                    "MEDIUMINT"  => [DBI::SQL_SMALLINT, 6, nil],
-                    "INT"        => [DBI::SQL_INTEGER, 11, nil],
-                    "INTEGER"    => [DBI::SQL_INTEGER, 11, nil],
-                    "BIGINT"     => [DBI::SQL_BIGINT, 25, nil],
-                    "INT24"      => [DBI::SQL_BIGINT, 25, nil],
-                    "REAL"       => [DBI::SQL_REAL, 12, nil],
-                    "FLOAT"      => [DBI::SQL_FLOAT, 12, nil],
-                    "DECIMAL"    => [DBI::SQL_DECIMAL, 12, nil],
-                    "NUMERIC"    => [DBI::SQL_NUMERIC, 12, nil],
-                    "DOUBLE"     => [DBI::SQL_DOUBLE, 22, nil],
-                    "CHAR"       => [DBI::SQL_CHAR, 1, nil],
-                    "VARCHAR"    => [DBI::SQL_VARCHAR, 255, nil],
-                    "DATE"       => [DBI::SQL_DATE, 10, nil],
-                    "TIME"       => [DBI::SQL_TIME, 8, nil],
-                    "TIMESTAMP"  => [DBI::SQL_TIMESTAMP, 19, nil],
-                    "DATETIME"   => [DBI::SQL_TIMESTAMP, 19, nil],
-                    "TINYBLOB"   => [DBI::SQL_BINARY, 255, nil],
-                    "BLOB"       => [DBI::SQL_VARBINARY, 65535, nil],
-                    "MEDIUMBLOB" => [DBI::SQL_VARBINARY, 16277215, nil],
-                    "LONGBLOB"   => [DBI::SQL_LONGVARBINARY, 2147483657, nil],
-                    "TINYTEXT"   => [DBI::SQL_VARCHAR, 255, nil],
-                    "TEXT"       => [DBI::SQL_LONGVARCHAR, 65535, nil],
-                    "MEDIUMTEXT" => [DBI::SQL_LONGVARCHAR, 16277215, nil],
-                    "LONGTEXT"   => [DBI::SQL_LONGVARCHAR, 2147483657, nil],
-                    "ENUM"       => [DBI::SQL_CHAR, 255, nil],
-                    "SET"        => [DBI::SQL_CHAR, 255, nil],
-                    "BIT"        => [DBI::SQL_BIT, 8, nil],
-                    nil          => [DBI::SQL_OTHER, nil, nil]
-        }
-
-
-        #
-        # This maps type names to DBI Types.
-        #
-        TYPE_MAP = {}
-
-        ::Mysql::Field.constants.grep(/^TYPE_/).each do |const|
-            mysql_type = MysqlField.const_get(const)  # numeric type code
-            coercion_method = DBI::Type::Varchar                 # default coercion method
-            case const.to_s
-            when 'TYPE_TINY'
-                mysql_type_name = 'TINYINT'
-                coercion_method = DBI::Type::Integer
-            when 'TYPE_SHORT'
-                mysql_type_name = 'SMALLINT'
-                coercion_method = DBI::Type::Integer
-            when 'TYPE_INT24'
-                mysql_type_name = 'MEDIUMINT'
-                coercion_method = DBI::Type::Integer
-            when 'TYPE_LONG'
-                mysql_type_name = 'INT'
-                coercion_method = DBI::Type::Integer
-            when 'TYPE_LONGLONG'
-                mysql_type_name = 'BIGINT'
-                coercion_method = DBI::Type::Integer
-            when 'TYPE_FLOAT'
-                mysql_type_name = 'FLOAT'
-                coercion_method = DBI::Type::Float
-            when 'TYPE_DOUBLE'
-                mysql_type_name = 'DOUBLE'
-                coercion_method = DBI::Type::Float
-            when 'TYPE_VAR_STRING', 'TYPE_STRING'
-                mysql_type_name = 'VARCHAR'    # questionable?
-                coercion_method = DBI::Type::Varchar
-            when 'TYPE_DATE'
-                mysql_type_name = 'DATE'
-                coercion_method = DBI::DBD::Mysql::Type::Date
-            when 'TYPE_TIME'
-                mysql_type_name = 'TIME'
-                coercion_method = DBI::Type::Timestamp
-            when 'TYPE_DATETIME', 'TYPE_TIMESTAMP'
-                mysql_type_name = 'DATETIME'
-                coercion_method = DBI::Type::Timestamp
-            when 'TYPE_CHAR'
-                mysql_type_name = 'TINYINT'    # questionable?
-            when 'TYPE_TINY_BLOB'
-                mysql_type_name = 'TINYBLOB'   # questionable?
-            when 'TYPE_MEDIUM_BLOB'
-                mysql_type_name = 'MEDIUMBLOB' # questionable?
-            when 'TYPE_LONG_BLOB'
-                mysql_type_name = 'LONGBLOB'   # questionable?
-            when 'TYPE_GEOMETRY'
-                mysql_type_name = 'BLOB'       # questionable?
-            when 'TYPE_YEAR',
-                 'TYPE_DECIMAL',                                     # questionable?
-                 'TYPE_BLOB',                                        # questionable?
-                 'TYPE_ENUM',
-                 'TYPE_SET',
-                 'TYPE_BIT',
-                 'TYPE_NULL'
-                mysql_type_name = const.to_s.sub(/^TYPE_/, '')
-            else
-                mysql_type_name = 'UNKNOWN'
-            end
-            TYPE_MAP[mysql_type] = [mysql_type_name, coercion_method]
-        end
-        TYPE_MAP[nil] = ['UNKNOWN', DBI::Type::Varchar]
-        TYPE_MAP[246] = ['NUMERIC', DBI::Type::Decimal]
-
-        #
-        # Constructor. Attributes supported:
-        #
-        # * AutoCommit: Commit after each executed statement. This will raise
-        #   a DBI::NotSupportedError if the backend does not support
-        #   transactions.
-        #
-        def initialize(handle, attr)
-            super
-            # check server version to determine transaction capability
-            ver_str = @handle.get_server_info
-            major, minor, teeny = ver_str.split(".")
-            teeny.sub!(/\D*$/, "")  # strip any non-numeric suffix if present
-            server_version = major.to_i*10000 + minor.to_i*100 + teeny.to_i
-            # It's not until 3.23.17 that SET AUTOCOMMIT,
-            # BEGIN, COMMIT, and ROLLBACK all are available
-            @have_transactions = (server_version >= 32317)
-            # assume that the connection begins in AutoCommit mode
-            @attr['AutoCommit'] = true
-            @mutex = Mutex.new
-        end
-
-        def disconnect
-            self.rollback unless @attr['AutoCommit']
-            @handle.close
-        rescue MyError => err
-            error(err)
-        end
-
-        def database_name
-            sth = Statement.new(self, @handle, "select DATABASE()", @mutex)
-            sth.execute
-            res = sth.fetch
-            sth.finish
-            return res[0]
-        end
-
-        def ping
-            begin
-                @handle.ping
-                return true
-            rescue MyError
-                return false
-            end
-        end
-
-        def tables
-            @handle.list_tables
-        rescue MyError => err
-            error(err)
-        end
-
-        #
-        # See DBI::BaseDatabase#columns.
-        #
-        # Extra attributes:
-        #
-        # * sql_type: XOPEN integer constant relating to type.
-        # * nullable: true if the column allows NULL as a value.
-        # * indexed: true if the column belongs to an index.
-        # * primary: true if the column is a part of a primary key.
-        # * unique: true if the values in this column are unique.
-        # * default: the default value if this column is not explicitly set.
-        #
-        def columns(table)
-            dbh = DBI::DatabaseHandle.new(self)
-            uniques = []
-            dbh.execute("SHOW INDEX FROM #{table}") do |sth|
-                sth.each do |row|
-                    uniques << row[4] if row[1] == 0
-                end
-            end
-
-            ret = nil
-            dbh.execute("SHOW FIELDS FROM #{table}") do |sth|
-                ret = sth.collect do |row|
-                    name, type, nullable, key, default, extra = row
-                    #type = row[1]
-                    #size = type[type.index('(')+1..type.index(')')-1]
-                    #size = 0
-                    #type = type[0..type.index('(')-1]
-
-                    sqltype, type, size, decimal = mysql_type_info(row[1])
-                    col = Hash.new
-                    col['name']           = name
-                    col['sql_type']       = sqltype
-                    col['type_name']      = type
-                    col['nullable']       = nullable == "YES"
-                    col['indexed']        = key != ""
-                    col['primary']        = key == "PRI"
-                    col['unique']         = uniques.index(name) != nil
-                    col['precision']      = size
-                    col['scale']          = decimal
-                    col['default']        = row[4]
-
-                    case col['type_name']
-                    when 'timestamp'
-                        col['dbi_type'] = DBI::Type::Timestamp
-                    end
-
-                    col
-                end # collect
-            end # execute
-
-            ret
-        end
-
-        def do(stmt, *bindvars)
-            st = Statement.new(self, @handle, stmt, @mutex)
-            st.bind_params(*bindvars)
-            res = st.execute
-            st.finish
-            return res
-        rescue MyError => err
-            error(err)
-        end
-
-
-        def prepare(statement)
-            Statement.new(self, @handle, statement, @mutex)
-        end
-
-        #
-        # MySQL has several backends, some of which may not support commits.
-        # If the backend this database uses doesn't, calling this method will
-        # raise a DBI::NotSupportedError.
-        #
-        def commit
-            if @have_transactions
-                self.do("COMMIT")
-            else
-                raise NotSupportedError
-            end
-        rescue MyError => err
-            error(err)
-        end
-
-        #
-        # See #commit for information regarding transactionless database
-        # backends.
-        #
-        def rollback
-            if @have_transactions
-                self.do("ROLLBACK")
-            else
-                raise NotSupportedError
-            end
-        rescue MyError => err
-            error(err)
-        end
-
-
-#                 def quote(value)
-#                     case value
-#                     when String
-#                       "'#{@handle.quote(value)}'"
-#                     when DBI::Binary
-#                       "'#{@handle.quote(value.to_s)}'"
-#                     when TrueClass
-#                       "'1'"
-#                     when FalseClass
-#                       "'0'"
-#                     else
-#                         super
-#                     end
-#                 end
-
-        #
-        # See DBI::DBD::MySQL::Database.new for supported attributes and usage.
-        #
-        def []=(attr, value)
-            case attr
-            when 'AutoCommit'
-                if @have_transactions
-                    self.do("SET AUTOCOMMIT=" + (value ? "1" : "0"))
-                else
-                    raise NotSupportedError
-                end
-            else
-                raise NotSupportedError
-            end
-
-            @attr[attr] = value
-        end
-
-        private # -------------------------------------------------
-
-        #
-        # Given a type name, weans some basic information from that and returns
-        # it in a format similar to columns.
-        #
-        # Return is an array of +sqltype+, +type+, +size+, and +decimal+.
-        # +sqltype+ is the XOPEN type, and +type+ is the string with the
-        # parameters removed.
-        #
-        # +size+ and +decimal+ refer to +precision+ and +scale+ in most cases,
-        # but not always for all types. Please consult the documentation for
-        # your MySQL version.
-        #
-        #
-        def mysql_type_info(typedef)
-            sqltype, type, size, decimal = nil, nil, nil, nil
-
-            pos = typedef.index('(')
-            if not pos.nil?
-                type = typedef[0..pos-1]
-                size = typedef[pos+1..-2]
-                pos = size.index(',')
-                if not pos.nil?
-                    size, decimal = size.split(',', 2)
-                    decimal = decimal.to_i
-                end
-                size = size.to_i
-            else
-                type = typedef
-            end
-
-            type_info = MYSQL_to_XOPEN[type.upcase] || MYSQL_to_XOPEN[nil]
-            sqltype = type_info[0]
-            if size.nil? then size = type_info[1] end
-            if decimal.nil? then decimal = type_info[2] end
-            return sqltype, type, size, decimal
-        end
-
-        #--
-        # Driver-specific functions ------------------------------------------------
-        #++
-
-        public
-
-        def __createdb(db)
-            @handle.create_db(db)
-        end
-
-        def __dropdb(db)
-            @handle.drop_db(db)
-        end
-
-        def __shutdown
-            @handle.shutdown
-        end
-
-        def __reload
-            @handle.reload
-        end
-
-        def __insert_id
-            @handle.insert_id
-        end
-
-        def __thread_id
-            @handle.thread_id
-        end
-
-        def __info
-            @handle.info
-        end
-
-        def __host_info
-            @handle.host_info
-        end
-
-        def __proto_info
-            @handle.proto_info
-        end
-
-        def __server_info
-            @handle.server_info
-        end
-
-        def __client_info
-            @handle.client_info
-        end
-
-        def __client_version
-            @handle.client_version
-        end
-
-        def __stat
-            @handle.stat
-        end
-    end # class Database
-end