ydbi 0.5.7 → 0.5.8

data/lib/dbd/pg/exec.rb

@@ -1,47 +0,0 @@
-module DBI::DBD::Pg
-    ################################################################
-    # Convenience adaptor to hide details command execution API calls.
-    # See PgExecutorAsync subclass
-    class PgExecutor
-        def initialize(pg_conn)
-            @pg_conn = pg_conn
-        end
-
-        def exec(sql, parameters = nil)
-            @pg_conn.exec(sql, parameters)
-        end
-
-        def exec_prepared(stmt_name, parameters = nil)
-            @pg_conn.exec_prepared(stmt_name, parameters)
-        end
-
-        def prepare(stmt_name, sql)
-            @pg_conn.prepare(stmt_name, sql)
-        end
-    end
-
-    # Asynchronous implementation of PgExecutor, useful for 'green
-    # thread' implementations (e.g., MRI <= 1.8.x) which would otherwise
-    # suspend other threads while awaiting query results.
-    #--
-    # FIXME:  PQsetnonblocking + select/poll would make the exec*
-    #         methods truly 'async', though this is rarely needed in
-    #         practice.
-    class PgExecutorAsync < PgExecutor
-        def exec(sql, parameters = nil)
-            @pg_conn.async_exec(sql, parameters)
-        end
-
-        def exec_prepared(stmt_name, parameters = nil)
-            @pg_conn.send_query_prepared(stmt_name, parameters)
-            @pg_conn.block()
-            @pg_conn.get_last_result()
-        end
-
-        def prepare(stmt_name, sql)
-            @pg_conn.send_prepare(stmt_name, sql)
-            @pg_conn.block()
-            @pg_conn.get_last_result()
-        end
-    end
-end

data/lib/dbd/pg/statement.rb

@@ -1,160 +0,0 @@
-#
-# See DBI::BaseStatement, and DBI::DBD::Pg::Tuples.
-#
-#--
-# Peculiar Statement responsibilities:
-#  - Translate dbi params (?, ?, ...) to Pg params ($1, $2, ...)
-#  - Translate DBI::Binary objects to Pg large objects (lo_*)
-
-class DBI::DBD::Pg::Statement < DBI::BaseStatement
-
-    PG_STMT_NAME_PREFIX = 'ruby-dbi:Pg:'
-
-    def initialize(db, sql)
-        super(db)
-        @db  = db
-        @sql = sql
-        @stmt_name = PG_STMT_NAME_PREFIX + self.object_id.to_s + Time.now.to_f.to_s
-        @result = nil
-        @bindvars = []
-        @prepared = false
-    rescue PG::Error => err
-        raise DBI::ProgrammingError.new(err.message)
-    end
-
-    def bind_param(index, value, options)
-        @bindvars[index-1] = value
-    end
-
-    #
-    # See DBI::BaseDatabase#execute.
-    #
-    # This method will make use of PostgreSQL's native BLOB support if
-    # DBI::Binary objects are passed in.
-    #
-    def execute
-        # replace DBI::Binary object by oid returned by lo_import
-        @bindvars.collect! do |var|
-            if var.is_a? DBI::Binary then
-                oid = @db.__blob_create(PG::Connection::INV_WRITE)
-                @db.__blob_write(oid, var.to_s)
-                oid
-            else
-                var
-            end
-        end
-
-        internal_prepare
-
-        if not @db['AutoCommit'] then
-            #          if not SQL.query?(boundsql) and not @db['AutoCommit'] then
-            @db.start_transaction unless @db.in_transaction?
-        end
-
-        if @db["pg_native_binding"]
-            pg_result = @db._exec_prepared(@stmt_name, *@bindvars)
-        else
-            pg_result = @db._exec_prepared(@stmt_name)
-        end
-
-        @result = DBI::DBD::Pg::Tuples.new(@db, pg_result)
-    rescue PG::Error, RuntimeError => err
-        raise DBI::ProgrammingError.new(err.message)
-    end
-
-    def fetch
-        @result.fetchrow
-    end
-
-    def fetch_scroll(direction, offset)
-        @result.fetch_scroll(direction, offset)
-    end
-
-    def finish
-        internal_finish
-        @result = nil
-        @db = nil
-    end
-
-    #
-    # See DBI::DBD::Pg::Tuples#column_info.
-    #
-    def column_info
-        @result.column_info
-    end
-
-    def rows
-        if @result
-            @result.rows_affected
-        else
-            nil
-        end
-    end
-
-    #
-    # Attributes:
-    #
-    # If +pg_row_count+ is requested and the statement has already executed,
-    # postgres will return what it believes is the row count.
-    #
-    def [](attr)
-        case attr
-        when 'pg_row_count'
-            if @result
-                @result.row_count
-            else
-                nil
-            end
-        else
-            @attr[attr]
-        end
-    end
-
-    private
-
-    #
-    # A native binding helper.
-    #
-    class DummyQuoter
-        # dummy to substitute ?-style parameter markers by :1 :2 etc.
-        def quote(str)
-            str
-        end
-    end
-
-    # finish the statement at a lower level
-    def internal_finish
-        @result.finish if @result
-        @db._exec("DEALLOCATE \"#{@stmt_name}\"") if @prepared rescue nil
-    end
-
-    # prepare the statement at a lower level.
-    def internal_prepare
-        if @db["pg_native_binding"]
-            unless @prepared
-                @stmt = @db._prepare(@stmt_name, translate_param_markers(@sql))
-            end
-        else
-            internal_finish
-            @stmt = @db._prepare(@stmt_name, DBI::SQL::PreparedStatement.new(DBI::DBD::Pg, @sql).bind(@bindvars))
-        end
-        @prepared = true
-    end
-
-    # Prepare the given SQL statement, returning its PostgreSQL string
-    # handle.  ?-style parameters are translated to $1, $2, etc.
-    #--
-    # TESTME  do ?::TYPE qualifers work?
-    # FIXME:  DBI ought to supply a generic param converter, e.g.:
-    #         sql = DBI::Utils::convert_placeholders(sql) do |i|
-    #                 '$' + i.to_s
-    #               end
-    def translate_param_markers(sql)
-        translator = DBI::SQL::PreparedStatement.new(DummyQuoter.new, sql)
-        if translator.unbound.size > 0
-            arr = (1..(translator.unbound.size)).collect{|i| "$#{i}"}
-            sql = translator.bind( arr )
-        end
-        sql
-    end
-end # Statement

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