ydbi 0.5.7 → 0.5.9

data/lib/dbd/pg/tuples.rb

@@ -1,121 +0,0 @@
-#
-# Tuples is a class to represent result sets.
-#
-# Many of these methods are extremely similar to the methods that deal with
-# result sets in DBI::BaseStatement and are wrapped by the StatementHandle.
-# Unless you plan on working on this driver, these methods should never be
-# called directly.
-#
-class DBI::DBD::Pg::Tuples
-
-    def initialize(db, pg_result)
-        @db = db
-        @pg_result = pg_result
-        @index = -1
-        @row = []
-    end
-
-    # See DBI::BaseStatement#column_info. Additional attributes:
-    #
-    # * array_of_type: True if this is actually an array of this type. In this
-    #   case, +dbi_type+ will be the type authority for conversion.
-    #
-    def column_info
-        a = []
-        0.upto(@pg_result.num_fields-1) do |i|
-            str = @pg_result.fname(i)
-
-            typeinfo = nil
-
-            begin
-                typmod = @pg_result.fmod(i)
-            rescue
-            end
-
-            if typmod and typ = @pg_result.ftype(i)
-                res = @db._exec("select format_type(#{typ}, #{typmod})")
-                typeinfo = DBI::DBD::Pg.parse_type(res[0].values[0])
-            end
-
-            map = @db.type_map[@pg_result.ftype(i)] || { }
-            h = { "name" => str }.merge(map)
-
-            if typeinfo
-                h["precision"]     = typeinfo[:size]
-                h["scale"]         = typeinfo[:decimal]
-                h["type"]          = typeinfo[:type]
-                h["array_of_type"] = typeinfo[:array]
-
-                if typeinfo[:array]
-                    h['dbi_type'] = 
-                        DBI::DBD::Pg::Type::Array.new(
-                            DBI::TypeUtil.type_name_to_module(typeinfo[:type])
-                    )
-                end
-            end
-
-            a.push h
-        end
-
-        return a
-    end
-
-    def fetchrow
-        @index += 1
-        if @index < @pg_result.num_tuples && @index >= 0
-            @row = Array.new
-            0.upto(@pg_result.num_fields-1) do |x|
-                @row.push(@pg_result.getvalue(@index, x))
-            end
-            @row
-        else
-            nil
-        end
-    end
-
-    #
-    # Just don't use this method. It'll be fixed soon.
-    #
-    def fetch_scroll(direction, offset)
-        # Exact semantics aren't too closely defined.  I attempted to follow the DBI:Mysql example.
-        case direction
-        when SQL_FETCH_NEXT
-            # Nothing special to do, besides the fetchrow
-        when SQL_FETCH_PRIOR
-            @index -= 2
-        when SQL_FETCH_FIRST
-            @index = -1
-        when SQL_FETCH_LAST
-            @index = @pg_result.num_tuples - 2
-        when SQL_FETCH_ABSOLUTE
-            # Note: if you go "out of range", all fetches will give nil until you get back
-            # into range, this doesn't raise an error.
-            @index = offset-1
-        when SQL_FETCH_RELATIVE
-            # Note: if you go "out of range", all fetches will give nil until you get back
-            # into range, this doesn't raise an error.
-            @index += offset - 1
-        else
-            raise NotSupportedError
-        end
-        self.fetchrow
-    end
-
-    #
-    # The number of rows returned.
-    #
-    def row_count
-        @pg_result.num_tuples
-    end
-
-    #
-    # The row processed count. This is analogue to DBI::StatementHandle#rows.
-    #
-    def rows_affected
-        @pg_result.cmdtuples
-    end
-
-    def finish
-        @pg_result.clear
-    end
-end # Tuples

data/lib/dbd/pg/type.rb

@@ -1,209 +0,0 @@
-#
-# Type Management for PostgreSQL-specific types.
-#
-# See DBI::Type and DBI::TypeUtil for more information.
-#
-module DBI::DBD::Pg::Type
-    #
-    # ByteA is a special escaped form of binary data, suitable for inclusion in queries.
-    #
-    # This class is an attempt to abstract that type so you do not have to
-    # concern yourself with the conversion issues.
-    #
-    class ByteA
-
-        attr_reader :original
-        attr_reader :escaped
-
-        #
-        # Build a new ByteA object.
-        #
-        # The data supplied is the unescaped binary data you wish to put in the
-        # database.
-        #
-        def initialize(obj)
-            @original = obj
-            @escaped = escape_bytea(obj)
-            @original.freeze
-            @escaped.freeze
-        end
-
-        #
-        # Escapes the supplied data. Has no effect on the object.
-        #
-        def escape_bytea(str)
-            PG::Connection.escape_bytea(str)
-        end
-
-        #
-        # Returns the original data.
-        #
-        def to_s
-            return @original.dup
-        end
-
-        #
-        # Class method to escape the data into ByteA format.
-        #
-        def self.escape_bytea(str)
-            self.new(str).escaped
-        end
-
-        #
-        # Class method to unescape the ByteA data and present it as a string.
-        #
-        def self.parse(obj)
-
-            return nil if obj.nil?
-
-            # FIXME there's a bug in the upstream 'pg' driver that does not
-            # properly decode bytea, leaving in an extra slash for each decoded
-            # character.
-            #
-            # Fix this for now, but beware that we'll have to unfix this as
-            # soon as they fix their end.
-            ret = PG::Connection.unescape_bytea(obj)
-
-            # XXX 
-            # String#split does not properly create a full array if the the
-            # string ENDS in the split regex, unless this oddball -1 argument is supplied.
-            #
-            # Another way of saying this:
-            # if foo = "foo\\\\\" and foo.split(/\\\\/), the result will be
-            # ["foo"]. You can add as many delimiters to the end of the string
-            # as you'd like - the result is no different.
-            #
-
-            ret = ret.split(/\\\\/, -1).collect { |x| x.length > 0 ? x.gsub(/\\[0-7]{3}/) { |y| y[1..3].oct.chr } : "" }.join("\\")
-            ret.gsub!(/''/, "'")
-            return ret
-        end
-    end
-
-    #
-    # PostgreSQL arrays are simply a specification that sits on top of normal
-    # types. They have a specialized string grammar and this class facilitates
-    # converting that syntax and the types within those arrays.
-    #
-    class Array
-
-        attr_reader :base_type
-
-        #
-        # +base_type+ is a DBI::Type that is used to parse the inner types when
-        # a non-array one is found.
-        #
-        # For instance, if you had an array of integer, one would pass
-        # DBI::Type::Integer here.
-        #
-        def initialize(base_type)
-            @base_type = base_type
-        end
-
-        #
-        # Object method. Please note that this is different than most DBI::Type
-        # classes! One must initialize an Array object with an appropriate
-        # DBI::Type used to convert the indices of the array before this method
-        # can be called.
-        #
-        # Returns an appropriately converted array.
-        #
-        def parse(obj)
-            if obj.nil?
-                nil
-            elsif obj.index('{') == 0 and obj.rindex('}') == (obj.length - 1)
-                convert_array(obj)
-            else
-                raise "Not an array"
-            end
-        end
-
-        #
-        # Parse a PostgreSQL-Array output and convert into ruby array. This
-        # does the real parsing work.
-        #
-        def convert_array(str)
-
-            array_nesting = 0         # nesting level of the array
-            in_string = false         # currently inside a quoted string ?
-            escaped = false           # if the character is escaped
-            sbuffer = ''              # buffer for the current element
-            result_array = ::Array.new  # the resulting Array
-
-            str.each_byte { |char|    # parse character by character
-                char = char.chr         # we need the Character, not it's Integer
-
-                if escaped then         # if this character is escaped, just add it to the buffer
-                    sbuffer += char
-                    escaped = false
-                    next
-                end
-
-                case char               # let's see what kind of character we have
-                    #------------- {: beginning of an array ----#
-                when '{'
-                    if in_string then     # ignore inside a string
-                        sbuffer += char
-                        next
-                    end
-
-                if array_nesting >= 1 then  # if it's an nested array, defer for recursion
-                    sbuffer += char
-                end
-                array_nesting += 1          # inside another array
-
-                #------------- ": string deliminator --------#
-                when '"'
-                    in_string = !in_string      
-
-                    #------------- \: escape character, next is regular character #
-                when "\\"     # single \, must be extra escaped in Ruby
-                    if array_nesting > 1
-                        sbuffer += char
-                    else
-                        escaped = true
-                    end
-
-                    #------------- ,: element separator ---------#
-                when ','
-                    if in_string or array_nesting > 1 then  # don't care if inside string or
-                        sbuffer += char                       # nested array
-                    else
-                        if !sbuffer.is_a? ::Array then
-                            sbuffer = @base_type.parse(sbuffer)
-                        end
-                        result_array << sbuffer               # otherwise, here ends an element
-                        sbuffer = ''
-                    end
-
-                #------------- }: End of Array --------------#
-                when '}' 
-                    if in_string then                # ignore if inside quoted string
-                        sbuffer += char
-                        next
-                    end
-
-                    array_nesting -=1                # decrease nesting level
-
-                    if array_nesting == 1            # must be the end of a nested array 
-                        sbuffer += char
-                        sbuffer = convert_array( sbuffer )  # recurse, using the whole nested array
-                    elsif array_nesting > 1          # inside nested array, keep it for later
-                        sbuffer += char
-                    else                             # array_nesting = 0, must be the last }
-                        if !sbuffer.is_a? ::Array then
-                            sbuffer = @base_type.parse( sbuffer )
-                        end
-
-                        result_array << sbuffer unless sbuffer.nil? # upto here was the last element
-                    end
-
-                    #------------- all other characters ---------#
-                else
-                    sbuffer += char                 # simply append
-                end
-            } 
-            return result_array
-        end # convert_array()
-    end
-end

data/lib/dbd/sqlite/database.rb

@@ -1,151 +0,0 @@
-#
-# See DBI::BaseDatabase.
-#
-class DBI::DBD::SQLite::Database < DBI::BaseDatabase
-    attr_reader :db
-    attr_reader :attr_hash
-    attr_accessor :open_handles
-
-    #
-    # Constructor. Valid attributes:
-    #
-    # * AutoCommit: Commit after every statement execution.
-    #
-    def initialize(dbname, user, auth, attr_hash)
-        # FIXME why isn't this crap being done in DBI?
-        unless dbname.kind_of? String
-            raise DBI::InterfaceError, "Database Name must be a string"
-        end
-
-        unless dbname.length > 0
-            raise DBI::InterfaceError, "Database Name needs to be length > 0"
-        end
-
-        unless attr_hash.kind_of? Hash
-            raise DBI::InterfaceError, "Attributes should be a hash"
-        end
-
-        # FIXME handle busy_timeout in SQLite driver
-        # FIXME handle SQLite pragmas in SQLite driver
-        @attr_hash = attr_hash
-        @open_handles = 0
-
-        self["AutoCommit"] = true if self["AutoCommit"].nil?
-
-        # open the database
-        begin
-            @db = ::SQLite::Database.new(dbname)
-        rescue Exception => e
-            raise DBI::OperationalError, "Couldn't open database #{dbname}: #{e.message}"
-        end
-    end
-
-    def disconnect
-        rollback rescue nil
-        @db.close if @db and !@db.closed?
-        @db = nil
-    end
-
-    def database_name
-        st = DBI::DBD::SQLite::Statement.new('PRAGMA database_list', self)
-        st.execute
-        row = st.fetch
-        st.finish
-
-        return row[2]
-    end
-
-    def prepare(stmt)
-        return DBI::DBD::SQLite::Statement.new(stmt, self)
-    end
-
-    def ping
-        return !@db.closed?
-    end
-
-    def tables
-        sth = prepare("select name from sqlite_master where type in ('table', 'view')")
-        sth.execute
-        tables = sth.fetch_all.flatten
-        sth.finish
-        return tables
-        # FIXME does sqlite use views too? not sure, but they need to be included according to spec
-    end
-
-    def commit
-        @db.commit if @db.transaction_active?
-    end
-
-    #
-    # Rollback the transaction. SQLite has some issues with open statement
-    # handles when this happens. If there are still open handles, a
-    # DBI::Warning exception will be raised.
-    #
-    def rollback
-        if @open_handles > 0
-            raise DBI::Warning, "Leaving unfinished select statement handles while rolling back a transaction can corrupt your database or crash your program"
-        end
-
-        @db.rollback if @db.transaction_active?
-    end
-
-    def [](key)
-        return @attr_hash[key]
-    end
-
-    #
-    # See DBI::BaseDatabase#[]=.
-    #
-    # If AutoCommit is set to +true+ using this method, was previously +false+,
-    # and we are currently in a transaction, The act of setting this will cause
-    # an immediate commit.
-    #
-    def []=(key, value)
-
-        old_value = @attr_hash[key]
-
-        @attr_hash[key] = value
-
-        # special handling of settings
-        case key
-        when "AutoCommit"
-            # if the value being set is true and the previous value is false,
-            # commit the current transaction (if any)
-            # FIXME I still think this is a horrible way of handling this.
-            if value and !old_value
-                begin 
-                    @dbh.commit
-                rescue Exception => e
-                end
-            end
-        end
-
-        return @attr_hash[key]
-    end
-
-    def columns(tablename)
-        return nil unless tablename and tablename.kind_of? String
-
-        sth = prepare("PRAGMA table_info(?)")
-        sth.bind_param(1, tablename)
-        sth.execute
-        columns = [ ]
-        while row = sth.fetch
-            column = { }
-            column["name"] = row[1]
-
-            m = DBI::DBD::SQLite.parse_type(row[2])
-            column["type_name"] = m[1]
-            column["precision"] = m[3].to_i if m[3]
-            column["scale"]     = m[5].to_i if m[5]
-
-            column["nullable"]  = row[3].to_i == 0
-            column["default"]   = row[4]
-            columns.push column
-        end
-
-        sth.finish
-        return columns
-        # XXX it'd be nice if the spec was changed to do this k/v with the name as the key.
-    end
-end

data/lib/dbd/sqlite/statement.rb

@@ -1,125 +0,0 @@
-#
-# See DBI::BaseStatement.
-#
-class DBI::DBD::SQLite::Statement < DBI::BaseStatement
-    DBI_TYPE_MAP = [
-        [ /^INT(EGER)?$/i,          DBI::SQL_INTEGER ],
-        [ /^(OID|ROWID|_ROWID_)$/i, DBI::SQL_OTHER   ],
-        [ /^FLOAT$/i,               DBI::SQL_FLOAT   ],
-        [ /^REAL$/i,                DBI::SQL_REAL    ],
-        [ /^DOUBLE$/i,              DBI::SQL_DOUBLE  ],
-        [ /^DECIMAL/i,              DBI::SQL_DECIMAL ],
-        [ /^(BOOL|BOOLEAN)$/i,      DBI::SQL_BOOLEAN ], 
-        [ /^TIME$/i,                DBI::SQL_TIME    ],
-        [ /^DATE$/i,                DBI::SQL_DATE    ],
-        [ /^TIMESTAMP$/i,           DBI::SQL_TIMESTAMP ], 
-        [ /^(VARCHAR|TEXT)/i,       DBI::SQL_VARCHAR ],
-        [ /^CHAR$/i,                DBI::SQL_CHAR    ],
-    ]
-
-    def initialize(stmt, dbh)
-        @dbh       = dbh
-        @statement = DBI::SQL::PreparedStatement.new(@dbh, stmt)
-        @attr      = { }
-        @params    = [ ]
-        @rows      = [ ]
-        @result_set = nil
-        @dbh.open_handles += 1
-    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, attributes=nil)
-        unless param.kind_of? Fixnum
-            raise DBI::InterfaceError, "Only numeric parameters are supported"
-        end
-
-        @params[param-1] = value
-
-        # FIXME what to do with attributes? are they important in SQLite?
-    end
-
-    #
-    # See DBI::BaseStatement#execute.
-    #
-    # In the event AutoCommit is off and no transaction is currently executing,
-    # one will be opened at this point. It is your responsibility to #finish,
-    # #cancel, #rollback, or #commit.
-    #
-    def execute
-        sql = @statement.bind(@params)
-        # XXX sqlite re-escapes this for us automatically, it's causing trouble with everything else.
-        #     this will probably break in a horrible manner and I will be forced to "fix" it again.
-        sql.gsub!(/\\\\/) { '\\' } 
-        DBI::DBD::SQLite.check_sql(sql)
-
-        begin
-            unless @dbh.db.transaction_active?
-                @dbh.db.transaction 
-            end
-            @result_set = @dbh.db.query(sql)
-            @dbh.commit if @dbh["AutoCommit"]
-        rescue Exception => e
-            raise DBI::DatabaseError, e.message
-        end
-    end
-
-    alias :finish :cancel
-
-    def finish
-        # nil out the result set
-        @result_set.close if @result_set
-        @result_set = nil
-        @rows = nil
-        @dbh.open_handles -= 1
-    end
-
-    def fetch
-        return nil if @result_set.eof?
-
-        row = @result_set.next
-        return nil unless row
-
-        return row
-    end
-
-    def column_info
-        columns = [ ]
-
-        # FIXME this shit should *really* be abstracted into DBI
-        # FIXME this still doesn't handle nullable/unique/default stuff.
-        @result_set.columns.each_with_index do |name, i|
-            columns[i] = { } unless columns[i]
-            columns[i]["name"] = name
-            type_name = @result_set.types[i]
-
-            if type_name
-                m = DBI::DBD::SQLite.parse_type(type_name)
-
-                columns[i]["type_name"] = m[1]
-                columns[i]["precision"] = m[3].to_i if m[3]
-                columns[i]["scale"]     = m[5].to_i if m[5]
-                DBI_TYPE_MAP.each do |map|
-                    if columns[i]["type_name"] =~ map[0]
-                        columns[i]["sql_type"] = map[1]
-                        break
-                    end
-                end
-
-                case columns[i]["type_name"]
-                when 'double'
-                    columns[i]["dbi_type"] = DBI::Type::Float
-                end
-            end
-        end
-
-        return columns
-    end
-
-    def rows
-        return @dbh.db.changes
-    end
-end