fe-lobj.c File Reference

#include "postgres_fe.h"
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/stat.h>
#include "libpq-fe.h"
#include "libpq-int.h"
#include "libpq/libpq-fs.h"
#include "port/pg_bswap.h"

Include dependency graph for fe-lobj.c:

Go to the source code of this file.

Macros
#define	LO_BUFSIZE   8192

Functions
static int	lo_initialize (PGconn *conn)
static Oid	lo_import_internal (PGconn *conn, const char *filename, Oid oid)
static int64_t	lo_hton64 (int64_t host64)
static int64_t	lo_ntoh64 (int64_t net64)
int	lo_open (PGconn *conn, Oid lobjId, int mode)
int	lo_close (PGconn *conn, int fd)
int	lo_truncate (PGconn *conn, int fd, size_t len)
int	lo_truncate64 (PGconn *conn, int fd, int64_t len)
int	lo_read (PGconn *conn, int fd, char *buf, size_t len)
int	lo_write (PGconn *conn, int fd, const char *buf, size_t len)
int	lo_lseek (PGconn *conn, int fd, int offset, int whence)
int64_t	lo_lseek64 (PGconn *conn, int fd, int64_t offset, int whence)
Oid	lo_creat (PGconn *conn, int mode)
Oid	lo_create (PGconn *conn, Oid lobjId)
int	lo_tell (PGconn *conn, int fd)
int64_t	lo_tell64 (PGconn *conn, int fd)
int	lo_unlink (PGconn *conn, Oid lobjId)
Oid	lo_import (PGconn *conn, const char *filename)
Oid	lo_import_with_oid (PGconn *conn, const char *filename, Oid lobjId)
int	lo_export (PGconn *conn, Oid lobjId, const char *filename)

Macro Definition Documentation

LO_BUFSIZE

#define LO_BUFSIZE   8192

Definition at line 42 of file fe-lobj.c.

Function Documentation

lo_close()

int lo_close	(	PGconn *	conn,
		int	fd
	)

Definition at line 96 of file fe-lobj.c.

{
    PQArgBlock  argv[1];
    PGresult   *res;
    int         retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
    res = PQfn(conn, conn->lobjfuncs->fn_lo_close,
               &retval, &result_len, 1, argv, 1);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_close, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by dumpLOs(), EndRestoreLO(), exportFile(), importFile(), lo_export(), lo_import_internal(), my_truncate(), overwrite(), and pickout().

lo_creat()

Oid lo_creat	(	PGconn *	conn,
		int	mode
	)

Definition at line 438 of file fe-lobj.c.

{
    PQArgBlock  argv[1];
    PGresult   *res;
    int         retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return InvalidOid;
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = mode;
    res = PQfn(conn, conn->lobjfuncs->fn_lo_creat,
               &retval, &result_len, 1, argv, 1);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return (Oid) retval;
    }
    else
    {
        PQclear(res);
        return InvalidOid;
    }
}

References conn, pgLobjfuncs::fn_lo_creat, PQArgBlock::integer, InvalidOid, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, mode, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by importFile(), and lo_import_internal().

lo_create()

Oid lo_create	(	PGconn *	conn,
		Oid	lobjId
	)

Definition at line 474 of file fe-lobj.c.

{
    PQArgBlock  argv[1];
    PGresult   *res;
    int         retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return InvalidOid;
 
    /* Must check this on-the-fly because it's not there pre-8.1 */
    if (conn->lobjfuncs->fn_lo_create == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_create");
        return InvalidOid;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = lobjId;
    res = PQfn(conn, conn->lobjfuncs->fn_lo_create,
               &retval, &result_len, 1, argv, 1);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return (Oid) retval;
    }
    else
    {
        PQclear(res);
        return InvalidOid;
    }
}

References conn, pgLobjfuncs::fn_lo_create, PQArgBlock::integer, InvalidOid, PQArgBlock::isint, PQArgBlock::len, libpq_append_conn_error(), lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by lo_import_internal(), and StartRestoreLO().

lo_export()

int lo_export	(	PGconn *	conn,
		Oid	lobjId,
		const char *	filename
	)

Definition at line 748 of file fe-lobj.c.

{
    int         result = 1;
    int         fd;
    int         nbytes,
                tmp;
    char        buf[LO_BUFSIZE];
    int         lobj;
    char        sebuf[PG_STRERROR_R_BUFLEN];
 
    /*
     * open the large object.
     */
    lobj = lo_open(conn, lobjId, INV_READ);
    if (lobj == -1)
    {
        /* we assume lo_open() already set a suitable error message */
        return -1;
    }
 
    /*
     * create the file to be written to
     */
    fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY, 0666);
    if (fd < 0)
    {
        /* We must do lo_close before setting the errorMessage */
        int         save_errno = errno;
 
        (void) lo_close(conn, lobj);
        /* deliberately overwrite any error from lo_close */
        pqClearConnErrorState(conn);
        libpq_append_conn_error(conn, "could not open file \"%s\": %s",
                                filename,
                                strerror_r(save_errno, sebuf, sizeof(sebuf)));
        return -1;
    }
 
    /*
     * read in from the large object and write to the file
     */
    while ((nbytes = lo_read(conn, lobj, buf, LO_BUFSIZE)) > 0)
    {
        tmp = write(fd, buf, nbytes);
        if (tmp != nbytes)
        {
            /* We must do lo_close before setting the errorMessage */
            int         save_errno = errno;
 
            (void) lo_close(conn, lobj);
            (void) close(fd);
            /* deliberately overwrite any error from lo_close */
            pqClearConnErrorState(conn);
            libpq_append_conn_error(conn, "could not write to file \"%s\": %s",
                                    filename,
                                    strerror_r(save_errno, sebuf, sizeof(sebuf)));
            return -1;
        }
    }
 
    /*
     * If lo_read() failed, we are now in an aborted transaction so there's no
     * need for lo_close(); furthermore, if we tried it we'd overwrite the
     * useful error result with a useless one. So skip lo_close() if we got a
     * failure result.
     */
    if (nbytes < 0 ||
        lo_close(conn, lobj) != 0)
    {
        /* assume lo_read() or lo_close() left a suitable error message */
        result = -1;
    }
 
    /* if we already failed, don't overwrite that msg with a close error */
    if (close(fd) != 0 && result >= 0)
    {
        libpq_append_conn_error(conn, "could not write to file \"%s\": %s",
                                filename, strerror_r(errno, sebuf, sizeof(sebuf)));
        result = -1;
    }
 
    return result;
}

References buf, close, conn, fd(), filename, INV_READ, libpq_append_conn_error(), LO_BUFSIZE, lo_close(), lo_open(), lo_read(), PG_BINARY, PG_STRERROR_R_BUFLEN, pqClearConnErrorState, strerror_r, and write.

Referenced by do_lo_export(), and main().

lo_hton64()

static int64_t lo_hton64 ( int64_t  host64 )

static

Definition at line 1023 of file fe-lobj.c.

{
    union
    {
        int64       i64;
        uint32      i32[2];
    }           swap;
    uint32      t;
 
    /* High order half first, since we're doing MSB-first */
    t = (uint32) (host64 >> 32);
    swap.i32[0] = pg_hton32(t);
 
    /* Now the low order half */
    t = (uint32) host64;
    swap.i32[1] = pg_hton32(t);
 
    return swap.i64;
}

References pg_hton32.

Referenced by lo_lseek64(), and lo_truncate64().

lo_import()

Oid lo_import	(	PGconn *	conn,
		const char *	filename
	)

Definition at line 626 of file fe-lobj.c.

{
    return lo_import_internal(conn, filename, InvalidOid);
}

References conn, filename, InvalidOid, and lo_import_internal().

Referenced by do_lo_import(), and main().

lo_import_internal()

static Oid lo_import_internal ( PGconn *  conn, const char *  filename, Oid  oid  )

static

Definition at line 647 of file fe-lobj.c.

{
    int         fd;
    int         nbytes,
                tmp;
    char        buf[LO_BUFSIZE];
    Oid         lobjOid;
    int         lobj;
    char        sebuf[PG_STRERROR_R_BUFLEN];
 
    if (conn == NULL)
        return InvalidOid;
 
    /* Since this is the beginning of a query cycle, reset the error state */
    pqClearConnErrorState(conn);
 
    /*
     * open the file to be read in
     */
    fd = open(filename, O_RDONLY | PG_BINARY, 0666);
    if (fd < 0)
    {                           /* error */
        libpq_append_conn_error(conn, "could not open file \"%s\": %s",
                                filename, strerror_r(errno, sebuf, sizeof(sebuf)));
        return InvalidOid;
    }
 
    /*
     * create an inversion object
     */
    if (oid == InvalidOid)
        lobjOid = lo_creat(conn, INV_READ | INV_WRITE);
    else
        lobjOid = lo_create(conn, oid);
 
    if (lobjOid == InvalidOid)
    {
        /* we assume lo_create() already set a suitable error message */
        (void) close(fd);
        return InvalidOid;
    }
 
    lobj = lo_open(conn, lobjOid, INV_WRITE);
    if (lobj == -1)
    {
        /* we assume lo_open() already set a suitable error message */
        (void) close(fd);
        return InvalidOid;
    }
 
    /*
     * read in from the file and write to the large object
     */
    while ((nbytes = read(fd, buf, LO_BUFSIZE)) > 0)
    {
        tmp = lo_write(conn, lobj, buf, nbytes);
        if (tmp != nbytes)
        {
            /*
             * If lo_write() failed, we are now in an aborted transaction so
             * there's no need for lo_close(); furthermore, if we tried it
             * we'd overwrite the useful error result with a useless one. So
             * just nail the doors shut and get out of town.
             */
            (void) close(fd);
            return InvalidOid;
        }
    }
 
    if (nbytes < 0)
    {
        /* We must do lo_close before setting the errorMessage */
        int         save_errno = errno;
 
        (void) lo_close(conn, lobj);
        (void) close(fd);
        /* deliberately overwrite any error from lo_close */
        pqClearConnErrorState(conn);
        libpq_append_conn_error(conn, "could not read from file \"%s\": %s",
                                filename,
                                strerror_r(save_errno, sebuf, sizeof(sebuf)));
        return InvalidOid;
    }
 
    (void) close(fd);
 
    if (lo_close(conn, lobj) != 0)
    {
        /* we assume lo_close() already set a suitable error message */
        return InvalidOid;
    }
 
    return lobjOid;
}

References buf, close, conn, fd(), filename, INV_READ, INV_WRITE, InvalidOid, libpq_append_conn_error(), LO_BUFSIZE, lo_close(), lo_creat(), lo_create(), lo_open(), lo_write(), PG_BINARY, PG_STRERROR_R_BUFLEN, pqClearConnErrorState, read, and strerror_r.

Referenced by lo_import(), and lo_import_with_oid().

lo_import_with_oid()

Oid lo_import_with_oid	(	PGconn *	conn,
		const char *	filename,
		Oid	lobjId
	)

Definition at line 641 of file fe-lobj.c.

{
    return lo_import_internal(conn, filename, lobjId);
}

References conn, filename, and lo_import_internal().

lo_initialize()

static int lo_initialize ( PGconn *  conn )

static

Definition at line 843 of file fe-lobj.c.

{
    PGresult   *res;
    PGlobjfuncs *lobjfuncs;
    int         n;
    const char *query;
    const char *fname;
    Oid         foid;
 
    /* Nothing we can do with no connection */
    if (conn == NULL)
        return -1;
 
    /* Since this is the beginning of a query cycle, reset the error state */
    pqClearConnErrorState(conn);
 
    /* Nothing else to do if we already collected info */
    if (conn->lobjfuncs != NULL)
        return 0;
 
    /*
     * Allocate the structure to hold the function OIDs.  We don't store it
     * into the PGconn until it's successfully filled.
     */
    lobjfuncs = (PGlobjfuncs *) malloc(sizeof(PGlobjfuncs));
    if (lobjfuncs == NULL)
    {
        libpq_append_conn_error(conn, "out of memory");
        return -1;
    }
    MemSet(lobjfuncs, 0, sizeof(PGlobjfuncs));
 
    /*
     * Execute the query to get all the functions at once.  (Not all of them
     * may exist in older server versions.)
     */
    query = "select proname, oid from pg_catalog.pg_proc "
        "where proname in ("
        "'lo_open', "
        "'lo_close', "
        "'lo_creat', "
        "'lo_create', "
        "'lo_unlink', "
        "'lo_lseek', "
        "'lo_lseek64', "
        "'lo_tell', "
        "'lo_tell64', "
        "'lo_truncate', "
        "'lo_truncate64', "
        "'loread', "
        "'lowrite') "
        "and pronamespace = (select oid from pg_catalog.pg_namespace "
        "where nspname = 'pg_catalog')";
 
    res = PQexec(conn, query);
    if (res == NULL)
    {
        free(lobjfuncs);
        return -1;
    }
 
    if (res->resultStatus != PGRES_TUPLES_OK)
    {
        free(lobjfuncs);
        PQclear(res);
        libpq_append_conn_error(conn, "query to initialize large object functions did not return data");
        return -1;
    }
 
    /*
     * Examine the result and put the OID's into the struct
     */
    for (n = 0; n < PQntuples(res); n++)
    {
        fname = PQgetvalue(res, n, 0);
        foid = (Oid) atoi(PQgetvalue(res, n, 1));
        if (strcmp(fname, "lo_open") == 0)
            lobjfuncs->fn_lo_open = foid;
        else if (strcmp(fname, "lo_close") == 0)
            lobjfuncs->fn_lo_close = foid;
        else if (strcmp(fname, "lo_creat") == 0)
            lobjfuncs->fn_lo_creat = foid;
        else if (strcmp(fname, "lo_create") == 0)
            lobjfuncs->fn_lo_create = foid;
        else if (strcmp(fname, "lo_unlink") == 0)
            lobjfuncs->fn_lo_unlink = foid;
        else if (strcmp(fname, "lo_lseek") == 0)
            lobjfuncs->fn_lo_lseek = foid;
        else if (strcmp(fname, "lo_lseek64") == 0)
            lobjfuncs->fn_lo_lseek64 = foid;
        else if (strcmp(fname, "lo_tell") == 0)
            lobjfuncs->fn_lo_tell = foid;
        else if (strcmp(fname, "lo_tell64") == 0)
            lobjfuncs->fn_lo_tell64 = foid;
        else if (strcmp(fname, "lo_truncate") == 0)
            lobjfuncs->fn_lo_truncate = foid;
        else if (strcmp(fname, "lo_truncate64") == 0)
            lobjfuncs->fn_lo_truncate64 = foid;
        else if (strcmp(fname, "loread") == 0)
            lobjfuncs->fn_lo_read = foid;
        else if (strcmp(fname, "lowrite") == 0)
            lobjfuncs->fn_lo_write = foid;
    }
 
    PQclear(res);
 
    /*
     * Finally check that we got all required large object interface functions
     * (ones that have been added later than the stone age are instead checked
     * only if used)
     */
    if (lobjfuncs->fn_lo_open == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_open");
        free(lobjfuncs);
        return -1;
    }
    if (lobjfuncs->fn_lo_close == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_close");
        free(lobjfuncs);
        return -1;
    }
    if (lobjfuncs->fn_lo_creat == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_creat");
        free(lobjfuncs);
        return -1;
    }
    if (lobjfuncs->fn_lo_unlink == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_unlink");
        free(lobjfuncs);
        return -1;
    }
    if (lobjfuncs->fn_lo_lseek == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_lseek");
        free(lobjfuncs);
        return -1;
    }
    if (lobjfuncs->fn_lo_tell == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_tell");
        free(lobjfuncs);
        return -1;
    }
    if (lobjfuncs->fn_lo_read == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "loread");
        free(lobjfuncs);
        return -1;
    }
    if (lobjfuncs->fn_lo_write == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lowrite");
        free(lobjfuncs);
        return -1;
    }
 
    /*
     * Put the structure into the connection control
     */
    conn->lobjfuncs = lobjfuncs;
    return 0;
}

References conn, pgLobjfuncs::fn_lo_close, pgLobjfuncs::fn_lo_creat, pgLobjfuncs::fn_lo_create, pgLobjfuncs::fn_lo_lseek, pgLobjfuncs::fn_lo_lseek64, pgLobjfuncs::fn_lo_open, pgLobjfuncs::fn_lo_read, pgLobjfuncs::fn_lo_tell, pgLobjfuncs::fn_lo_tell64, pgLobjfuncs::fn_lo_truncate, pgLobjfuncs::fn_lo_truncate64, pgLobjfuncs::fn_lo_unlink, pgLobjfuncs::fn_lo_write, free, if(), libpq_append_conn_error(), pg_conn::lobjfuncs, malloc, MemSet, PGRES_TUPLES_OK, PQclear(), pqClearConnErrorState, PQexec(), PQgetvalue(), PQntuples(), and pg_result::resultStatus.

Referenced by lo_close(), lo_creat(), lo_create(), lo_lseek(), lo_lseek64(), lo_open(), lo_read(), lo_tell(), lo_tell64(), lo_truncate(), lo_truncate64(), lo_unlink(), and lo_write().

lo_lseek()

int lo_lseek	(	PGconn *	conn,
		int	fd,
		int	offset,
		int	whence
	)

Definition at line 344 of file fe-lobj.c.

{
    PQArgBlock  argv[3];
    PGresult   *res;
    int         retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    argv[1].isint = 1;
    argv[1].len = 4;
    argv[1].u.integer = offset;
 
    argv[2].isint = 1;
    argv[2].len = 4;
    argv[2].u.integer = whence;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_lseek,
               &retval, &result_len, 1, argv, 3);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_lseek, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by overwrite(), and pickout().

lo_lseek64()

int64_t lo_lseek64	(	PGconn *	conn,
		int	fd,
		int64_t	offset,
		int	whence
	)

Definition at line 385 of file fe-lobj.c.

{
    PQArgBlock  argv[3];
    PGresult   *res;
    int64       retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    if (conn->lobjfuncs->fn_lo_lseek64 == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_lseek64");
        return -1;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    offset = lo_hton64(offset);
    argv[1].isint = 0;
    argv[1].len = 8;
    argv[1].u.ptr = (int *) &offset;
 
    argv[2].isint = 1;
    argv[2].len = 4;
    argv[2].u.integer = whence;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_lseek64,
               (void *) &retval, &result_len, 0, argv, 3);
    if (PQresultStatus(res) == PGRES_COMMAND_OK && result_len == 8)
    {
        PQclear(res);
        return lo_ntoh64(retval);
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_lseek64, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_append_conn_error(), lo_hton64(), lo_initialize(), lo_ntoh64(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), PQArgBlock::ptr, and PQArgBlock::u.

Referenced by overwrite(), and pickout().

lo_ntoh64()

static int64_t lo_ntoh64 ( int64_t  net64 )

static

Definition at line 1048 of file fe-lobj.c.

{
    union
    {
        int64       i64;
        uint32      i32[2];
    }           swap;
    int64       result;
 
    swap.i64 = net64;
 
    result = (uint32) pg_ntoh32(swap.i32[0]);
    result <<= 32;
    result |= (uint32) pg_ntoh32(swap.i32[1]);
 
    return result;
}

References pg_ntoh32.

Referenced by lo_lseek64(), and lo_tell64().

lo_open()

int lo_open	(	PGconn *	conn,
		Oid	lobjId,
		int	mode
	)

Definition at line 57 of file fe-lobj.c.

{
    int         fd;
    int         result_len;
    PQArgBlock  argv[2];
    PGresult   *res;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = lobjId;
 
    argv[1].isint = 1;
    argv[1].len = 4;
    argv[1].u.integer = mode;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_open, &fd, &result_len, 1, argv, 2);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return fd;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_open, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, mode, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by dumpLOs(), exportFile(), importFile(), lo_export(), lo_import_internal(), my_truncate(), overwrite(), pickout(), and StartRestoreLO().

lo_read()

int lo_read	(	PGconn *	conn,
		int	fd,
		char *	buf,
		size_t	len
	)

Definition at line 245 of file fe-lobj.c.

{
    PQArgBlock  argv[2];
    PGresult   *res;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    /*
     * Long ago, somebody thought it'd be a good idea to declare this function
     * as taking size_t ... but the underlying backend function only accepts a
     * signed int32 length.  So throw error if the given value overflows
     * int32.
     */
    if (len > (size_t) INT_MAX)
    {
        libpq_append_conn_error(conn, "argument of lo_read exceeds integer range");
        return -1;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    argv[1].isint = 1;
    argv[1].len = 4;
    argv[1].u.integer = (int) len;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_read,
               (void *) buf, &result_len, 0, argv, 2);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return result_len;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References buf, conn, fd(), pgLobjfuncs::fn_lo_read, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, len, libpq_append_conn_error(), lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by lo_export().

lo_tell()

int lo_tell	(	PGconn *	conn,
		int	fd
	)

Definition at line 515 of file fe-lobj.c.

{
    int         retval;
    PQArgBlock  argv[1];
    PGresult   *res;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_tell,
               &retval, &result_len, 1, argv, 1);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_tell, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

lo_tell64()

int64_t lo_tell64	(	PGconn *	conn,
		int	fd
	)

Definition at line 548 of file fe-lobj.c.

{
    int64       retval;
    PQArgBlock  argv[1];
    PGresult   *res;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    if (conn->lobjfuncs->fn_lo_tell64 == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_tell64");
        return -1;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_tell64,
               (void *) &retval, &result_len, 0, argv, 1);
    if (PQresultStatus(res) == PGRES_COMMAND_OK && result_len == 8)
    {
        PQclear(res);
        return lo_ntoh64(retval);
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_tell64, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, libpq_append_conn_error(), lo_initialize(), lo_ntoh64(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by pickout().

lo_truncate()

int lo_truncate	(	PGconn *	conn,
		int	fd,
		size_t	len
	)

Definition at line 131 of file fe-lobj.c.

{
    PQArgBlock  argv[2];
    PGresult   *res;
    int         retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    /* Must check this on-the-fly because it's not there pre-8.3 */
    if (conn->lobjfuncs->fn_lo_truncate == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_truncate");
        return -1;
    }
 
    /*
     * Long ago, somebody thought it'd be a good idea to declare this function
     * as taking size_t ... but the underlying backend function only accepts a
     * signed int32 length.  So throw error if the given value overflows
     * int32.  (A possible alternative is to automatically redirect the call
     * to lo_truncate64; but if the caller wanted to rely on that backend
     * function being available, he could have called lo_truncate64 for
     * himself.)
     */
    if (len > (size_t) INT_MAX)
    {
        libpq_append_conn_error(conn, "argument of lo_truncate exceeds integer range");
        return -1;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    argv[1].isint = 1;
    argv[1].len = 4;
    argv[1].u.integer = (int) len;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_truncate,
               &retval, &result_len, 1, argv, 2);
 
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_truncate, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, len, libpq_append_conn_error(), lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

lo_truncate64()

int lo_truncate64	(	PGconn *	conn,
		int	fd,
		int64_t	len
	)

Definition at line 195 of file fe-lobj.c.

{
    PQArgBlock  argv[2];
    PGresult   *res;
    int         retval;
    int         result_len;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    if (conn->lobjfuncs->fn_lo_truncate64 == 0)
    {
        libpq_append_conn_error(conn, "cannot determine OID of function %s",
                                "lo_truncate64");
        return -1;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    len = lo_hton64(len);
    argv[1].isint = 0;
    argv[1].len = 8;
    argv[1].u.ptr = (int *) &len;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_truncate64,
               &retval, &result_len, 1, argv, 2);
 
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, fd(), pgLobjfuncs::fn_lo_truncate64, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, len, libpq_append_conn_error(), lo_hton64(), lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), PQArgBlock::ptr, and PQArgBlock::u.

Referenced by my_truncate().

lo_unlink()

int lo_unlink	(	PGconn *	conn,
		Oid	lobjId
	)

Definition at line 589 of file fe-lobj.c.

{
    PQArgBlock  argv[1];
    PGresult   *res;
    int         result_len;
    int         retval;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = lobjId;
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_unlink,
               &retval, &result_len, 1, argv, 1);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References conn, pgLobjfuncs::fn_lo_unlink, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), and PQArgBlock::u.

Referenced by do_lo_unlink(), and vacuumlo().

lo_write()

int lo_write	(	PGconn *	conn,
		int	fd,
		const char *	buf,
		size_t	len
	)

Definition at line 295 of file fe-lobj.c.

{
    PQArgBlock  argv[2];
    PGresult   *res;
    int         result_len;
    int         retval;
 
    if (lo_initialize(conn) < 0)
        return -1;
 
    /*
     * Long ago, somebody thought it'd be a good idea to declare this function
     * as taking size_t ... but the underlying backend function only accepts a
     * signed int32 length.  So throw error if the given value overflows
     * int32.
     */
    if (len > (size_t) INT_MAX)
    {
        libpq_append_conn_error(conn, "argument of lo_write exceeds integer range");
        return -1;
    }
 
    argv[0].isint = 1;
    argv[0].len = 4;
    argv[0].u.integer = fd;
 
    argv[1].isint = 0;
    argv[1].len = (int) len;
    argv[1].u.ptr = (int *) unconstify(char *, buf);
 
    res = PQfn(conn, conn->lobjfuncs->fn_lo_write,
               &retval, &result_len, 1, argv, 2);
    if (PQresultStatus(res) == PGRES_COMMAND_OK)
    {
        PQclear(res);
        return retval;
    }
    else
    {
        PQclear(res);
        return -1;
    }
}

References buf, conn, fd(), pgLobjfuncs::fn_lo_write, PQArgBlock::integer, PQArgBlock::isint, PQArgBlock::len, len, libpq_append_conn_error(), lo_initialize(), pg_conn::lobjfuncs, PGRES_COMMAND_OK, PQclear(), PQfn(), PQresultStatus(), PQArgBlock::ptr, PQArgBlock::u, and unconstify.

Referenced by lo_import_internal().