1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* fe-lobj.c
|
1997-09-07 07:04:48 +02:00
|
|
|
* Front-end large object interface
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2004-12-31 23:04:05 +01:00
|
|
|
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2006-03-02 22:56:14 +01:00
|
|
|
* $PostgreSQL: pgsql/src/interfaces/libpq/fe-lobj.c,v 1.55 2006/03/02 21:56:14 tgl Exp $
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
1998-08-17 05:50:43 +02:00
|
|
|
|
2004-08-17 04:44:13 +02:00
|
|
|
#ifdef WIN32
|
|
|
|
/*
|
|
|
|
* As unlink/rename are #define'd in port.h (via postgres_fe.h), io.h
|
|
|
|
* must be included first on MS C. Might as well do it for all WIN32's
|
|
|
|
* here.
|
|
|
|
*/
|
|
|
|
#include <io.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "postgres_fe.h"
|
1999-07-19 04:27:16 +02:00
|
|
|
|
1998-07-03 06:24:16 +02:00
|
|
|
#ifdef WIN32
|
|
|
|
#include "win32.h"
|
1999-07-19 08:25:40 +02:00
|
|
|
#else
|
|
|
|
#include <unistd.h>
|
1998-07-03 06:24:16 +02:00
|
|
|
#endif
|
1998-08-17 05:50:43 +02:00
|
|
|
|
2004-08-17 04:44:13 +02:00
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <errno.h>
|
|
|
|
|
2001-09-17 22:05:47 +02:00
|
|
|
#include "libpq-fe.h"
|
|
|
|
#include "libpq-int.h"
|
1998-09-01 06:40:42 +02:00
|
|
|
#include "libpq/libpq-fs.h" /* must come after sys/stat.h */
|
1998-08-17 05:50:43 +02:00
|
|
|
|
2000-10-24 05:15:14 +02:00
|
|
|
#define LO_BUFSIZE 8192
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-08 23:56:23 +02:00
|
|
|
static int lo_initialize(PGconn *conn);
|
1996-11-11 13:16:57 +01:00
|
|
|
|
2001-09-17 22:05:47 +02:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
|
|
|
* lo_open
|
1997-09-07 07:04:48 +02:00
|
|
|
* opens an existing large object
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* returns the file descriptor for use in later lo_* calls
|
|
|
|
* return -1 upon failure.
|
|
|
|
*/
|
|
|
|
int
|
1997-09-08 23:56:23 +02:00
|
|
|
lo_open(PGconn *conn, Oid lobjId, int mode)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int fd;
|
|
|
|
int result_len;
|
|
|
|
PQArgBlock argv[2];
|
|
|
|
PGresult *res;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2004-01-07 19:56:30 +01:00
|
|
|
if (conn->lobjfuncs == NULL)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
|
|
|
if (lo_initialize(conn) < 0)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
1998-10-01 03:40:26 +02:00
|
|
|
{
|
|
|
|
PQclear(res);
|
1997-09-07 07:04:48 +02:00
|
|
|
return -1;
|
1998-10-01 03:40:26 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lo_close
|
1997-09-07 07:04:48 +02:00
|
|
|
* closes an existing large object
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* returns 0 upon success
|
|
|
|
* returns -1 upon failure.
|
|
|
|
*/
|
|
|
|
int
|
1997-09-08 23:56:23 +02:00
|
|
|
lo_close(PGconn *conn, int fd)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
PQArgBlock argv[1];
|
|
|
|
PGresult *res;
|
|
|
|
int retval;
|
|
|
|
int result_len;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2004-01-07 19:56:30 +01:00
|
|
|
if (conn->lobjfuncs == NULL)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
|
|
|
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
|
1998-10-01 03:40:26 +02:00
|
|
|
{
|
|
|
|
PQclear(res);
|
1997-09-07 07:04:48 +02:00
|
|
|
return -1;
|
1998-10-01 03:40:26 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lo_read
|
1997-09-07 07:04:48 +02:00
|
|
|
* read len bytes of the large object into buf
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2001-09-17 22:05:47 +02:00
|
|
|
* returns the number of bytes read, or -1 on failure.
|
1996-07-09 08:22:35 +02:00
|
|
|
* the CALLER must have allocated enough space to hold the result returned
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
In the spirit of TODO item
* Add use of 'const' for varibles in source tree
(which is misspelled, btw.)
I went through the front-end libpq code and did so. This affects in
particular the various accessor functions (such as PQdb() and
PQgetvalue()) as well as, by necessity, the internal helpers they use.
I have been really thorough in that regard, perhaps some people will find
it annoying that things like
char * foo = PQgetvalue(res, 0, 0)
will generate a warning. On the other hand it _should_ generate one. This
is no real compatibility break, although a few clients will have to be
fixed to suppress warnings. (Which again would be in the spirit of the
above TODO.)
In addition I replaced some int's by size_t's and removed some warnings
(and generated some new ones -- grmpf!). Also I rewrote PQoidStatus (so it
actually honors the const!) and supplied a new function PQoidValue that
returns a proper Oid type. This is only front-end stuff, none of the
communicaton stuff was touched.
The psql patch also adds some new consts to honor the new libpq situation,
as well as fixes a fatal condition that resulted when using the -V
(--version) option and there is no database listening.
So, to summarize, the psql you should definitely put in (with or without
the libpq). If you think I went too far with the const-mania in libpq, let
me know and I'll make adjustments. If you approve it, I will also update
the docs.
-Peter
--
Peter Eisentraut Sernanders vaeg 10:115
1999-11-11 01:10:14 +01:00
|
|
|
lo_read(PGconn *conn, int fd, char *buf, size_t len)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
PQArgBlock argv[2];
|
|
|
|
PGresult *res;
|
|
|
|
int result_len;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2004-01-07 19:56:30 +01:00
|
|
|
if (conn->lobjfuncs == NULL)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
|
|
|
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 = len;
|
|
|
|
|
|
|
|
res = PQfn(conn, conn->lobjfuncs->fn_lo_read,
|
|
|
|
(int *) buf, &result_len, 0, argv, 2);
|
|
|
|
if (PQresultStatus(res) == PGRES_COMMAND_OK)
|
|
|
|
{
|
|
|
|
PQclear(res);
|
|
|
|
return result_len;
|
|
|
|
}
|
|
|
|
else
|
1998-10-01 03:40:26 +02:00
|
|
|
{
|
|
|
|
PQclear(res);
|
1997-09-07 07:04:48 +02:00
|
|
|
return -1;
|
1998-10-01 03:40:26 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lo_write
|
1997-09-07 07:04:48 +02:00
|
|
|
* write len bytes of buf into the large object fd
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2001-09-17 22:05:47 +02:00
|
|
|
* returns the number of bytes written, or -1 on failure.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
int
|
2000-02-08 00:10:11 +01:00
|
|
|
lo_write(PGconn *conn, int fd, char *buf, size_t len)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
PQArgBlock argv[2];
|
|
|
|
PGresult *res;
|
|
|
|
int result_len;
|
|
|
|
int retval;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2004-01-07 19:56:30 +01:00
|
|
|
if (conn->lobjfuncs == NULL)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
|
|
|
if (lo_initialize(conn) < 0)
|
|
|
|
return -1;
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (len <= 0)
|
|
|
|
return 0;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
argv[0].isint = 1;
|
|
|
|
argv[0].len = 4;
|
|
|
|
argv[0].u.integer = fd;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
argv[1].isint = 0;
|
|
|
|
argv[1].len = len;
|
|
|
|
argv[1].u.ptr = (int *) 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
|
1998-10-01 03:40:26 +02:00
|
|
|
{
|
|
|
|
PQclear(res);
|
1997-09-07 07:04:48 +02:00
|
|
|
return -1;
|
1998-10-01 03:40:26 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lo_lseek
|
1997-09-07 07:04:48 +02:00
|
|
|
* change the current read or write location on a large object
|
1996-07-09 08:22:35 +02:00
|
|
|
* currently, only L_SET is a legal value for whence
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
1997-09-08 23:56:23 +02:00
|
|
|
lo_lseek(PGconn *conn, int fd, int offset, int whence)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
PQArgBlock argv[3];
|
|
|
|
PGresult *res;
|
|
|
|
int retval;
|
|
|
|
int result_len;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2004-01-07 19:56:30 +01:00
|
|
|
if (conn->lobjfuncs == NULL)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
|
|
|
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
|
1998-10-01 03:40:26 +02:00
|
|
|
{
|
|
|
|
PQclear(res);
|
1997-09-07 07:04:48 +02:00
|
|
|
return -1;
|
1998-10-01 03:40:26 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lo_creat
|
1997-09-07 07:04:48 +02:00
|
|
|
* create a new large object
|
2005-06-13 04:26:53 +02:00
|
|
|
* the mode is ignored (once upon a time it had a use)
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* returns the oid of the large object created or
|
|
|
|
* InvalidOid upon failure
|
|
|
|
*/
|
|
|
|
Oid
|
1997-09-08 23:56:23 +02:00
|
|
|
lo_creat(PGconn *conn, int mode)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
PQArgBlock argv[1];
|
|
|
|
PGresult *res;
|
|
|
|
int retval;
|
|
|
|
int result_len;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2004-01-07 19:56:30 +01:00
|
|
|
if (conn->lobjfuncs == NULL)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
|
|
|
if (lo_initialize(conn) < 0)
|
2001-09-17 22:05:47 +02:00
|
|
|
return InvalidOid;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
1998-10-01 03:40:26 +02:00
|
|
|
{
|
|
|
|
PQclear(res);
|
1997-09-07 07:04:48 +02:00
|
|
|
return InvalidOid;
|
1998-10-01 03:40:26 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2005-06-13 04:26:53 +02:00
|
|
|
/*
|
|
|
|
* lo_create
|
|
|
|
* create a new large object
|
|
|
|
* if lobjId isn't InvalidOid, it specifies the OID to (attempt to) create
|
|
|
|
*
|
|
|
|
* returns the oid of the large object created or
|
|
|
|
* InvalidOid upon failure
|
|
|
|
*/
|
|
|
|
Oid
|
|
|
|
lo_create(PGconn *conn, Oid lobjId)
|
|
|
|
{
|
|
|
|
PQArgBlock argv[1];
|
|
|
|
PGresult *res;
|
|
|
|
int retval;
|
|
|
|
int result_len;
|
|
|
|
|
|
|
|
if (conn->lobjfuncs == NULL)
|
|
|
|
{
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("cannot determine OID of function lo_create\n"));
|
2005-06-13 04:26:53 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* lo_tell
|
1997-09-07 07:04:48 +02:00
|
|
|
* returns the current seek location of the large object
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
1997-09-08 23:56:23 +02:00
|
|
|
lo_tell(PGconn *conn, int fd)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int retval;
|
|
|
|
PQArgBlock argv[1];
|
|
|
|
PGresult *res;
|
|
|
|
int result_len;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2004-01-07 19:56:30 +01:00
|
|
|
if (conn->lobjfuncs == NULL)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
|
|
|
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
|
1998-10-01 03:40:26 +02:00
|
|
|
{
|
|
|
|
PQclear(res);
|
1997-09-07 07:04:48 +02:00
|
|
|
return -1;
|
1998-10-01 03:40:26 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lo_unlink
|
1997-09-07 07:04:48 +02:00
|
|
|
* delete a file
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
1997-09-08 23:56:23 +02:00
|
|
|
lo_unlink(PGconn *conn, Oid lobjId)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
PQArgBlock argv[1];
|
|
|
|
PGresult *res;
|
|
|
|
int result_len;
|
|
|
|
int retval;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2004-01-07 19:56:30 +01:00
|
|
|
if (conn->lobjfuncs == NULL)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
|
|
|
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
|
1998-10-01 03:40:26 +02:00
|
|
|
{
|
|
|
|
PQclear(res);
|
1997-09-07 07:04:48 +02:00
|
|
|
return -1;
|
1998-10-01 03:40:26 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lo_import -
|
1997-09-07 07:04:48 +02:00
|
|
|
* imports a file as an (inversion) large object.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2001-09-17 22:05:47 +02:00
|
|
|
* returns the oid of that object upon success,
|
|
|
|
* returns InvalidOid upon failure
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
Oid
|
In the spirit of TODO item
* Add use of 'const' for varibles in source tree
(which is misspelled, btw.)
I went through the front-end libpq code and did so. This affects in
particular the various accessor functions (such as PQdb() and
PQgetvalue()) as well as, by necessity, the internal helpers they use.
I have been really thorough in that regard, perhaps some people will find
it annoying that things like
char * foo = PQgetvalue(res, 0, 0)
will generate a warning. On the other hand it _should_ generate one. This
is no real compatibility break, although a few clients will have to be
fixed to suppress warnings. (Which again would be in the spirit of the
above TODO.)
In addition I replaced some int's by size_t's and removed some warnings
(and generated some new ones -- grmpf!). Also I rewrote PQoidStatus (so it
actually honors the const!) and supplied a new function PQoidValue that
returns a proper Oid type. This is only front-end stuff, none of the
communicaton stuff was touched.
The psql patch also adds some new consts to honor the new libpq situation,
as well as fixes a fatal condition that resulted when using the -V
(--version) option and there is no database listening.
So, to summarize, the psql you should definitely put in (with or without
the libpq). If you think I went too far with the const-mania in libpq, let
me know and I'll make adjustments. If you approve it, I will also update
the docs.
-Peter
--
Peter Eisentraut Sernanders vaeg 10:115
1999-11-11 01:10:14 +01:00
|
|
|
lo_import(PGconn *conn, const char *filename)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int fd;
|
|
|
|
int nbytes,
|
|
|
|
tmp;
|
|
|
|
char buf[LO_BUFSIZE];
|
|
|
|
Oid lobjOid;
|
|
|
|
int lobj;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* open the file to be read in
|
|
|
|
*/
|
2000-06-02 17:57:44 +02:00
|
|
|
fd = open(filename, O_RDONLY | PG_BINARY, 0666);
|
1997-09-07 07:04:48 +02:00
|
|
|
if (fd < 0)
|
|
|
|
{ /* error */
|
2003-08-04 02:43:34 +02:00
|
|
|
char sebuf[256];
|
|
|
|
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("could not open file \"%s\": %s\n"),
|
|
|
|
filename, pqStrerror(errno, sebuf, sizeof(sebuf)));
|
1997-09-07 07:04:48 +02:00
|
|
|
return InvalidOid;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* create an inversion "object"
|
|
|
|
*/
|
|
|
|
lobjOid = lo_creat(conn, INV_READ | INV_WRITE);
|
|
|
|
if (lobjOid == InvalidOid)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("could not create large object for file \"%s\"\n"),
|
1999-08-31 03:37:37 +02:00
|
|
|
filename);
|
2001-09-17 22:05:47 +02:00
|
|
|
(void) close(fd);
|
1997-09-07 07:04:48 +02:00
|
|
|
return InvalidOid;
|
|
|
|
}
|
|
|
|
|
|
|
|
lobj = lo_open(conn, lobjOid, INV_WRITE);
|
|
|
|
if (lobj == -1)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("could not open large object %u\n"),
|
1999-08-31 03:37:37 +02:00
|
|
|
lobjOid);
|
2001-09-17 22:05:47 +02:00
|
|
|
(void) close(fd);
|
1997-09-07 07:04:48 +02:00
|
|
|
return InvalidOid;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* read in from the Unix file and write to the inversion file
|
|
|
|
*/
|
|
|
|
while ((nbytes = read(fd, buf, LO_BUFSIZE)) > 0)
|
|
|
|
{
|
|
|
|
tmp = lo_write(conn, lobj, buf, nbytes);
|
|
|
|
if (tmp < nbytes)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("error while reading file \"%s\"\n"),
|
1999-08-31 03:37:37 +02:00
|
|
|
filename);
|
2001-09-17 22:05:47 +02:00
|
|
|
(void) close(fd);
|
|
|
|
(void) lo_close(conn, lobj);
|
1997-09-07 07:04:48 +02:00
|
|
|
return InvalidOid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
(void) close(fd);
|
|
|
|
(void) lo_close(conn, lobj);
|
|
|
|
|
|
|
|
return lobjOid;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lo_export -
|
1997-09-07 07:04:48 +02:00
|
|
|
* exports an (inversion) large object.
|
1996-07-09 08:22:35 +02:00
|
|
|
* returns -1 upon failure, 1 otherwise
|
|
|
|
*/
|
|
|
|
int
|
In the spirit of TODO item
* Add use of 'const' for varibles in source tree
(which is misspelled, btw.)
I went through the front-end libpq code and did so. This affects in
particular the various accessor functions (such as PQdb() and
PQgetvalue()) as well as, by necessity, the internal helpers they use.
I have been really thorough in that regard, perhaps some people will find
it annoying that things like
char * foo = PQgetvalue(res, 0, 0)
will generate a warning. On the other hand it _should_ generate one. This
is no real compatibility break, although a few clients will have to be
fixed to suppress warnings. (Which again would be in the spirit of the
above TODO.)
In addition I replaced some int's by size_t's and removed some warnings
(and generated some new ones -- grmpf!). Also I rewrote PQoidStatus (so it
actually honors the const!) and supplied a new function PQoidValue that
returns a proper Oid type. This is only front-end stuff, none of the
communicaton stuff was touched.
The psql patch also adds some new consts to honor the new libpq situation,
as well as fixes a fatal condition that resulted when using the -V
(--version) option and there is no database listening.
So, to summarize, the psql you should definitely put in (with or without
the libpq). If you think I went too far with the const-mania in libpq, let
me know and I'll make adjustments. If you approve it, I will also update
the docs.
-Peter
--
Peter Eisentraut Sernanders vaeg 10:115
1999-11-11 01:10:14 +01:00
|
|
|
lo_export(PGconn *conn, Oid lobjId, const char *filename)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int fd;
|
|
|
|
int nbytes,
|
|
|
|
tmp;
|
|
|
|
char buf[LO_BUFSIZE];
|
|
|
|
int lobj;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*
|
2001-09-17 22:05:47 +02:00
|
|
|
* open the large object.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
lobj = lo_open(conn, lobjId, INV_READ);
|
|
|
|
if (lobj == -1)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("could not open large object %u\n"), lobjId);
|
1997-09-07 07:04:48 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2001-09-17 22:05:47 +02:00
|
|
|
* create the file to be written to
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2000-06-02 17:57:44 +02:00
|
|
|
fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY, 0666);
|
1997-09-07 07:04:48 +02:00
|
|
|
if (fd < 0)
|
|
|
|
{ /* error */
|
2003-08-04 02:43:34 +02:00
|
|
|
char sebuf[256];
|
|
|
|
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("could not open file \"%s\": %s\n"),
|
|
|
|
filename, pqStrerror(errno, sebuf, sizeof(sebuf)));
|
2001-09-17 22:05:47 +02:00
|
|
|
(void) lo_close(conn, lobj);
|
|
|
|
return -1;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/*
|
2004-01-26 23:35:32 +01:00
|
|
|
* read in from the inversion file and write to the Unix file
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
while ((nbytes = lo_read(conn, lobj, buf, LO_BUFSIZE)) > 0)
|
|
|
|
{
|
|
|
|
tmp = write(fd, buf, nbytes);
|
|
|
|
if (tmp < nbytes)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("error while writing to file \"%s\"\n"),
|
1999-08-31 03:37:37 +02:00
|
|
|
filename);
|
2001-09-17 22:05:47 +02:00
|
|
|
(void) lo_close(conn, lobj);
|
|
|
|
(void) close(fd);
|
1997-09-07 07:04:48 +02:00
|
|
|
return -1;
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
(void) lo_close(conn, lobj);
|
2004-01-26 23:35:32 +01:00
|
|
|
|
|
|
|
if (close(fd))
|
|
|
|
{
|
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("error while writing to file \"%s\"\n"),
|
2004-01-26 23:35:32 +01:00
|
|
|
filename);
|
|
|
|
return -1;
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
return 1;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1996-11-11 13:16:57 +01:00
|
|
|
|
|
|
|
|
2001-08-17 17:11:15 +02:00
|
|
|
/*
|
1996-11-11 13:16:57 +01:00
|
|
|
* lo_initialize
|
|
|
|
*
|
|
|
|
* Initialize the large object interface for an existing connection.
|
|
|
|
* We ask the backend about the functions OID's in pg_proc for all
|
|
|
|
* functions that are required for large object operations.
|
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
static int
|
1997-09-08 23:56:23 +02:00
|
|
|
lo_initialize(PGconn *conn)
|
1996-11-11 13:16:57 +01:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
PGresult *res;
|
|
|
|
PGlobjfuncs *lobjfuncs;
|
|
|
|
int n;
|
2004-03-05 02:53:59 +01:00
|
|
|
const char *query;
|
2000-04-12 19:17:23 +02:00
|
|
|
const char *fname;
|
1997-09-08 04:41:22 +02:00
|
|
|
Oid foid;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Allocate the structure to hold the functions OID's
|
|
|
|
*/
|
|
|
|
lobjfuncs = (PGlobjfuncs *) malloc(sizeof(PGlobjfuncs));
|
2004-01-07 19:56:30 +01:00
|
|
|
if (lobjfuncs == NULL)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2001-07-15 15:45:04 +02:00
|
|
|
libpq_gettext("out of memory\n"));
|
1997-09-07 07:04:48 +02:00
|
|
|
return -1;
|
|
|
|
}
|
1997-09-18 22:22:58 +02:00
|
|
|
MemSet((char *) lobjfuncs, 0, sizeof(PGlobjfuncs));
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Execute the query to get all the functions at once. In 7.3 and later
|
|
|
|
* we need to be schema-safe. lo_create only exists in 8.1 and up.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2004-03-05 02:53:59 +01:00
|
|
|
if (conn->sversion >= 70300)
|
|
|
|
query = "select proname, oid from pg_catalog.pg_proc "
|
|
|
|
"where proname in ("
|
|
|
|
"'lo_open', "
|
|
|
|
"'lo_close', "
|
|
|
|
"'lo_creat', "
|
2005-06-13 04:26:53 +02:00
|
|
|
"'lo_create', "
|
2004-03-05 02:53:59 +01:00
|
|
|
"'lo_unlink', "
|
|
|
|
"'lo_lseek', "
|
|
|
|
"'lo_tell', "
|
|
|
|
"'loread', "
|
|
|
|
"'lowrite') "
|
|
|
|
"and pronamespace = (select oid from pg_catalog.pg_namespace "
|
|
|
|
"where nspname = 'pg_catalog')";
|
|
|
|
else
|
|
|
|
query = "select proname, oid from pg_proc "
|
|
|
|
"where proname = 'lo_open' "
|
|
|
|
"or proname = 'lo_close' "
|
|
|
|
"or proname = 'lo_creat' "
|
|
|
|
"or proname = 'lo_unlink' "
|
|
|
|
"or proname = 'lo_lseek' "
|
|
|
|
"or proname = 'lo_tell' "
|
|
|
|
"or proname = 'loread' "
|
|
|
|
"or proname = 'lowrite'";
|
|
|
|
|
|
|
|
res = PQexec(conn, query);
|
2004-01-07 19:56:30 +01:00
|
|
|
if (res == NULL)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
|
|
|
free(lobjfuncs);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (res->resultStatus != PGRES_TUPLES_OK)
|
|
|
|
{
|
|
|
|
free(lobjfuncs);
|
|
|
|
PQclear(res);
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2001-07-15 15:45:04 +02:00
|
|
|
libpq_gettext("query to initialize large object functions did not return data\n"));
|
1997-09-07 07:04:48 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* 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"))
|
|
|
|
lobjfuncs->fn_lo_open = foid;
|
|
|
|
else if (!strcmp(fname, "lo_close"))
|
|
|
|
lobjfuncs->fn_lo_close = foid;
|
|
|
|
else if (!strcmp(fname, "lo_creat"))
|
|
|
|
lobjfuncs->fn_lo_creat = foid;
|
2005-06-13 04:26:53 +02:00
|
|
|
else if (!strcmp(fname, "lo_create"))
|
|
|
|
lobjfuncs->fn_lo_create = foid;
|
1997-09-07 07:04:48 +02:00
|
|
|
else if (!strcmp(fname, "lo_unlink"))
|
|
|
|
lobjfuncs->fn_lo_unlink = foid;
|
|
|
|
else if (!strcmp(fname, "lo_lseek"))
|
|
|
|
lobjfuncs->fn_lo_lseek = foid;
|
|
|
|
else if (!strcmp(fname, "lo_tell"))
|
|
|
|
lobjfuncs->fn_lo_tell = foid;
|
|
|
|
else if (!strcmp(fname, "loread"))
|
|
|
|
lobjfuncs->fn_lo_read = foid;
|
|
|
|
else if (!strcmp(fname, "lowrite"))
|
|
|
|
lobjfuncs->fn_lo_write = foid;
|
|
|
|
}
|
1996-11-11 13:16:57 +01:00
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Finally check that we really got all large object interface functions
|
|
|
|
* --- except lo_create, which may not exist.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
if (lobjfuncs->fn_lo_open == 0)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("cannot determine OID of function lo_open\n"));
|
1997-09-07 07:04:48 +02:00
|
|
|
free(lobjfuncs);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (lobjfuncs->fn_lo_close == 0)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("cannot determine OID of function lo_close\n"));
|
1997-09-07 07:04:48 +02:00
|
|
|
free(lobjfuncs);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (lobjfuncs->fn_lo_creat == 0)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("cannot determine OID of function lo_creat\n"));
|
1997-09-07 07:04:48 +02:00
|
|
|
free(lobjfuncs);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (lobjfuncs->fn_lo_unlink == 0)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("cannot determine OID of function lo_unlink\n"));
|
1997-09-07 07:04:48 +02:00
|
|
|
free(lobjfuncs);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (lobjfuncs->fn_lo_lseek == 0)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("cannot determine OID of function lo_lseek\n"));
|
1997-09-07 07:04:48 +02:00
|
|
|
free(lobjfuncs);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (lobjfuncs->fn_lo_tell == 0)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("cannot determine OID of function lo_tell\n"));
|
1997-09-07 07:04:48 +02:00
|
|
|
free(lobjfuncs);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (lobjfuncs->fn_lo_read == 0)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("cannot determine OID of function loread\n"));
|
1997-09-07 07:04:48 +02:00
|
|
|
free(lobjfuncs);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (lobjfuncs->fn_lo_write == 0)
|
|
|
|
{
|
1999-08-31 03:37:37 +02:00
|
|
|
printfPQExpBuffer(&conn->errorMessage,
|
2005-10-15 04:49:52 +02:00
|
|
|
libpq_gettext("cannot determine OID of function lowrite\n"));
|
1997-09-07 07:04:48 +02:00
|
|
|
free(lobjfuncs);
|
|
|
|
return -1;
|
|
|
|
}
|
1996-11-11 13:16:57 +01:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Put the structure into the connection control
|
|
|
|
*/
|
|
|
|
conn->lobjfuncs = lobjfuncs;
|
|
|
|
return 0;
|
|
|
|
}
|