large_obj.c

Go to the documentation of this file.

/*
 * psql - the PostgreSQL interactive terminal
 *
 * Copyright (c) 2000-2024, PostgreSQL Global Development Group
 *
 * src/bin/psql/large_obj.c
 */
#include "postgres_fe.h"
 
#include "common.h"
#include "common/logging.h"
#include "fe_utils/cancel.h"
#include "large_obj.h"
#include "settings.h"
 
static void print_lo_result(const char *fmt,...) pg_attribute_printf(1, 2);
 
static void
print_lo_result(const char *fmt,...)
{
    va_list     ap;
 
    if (!pset.quiet)
    {
        if (pset.popt.topt.format == PRINT_HTML)
            fputs("<p>", pset.queryFout);
 
        va_start(ap, fmt);
        vfprintf(pset.queryFout, fmt, ap);
        va_end(ap);
 
        if (pset.popt.topt.format == PRINT_HTML)
            fputs("</p>\n", pset.queryFout);
        else
            fputs("\n", pset.queryFout);
    }
 
    if (pset.logfile)
    {
        va_start(ap, fmt);
        vfprintf(pset.logfile, fmt, ap);
        va_end(ap);
        fputs("\n", pset.logfile);
    }
}
 
 
/*
 * Prepare to do a large-object operation.  We *must* be inside a transaction
 * block for all these operations, so start one if needed.
 *
 * Returns true if okay, false if failed.  *own_transaction is set to indicate
 * if we started our own transaction or not.
 */
static bool
start_lo_xact(const char *operation, bool *own_transaction)
{
    PGTransactionStatusType tstatus;
    PGresult   *res;
 
    *own_transaction = false;
 
    if (!pset.db)
    {
        pg_log_error("%s: not connected to a database", operation);
        return false;
    }
 
    tstatus = PQtransactionStatus(pset.db);
 
    switch (tstatus)
    {
        case PQTRANS_IDLE:
            /* need to start our own xact */
            if (!(res = PSQLexec("BEGIN")))
                return false;
            PQclear(res);
            *own_transaction = true;
            break;
        case PQTRANS_INTRANS:
            /* use the existing xact */
            break;
        case PQTRANS_INERROR:
            pg_log_error("%s: current transaction is aborted", operation);
            return false;
        default:
            pg_log_error("%s: unknown transaction status", operation);
            return false;
    }
 
    return true;
}
 
/*
 * Clean up after a successful LO operation
 */
static bool
finish_lo_xact(const char *operation, bool own_transaction)
{
    PGresult   *res;
 
    if (own_transaction && pset.autocommit)
    {
        /* close out our own xact */
        if (!(res = PSQLexec("COMMIT")))
        {
            res = PSQLexec("ROLLBACK");
            PQclear(res);
            return false;
        }
        PQclear(res);
    }
 
    return true;
}
 
/*
 * Clean up after a failed LO operation
 */
static bool
fail_lo_xact(const char *operation, bool own_transaction)
{
    PGresult   *res;
 
    if (own_transaction && pset.autocommit)
    {
        /* close out our own xact */
        res = PSQLexec("ROLLBACK");
        PQclear(res);
    }
 
    return false;               /* always */
}
 
 
/*
 * do_lo_export()
 *
 * Write a large object to a file
 */
bool
do_lo_export(const char *loid_arg, const char *filename_arg)
{
    int         status;
    bool        own_transaction;
 
    if (!start_lo_xact("\\lo_export", &own_transaction))
        return false;
 
    SetCancelConn(NULL);
    status = lo_export(pset.db, atooid(loid_arg), filename_arg);
    ResetCancelConn();
 
    /* of course this status is documented nowhere :( */
    if (status != 1)
    {
        pg_log_info("%s", PQerrorMessage(pset.db));
        return fail_lo_xact("\\lo_export", own_transaction);
    }
 
    if (!finish_lo_xact("\\lo_export", own_transaction))
        return false;
 
    print_lo_result("lo_export");
 
    return true;
}
 
 
/*
 * do_lo_import()
 *
 * Copy large object from file to database
 */
bool
do_lo_import(const char *filename_arg, const char *comment_arg)
{
    PGresult   *res;
    Oid         loid;
    char        oidbuf[32];
    bool        own_transaction;
 
    if (!start_lo_xact("\\lo_import", &own_transaction))
        return false;
 
    SetCancelConn(NULL);
    loid = lo_import(pset.db, filename_arg);
    ResetCancelConn();
 
    if (loid == InvalidOid)
    {
        pg_log_info("%s", PQerrorMessage(pset.db));
        return fail_lo_xact("\\lo_import", own_transaction);
    }
 
    /* insert description if given */
    if (comment_arg)
    {
        char       *cmdbuf;
        char       *bufptr;
        size_t      slen = strlen(comment_arg);
 
        cmdbuf = pg_malloc_extended(slen * 2 + 256, MCXT_ALLOC_NO_OOM);
        if (!cmdbuf)
            return fail_lo_xact("\\lo_import", own_transaction);
        sprintf(cmdbuf, "COMMENT ON LARGE OBJECT %u IS '", loid);
        bufptr = cmdbuf + strlen(cmdbuf);
        bufptr += PQescapeStringConn(pset.db, bufptr, comment_arg, slen, NULL);
        strcpy(bufptr, "'");
 
        if (!(res = PSQLexec(cmdbuf)))
        {
            free(cmdbuf);
            return fail_lo_xact("\\lo_import", own_transaction);
        }
 
        PQclear(res);
        free(cmdbuf);
    }
 
    if (!finish_lo_xact("\\lo_import", own_transaction))
        return false;
 
    print_lo_result("lo_import %u", loid);
 
    sprintf(oidbuf, "%u", loid);
    SetVariable(pset.vars, "LASTOID", oidbuf);
 
    return true;
}
 
 
/*
 * do_lo_unlink()
 *
 * removes a large object out of the database
 */
bool
do_lo_unlink(const char *loid_arg)
{
    int         status;
    Oid         loid = atooid(loid_arg);
    bool        own_transaction;
 
    if (!start_lo_xact("\\lo_unlink", &own_transaction))
        return false;
 
    SetCancelConn(NULL);
    status = lo_unlink(pset.db, loid);
    ResetCancelConn();
 
    if (status == -1)
    {
        pg_log_info("%s", PQerrorMessage(pset.db));
        return fail_lo_xact("\\lo_unlink", own_transaction);
    }
 
    if (!finish_lo_xact("\\lo_unlink", own_transaction))
        return false;
 
    print_lo_result("lo_unlink %u", loid);
 
    return true;
}