ydbi 0.5.8 → 0.6.0

data/lib/dbd/pg/database.rb

@@ -0,0 +1,508 @@
+#
+# See DBI::BaseDatabase.
+#
+class DBI::DBD::Pg::Database < DBI::BaseDatabase
+
+    # type map 
+    POSTGRESQL_to_XOPEN = {
+          "boolean"                   => [DBI::SQL_CHAR, 1, nil],
+          "character"                 => [DBI::SQL_CHAR, 1, nil],
+          "char"                      => [DBI::SQL_CHAR, 1, nil],
+          "real"                      => [DBI::SQL_REAL, 4, 6],
+          "double precision"          => [DBI::SQL_DOUBLE, 8, 15],
+          "smallint"                  => [DBI::SQL_SMALLINT, 2],
+          "integer"                   => [DBI::SQL_INTEGER, 4],
+          "bigint"                    => [DBI::SQL_BIGINT, 8],
+          "numeric"                   => [DBI::SQL_NUMERIC, nil, nil],
+          "time with time zone"       => [DBI::SQL_TIME, nil, nil],
+          "timestamp with time zone"  => [DBI::SQL_TIMESTAMP, nil, nil],
+          "bit varying"               => [DBI::SQL_BINARY, nil, nil], #huh??
+          "character varying"         => [DBI::SQL_VARCHAR, nil, nil],
+          "bit"                       => [DBI::SQL_TINYINT, nil, nil],
+          "text"                      => [DBI::SQL_VARCHAR, nil, nil],
+          nil                         => [DBI::SQL_OTHER, nil, nil]
+    }
+
+    attr_reader :type_map
+
+    #
+    # See DBI::BaseDatabase#new. These attributes are also supported:
+    #
+    # * pg_async: boolean or strings 'true' or 'false'. Indicates if we're to
+    #   use PostgreSQL's asyncrohonous support. 'NonBlocking' is a synonym for
+    #   this.
+    # * AutoCommit: 'unchained' mode in PostgreSQL. Commits after each
+    #   statement execution. 
+    # * pg_client_encoding: set the encoding for the client.
+    # * pg_native_binding: Boolean. Indicates whether to use libpq native
+    #   binding or DBI's inline binding. Defaults to true.
+    #
+    def initialize(dbname, user, auth, attr)
+        hash = DBI::Utils.parse_params(dbname)
+
+        if hash['dbname'].nil? and hash['database'].nil?
+            raise DBI::InterfaceError, "must specify database"
+        end
+
+        hash['options'] ||= nil
+        hash['tty'] = nil
+        hash['host'] ||= 'localhost'
+        hash['port'] = hash['port'].to_i unless hash['port'].nil? 
+
+        @connection = PG::Connection.new(hash['host'], hash['port'], hash['options'], hash['tty'],
+                                 hash['dbname'] || hash['database'], user, auth)
+
+        @exec_method = :exec
+        @in_transaction = false
+
+        # set attribute defaults, and look for pg_* attrs in the DSN
+        @attr = { 'AutoCommit' => true, 'pg_async' => false }
+        hash.each do |key, value|
+            @attr[key] = value if key =~ /^pg_./
+        end
+        @attr.merge!(attr || {})
+        if @attr['pg_async'].is_a?(String)
+            case @attr['pg_async'].downcase
+            when 'true'
+                @attr['pg_async'] = true
+            when 'false'
+                @attr['pg_async'] = false
+            else
+                raise InterfaceError, %q{'pg_async' must be 'true' or 'false'}
+            end
+        end
+
+        @attr.each { |k,v| self[k] = v} 
+        @attr["pg_native_binding"] = true unless @attr.has_key? "pg_native_binding"
+
+        load_type_map
+
+        self['AutoCommit'] = true    # Postgres starts in unchained mode (AutoCommit=on) by default 
+
+    rescue PG::Error => err
+        raise DBI::OperationalError.new(err.message)
+    end
+
+    def disconnect
+        if not @attr['AutoCommit'] and @in_transaction
+            _exec("ROLLBACK")   # rollback outstanding transactions
+        end
+        @connection.close
+    end
+
+    def ping
+        answer = _exec("SELECT 1")
+        if answer
+            return answer.num_tuples == 1
+        else
+            return false
+        end
+    rescue PG::Error
+        return false
+    ensure
+        answer.clear if answer
+    end
+
+    def database_name
+        @connection.db
+    end
+
+    def tables
+        stmt = execute("SELECT c.relname FROM pg_catalog.pg_class c WHERE c.relkind IN ('r','v') and pg_catalog.pg_table_is_visible(c.oid)")
+        res = stmt.fetch_all.collect {|row| row[0]} 
+        stmt.finish
+        res
+    end
+
+    #
+    # See DBI::BaseDatabase.
+    #
+    # These additional attributes are also supported:
+    #
+    # * nullable: true if NULL values are allowed in this column.
+    # * indexed: true if this column is a part of an index.
+    # * primary: true if this column is a part of a primary key.
+    # * unique: true if this column is a part of a unique key.
+    # * default: what will be insert if this column is left out of an insert query.
+    # * array_of_type: true if this is actually an array of this type.
+    #   +dbi_type+ will be the type authority if this is the case.
+    #
+    def columns(table)
+        sql1 = %[
+            select a.attname, i.indisprimary, i.indisunique
+            from pg_class bc inner join pg_index i 
+                on bc.oid = i.indrelid 
+                inner join pg_class c 
+                    on c.oid = i.indexrelid 
+                    inner join pg_attribute a
+                        on c.oid = a.attrelid
+            where bc.relname = ?
+                and bc.relkind in ('r', 'v')
+                and pg_catalog.pg_table_is_visible(bc.oid);
+        ]
+
+        sql2 = %[
+            SELECT a.attname, a.atttypid, a.attnotnull, a.attlen, format_type(a.atttypid, a.atttypmod) 
+            FROM pg_catalog.pg_class c, pg_attribute a, pg_type t 
+            WHERE a.attnum > 0 AND a.attrelid = c.oid AND a.atttypid = t.oid AND c.relname = ?
+                AND c.relkind IN ('r','v')
+            AND pg_catalog.pg_table_is_visible(c.oid)
+        ]
+
+        # by Michael Neumann (get default value)
+        # corrected by Joseph McDonald
+        # from https://www.postgresql.org/docs/12/release-12.html
+        # Remove obsolete pg_attrdef.adsrc column (Peter Eisentraut)
+        # This column has been deprecated for a long time, because it did not update in response to other catalog changes (such as column renamings). The # # recommended way to get a text version of a default-value expression from pg_attrdef is pg_get_expr(adbin, adrelid).
+
+        sql3 = %[
+            SELECT pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid), pg_attribute.attname
+            FROM pg_attribute, pg_attrdef, pg_catalog.pg_class
+            WHERE pg_catalog.pg_class.relname = ? AND
+            pg_attribute.attrelid = pg_catalog.pg_class.oid AND
+                          pg_attrdef.adrelid = pg_catalog.pg_class.oid AND
+                          pg_attrdef.adnum = pg_attribute.attnum
+                          AND pg_catalog.pg_class.relkind IN ('r','v')
+                          AND pg_catalog.pg_table_is_visible(pg_catalog.pg_class.oid)
+        ]
+
+        dbh = DBI::DatabaseHandle.new(self)
+        dbh.driver_name = DBI::DBD::Pg.driver_name
+        indices = {}
+        default_values = {}
+
+        dbh.select_all(sql3, table) do |default, name|
+            default_values[name] = default
+        end
+
+        dbh.select_all(sql1, table) do |name, primary, unique|
+            indices[name] = [primary, unique]
+        end
+
+        ########## 
+
+        ret = []
+        dbh.execute(sql2, table) do |sth|
+            ret = sth.collect do |row|
+                name, pg_type, notnullable, len, ftype = row
+                #name = row[2]
+                indexed = false
+                primary = nil
+                unique = nil
+                if indices.has_key?(name)
+                    indexed = true
+                    primary, unique = indices[name]
+                end
+
+                typeinfo = DBI::DBD::Pg.parse_type(ftype)
+                typeinfo[:size] ||= len
+
+                if POSTGRESQL_to_XOPEN.has_key?(typeinfo[:type])
+                    sql_type = POSTGRESQL_to_XOPEN[typeinfo[:type]][0]
+                else
+                    sql_type = POSTGRESQL_to_XOPEN[nil][0]
+                end
+
+                row = {}
+                row['name']           = name
+                row['sql_type']       = sql_type
+                row['type_name']      = typeinfo[:type]
+                row['nullable']       = ! notnullable
+                row['indexed']        = indexed
+                row['primary']        = primary
+                row['unique']         = unique
+                row['precision']      = typeinfo[:size]
+                row['scale']          = typeinfo[:decimal]
+                row['default']        = default_values[name]
+                row['array_of_type']  = typeinfo[:array]
+
+                if typeinfo[:array]
+                    row['dbi_type'] = 
+                        DBI::DBD::Pg::Type::Array.new(
+                            DBI::TypeUtil.type_name_to_module(typeinfo[:type])
+                    )
+                end
+                row
+            end # collect
+        end # execute
+
+        return ret
+    end
+
+    def prepare(statement)
+        DBI::DBD::Pg::Statement.new(self, statement)
+    end
+
+    def [](attr)
+        case attr
+        when 'pg_client_encoding'
+            @connection.client_encoding
+        when 'NonBlocking'
+            @attr['pg_async']
+        else
+            @attr[attr]
+        end
+    end
+
+    def []=(attr, value)
+        case attr
+        when 'AutoCommit'
+            if @attr['AutoCommit'] != value then
+                if value    # turn AutoCommit ON
+                    if @in_transaction
+                        # TODO: commit outstanding transactions?
+                        _exec("COMMIT")
+                        @in_transaction = false
+                    end
+                else        # turn AutoCommit OFF
+                    @in_transaction = false
+                end
+            end
+        # value is assigned below
+        when 'NonBlocking', 'pg_async'
+            # booleanize input
+            value = value ? true : false
+            @pgexec = (value ? DBI::DBD::Pg::PgExecutorAsync : DBI::DBD::Pg::PgExecutor).new(@connection)
+            # value is assigned to @attr below
+        when 'pg_client_encoding'
+            @connection.set_client_encoding(value)
+        when 'pg_native_binding'
+            @attr[attr] = value
+        else
+            if attr =~ /^pg_/ or attr != /_/
+                raise DBI::NotSupportedError, "Option '#{attr}' not supported"
+            else # option for some other driver - quitly ignore
+                return
+            end
+        end
+        @attr[attr] = value
+    end
+
+    def commit
+        if @in_transaction
+            _exec("COMMIT")
+            @in_transaction = false
+        else
+            # TODO: Warn?
+        end
+    end
+
+    def rollback
+        if @in_transaction
+            _exec("ROLLBACK")
+            @in_transaction = false
+        else
+            # TODO: Warn?
+        end
+    end
+
+    #
+    # Are we in an transaction?
+    #
+    def in_transaction?
+        @in_transaction
+    end
+
+    #
+    # Forcibly initializes a new transaction.
+    #
+    def start_transaction
+        _exec("BEGIN")
+        @in_transaction = true
+    end
+
+    def _exec(sql, *parameters)
+        @pgexec.exec(sql, parameters)
+    end
+
+    def _exec_prepared(stmt_name, *parameters)
+        @pgexec.exec_prepared(stmt_name, parameters)
+    end
+
+    def _prepare(stmt_name, sql)
+        @pgexec.prepare(stmt_name, sql)
+    end
+
+    private 
+
+    def parse_type_name(type_name)
+        case type_name
+        when 'bool'                      then DBI::Type::Boolean
+        when 'int8', 'int4', 'int2'      then DBI::Type::Integer
+        when 'varchar'                   then DBI::Type::Varchar
+        when 'float4','float8'           then DBI::Type::Float
+        when 'time', 'timetz'            then DBI::Type::Timestamp
+        when 'timestamp', 'timestamptz'  then DBI::Type::Timestamp
+        when 'date'                      then DBI::Type::Timestamp
+        when 'decimal', 'numeric'        then DBI::Type::Decimal
+        when 'bytea'                     then DBI::DBD::Pg::Type::ByteA
+        when 'enum'                      then DBI::Type::Varchar
+        end
+    end
+
+    #
+    # Gathers the types from the postgres database and attempts to
+    # locate matching DBI::Type objects for them.
+    # 
+    def load_type_map
+        @type_map = Hash.new
+
+        res = _exec("SELECT oid, typname, typelem FROM pg_type WHERE typtype IN ('b', 'e')")
+
+        res.each do |row|
+            rowtype = parse_type_name(row["typname"])
+            @type_map[row["oid"].to_i] = 
+                { 
+                    "type_name" => row["typname"],
+                    "dbi_type" => 
+                        if rowtype
+                            rowtype
+                        elsif row["typname"] =~ /^_/ and row["typelem"].to_i > 0 then
+                            # arrays are special and have a subtype, as an
+                            # oid held in the "typelem" field.
+                            # Since we may not have a mapping for the
+                            # subtype yet, defer by storing the typelem
+                            # integer as a base type in a constructed
+                            # Type::Array object. dirty, i know.
+                            #
+                            # These array objects will be reconstructed
+                            # after all rows are processed and therefore
+                            # the oid -> type mapping is complete.
+                            # 
+                            DBI::DBD::Pg::Type::Array.new(row["typelem"].to_i)
+                        else
+                            DBI::Type::Varchar
+                        end
+                }
+        end 
+        # additional conversions
+        @type_map[705]  ||= DBI::Type::Varchar       # select 'hallo'
+        @type_map[1114] ||= DBI::Type::Timestamp # TIMESTAMP WITHOUT TIME ZONE
+
+        # remap array subtypes
+        @type_map.each_key do |key|
+            if @type_map[key]["dbi_type"].class == DBI::DBD::Pg::Type::Array
+                oid = @type_map[key]["dbi_type"].base_type
+                if @type_map[oid]
+                    @type_map[key]["dbi_type"] = DBI::DBD::Pg::Type::Array.new(@type_map[oid]["dbi_type"])
+                else
+                    # punt
+                    @type_map[key] = DBI::DBD::Pg::Type::Array.new(DBI::Type::Varchar)
+                end
+            end unless key.is_a?(Integer)
+        end
+    end
+
+    public
+
+    # return the postgresql types for this session. returns an oid -> type name mapping.
+    def __types(force=nil)
+        load_type_map if (!@type_map or force)
+        @type_map
+    end
+
+    # deprecated.
+    def __types_old
+        h = { } 
+
+        _exec('select oid, typname from pg_type').each do |row|
+            h[row["oid"].to_i] = row["typname"]
+        end
+
+        return h
+    end
+
+    #
+    # Import a BLOB from a file.
+    # 
+    def __blob_import(file)
+        start_transaction unless @in_transaction
+        @connection.lo_import(file)
+    rescue PG::Error => err
+        raise DBI::DatabaseError.new(err.message) 
+    end
+
+    #
+    # Export a BLOB to a file.
+    #
+    def __blob_export(oid, file)
+        start_transaction unless @in_transaction
+        @connection.lo_export(oid.to_i, file)
+    rescue PG::Error => err
+        raise DBI::DatabaseError.new(err.message) 
+    end
+
+    #
+    # Create a BLOB.
+    #
+    def __blob_create(mode=PG::Connection::INV_READ)
+        start_transaction unless @in_transaction
+        @connection.lo_creat(mode)
+    rescue PG::Error => err
+        raise DBI::DatabaseError.new(err.message) 
+    end
+
+    #
+    # Open a BLOB.
+    #
+    def __blob_open(oid, mode=PG::Connection::INV_READ)
+        start_transaction unless @in_transaction
+        @connection.lo_open(oid.to_i, mode)
+    rescue PG::Error => err
+        raise DBI::DatabaseError.new(err.message) 
+    end
+
+    #
+    # Remove a BLOB.
+    #
+    def __blob_unlink(oid)
+        start_transaction unless @in_transaction
+        @connection.lo_unlink(oid.to_i)
+    rescue PG::Error => err
+        raise DBI::DatabaseError.new(err.message) 
+    end
+
+    #
+    # Read a BLOB and return the data.
+    #
+    def __blob_read(oid, length)
+        blob = @connection.lo_open(oid.to_i, PG::Connection::INV_READ)
+
+        if length.nil?
+            data = @connection.lo_read(blob)
+        else
+            data = @connection.lo_read(blob, length)
+        end
+
+        # FIXME it doesn't like to close here either.
+        # @connection.lo_close(blob)
+        data
+    rescue PG::Error => err
+        raise DBI::DatabaseError.new(err.message) 
+    end
+
+    #
+    # Write the value to the BLOB.
+    #
+    def __blob_write(oid, value)
+        start_transaction unless @in_transaction
+        blob = @connection.lo_open(oid.to_i, PG::Connection::INV_WRITE)
+        res = @connection.lo_write(blob, value)
+        # FIXME not sure why PG doesn't like to close here -- seems to be
+        # working but we should make sure it's not eating file descriptors
+        # up before release.
+        # @connection.lo_close(blob)
+        return res
+    rescue PG::Error => err
+        raise DBI::DatabaseError.new(err.message)
+    end
+
+    #
+    # FIXME DOCUMENT
+    #
+    def __set_notice_processor(proc)
+        @connection.set_notice_processor proc
+    rescue PG::Error => err
+        raise DBI::DatabaseError.new(err.message) 
+    end
+end # Database

data/lib/dbd/pg/exec.rb

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,160 @@
+#
+# 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