static void
overwrite(PGconn *conn, Oid lobjId, int start, int len)
{
int lobj_fd;
char *buf;
int nbytes;
int nwritten;
int i;
lobj_fd = lo_open(conn, lobjId, INV_WRITE);
if (lobj_fd < 0)
fprintf(stderr, "cannot open large object %u", lobjId);
lo_lseek(conn, lobj_fd, start, SEEK_SET);
buf = malloc(len + 1);
for (i = 0; i < len; i++)
buf[i] = 'X';
buf[i] = '\0';
nwritten = 0;
while (len - nwritten > 0)
{
nbytes = lo_write(conn, lobj_fd, buf + nwritten, len - nwritten);
nwritten += nbytes;
if (nbytes <= 0)
{
fprintf(stderr, "\nWRITE FAILED!\n");
break;
}
}
free(buf);
fprintf(stderr, "\n");
lo_close(conn, lobj_fd);
}
Py_ssize_t
lobject_write(lobjectObject *self, const char *buf, size_t len)
{
Py_ssize_t written;
PGresult *pgres = NULL;
char *error = NULL;
Dprintf("lobject_writing: fd = %d, len = %d",
self->fd, len);
Py_BEGIN_ALLOW_THREADS;
pthread_mutex_lock(&(self->conn->lock));
PQsetnonblocking(self->conn->pgconn, 0);
written = lo_write(self->conn->pgconn, self->fd, buf, len);
if (written < 0)
collect_error(self->conn, &error);
PQsetnonblocking(self->conn->pgconn, 1);
pthread_mutex_unlock(&(self->conn->lock));
Py_END_ALLOW_THREADS;
if (written < 0)
pq_complete_error(self->conn, &pgres, &error);
return written;
}
Datum
lowrite(PG_FUNCTION_ARGS)
{
int32 fd = PG_GETARG_INT32(0);
bytea *wbuf = PG_GETARG_BYTEA_P(1);
int bytestowrite;
int totalwritten;
#ifdef PGXC
#ifdef XCP
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Postgres-XL does not yet support large objects"),
errdetail("The feature is not currently supported")));
#else
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Postgres-XC does not support large object yet"),
errdetail("The feature is not currently supported")));
#endif
#endif
bytestowrite = VARSIZE(wbuf) - VARHDRSZ;
totalwritten = lo_write(fd, VARDATA(wbuf), bytestowrite);
PG_RETURN_INT32(totalwritten);
}
Datum
lowrite(PG_FUNCTION_ARGS)
{
int32 fd = PG_GETARG_INT32(0);
bytea *wbuf = PG_GETARG_BYTEA_P(1);
int bytestowrite;
int totalwritten;
bytestowrite = VARSIZE(wbuf) - VARHDRSZ;
totalwritten = lo_write(fd, VARDATA(wbuf), bytestowrite);
PG_RETURN_INT32(totalwritten);
}
Datum
be_lowrite(PG_FUNCTION_ARGS)
{
int32 fd = PG_GETARG_INT32(0);
bytea *wbuf = PG_GETARG_BYTEA_PP(1);
int bytestowrite;
int totalwritten;
bytestowrite = VARSIZE_ANY_EXHDR(wbuf);
totalwritten = lo_write(fd, VARDATA_ANY(wbuf), bytestowrite);
PG_RETURN_INT32(totalwritten);
}
CAMLprim value lo_write_ba_stub(value v_conn, value v_fd,
value v_buf, value v_pos, value v_len)
{
CAMLparam2(v_conn, v_buf);
PGconn *conn = get_conn(v_conn);
value v_res;
size_t len = Long_val(v_len);
char *buf = ((char *) Caml_ba_data_val(v_buf)) + Long_val(v_pos);
caml_enter_blocking_section();
v_res = Val_long(lo_write(conn, Int_val(v_fd), buf, len));
caml_leave_blocking_section();
CAMLreturn(v_res);
}
CAMLprim value lo_write_stub(value v_conn, value v_fd,
value v_buf, value v_pos, value v_len)
{
CAMLparam1(v_conn);
PGconn *conn = get_conn(v_conn);
value v_res;
size_t len = Long_val(v_len);
char *buf = caml_stat_alloc(len);
memcpy(buf, String_val(v_buf) + Long_val(v_pos), len);
caml_enter_blocking_section();
v_res = Val_long(lo_write(conn, Int_val(v_fd), buf, len));
free(buf);
caml_leave_blocking_section();
CAMLreturn(v_res);
}
/* ************************************************************************* */
int pg_lo_write(ClipMachine* mp, SQLCONN* c, int oid_fd, const char *buffer, int length){
PG_CONN *conn = (PG_CONN*)c;
int rt;
if(!conn->at){
_clip_trap_err(mp,0,0,0,subsys,ER_START,er_start);
return 1;
}
rt = lo_write(conn->conn, oid_fd, (char*)buffer, (size_t) length);
if (rt < 0){
_clip_trap_err(mp,0,0,0,subsys,ER_START,er_blob_write);
return 1;
}
_clip_retni(mp,(unsigned int) rt);
return 0;
}
Datum
lowrite(PG_FUNCTION_ARGS)
{
int32 fd = PG_GETARG_INT32(0);
bytea *wbuf = PG_GETARG_BYTEA_P(1);
int bytestowrite;
int totalwritten;
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("large objects are not supported")));
bytestowrite = VARSIZE(wbuf) - VARHDRSZ;
totalwritten = lo_write(fd, VARDATA(wbuf), bytestowrite);
PG_RETURN_INT32(totalwritten);
}
virtual void bind(int col,std::istream &in)
{
check(col);
if(blob_ == bytea_type) {
std::ostringstream ss;
ss << in.rdbuf();
params_values_[col-1]=ss.str();
params_set_[col-1]=binary_param;
}
else {
Oid id = 0;
int fd = -1;
try {
id = lo_creat(conn_, INV_READ|INV_WRITE);
if(id == 0)
throw pqerror(conn_,"failed to create large object");
fd = lo_open(conn_,id,INV_READ | INV_WRITE);
if(fd < 0)
throw pqerror(conn_,"failed to open large object for writing");
char buf[4096];
for(;;) {
in.read(buf,sizeof(buf));
int bytes_read = in.gcount();
if(bytes_read > 0) {
int n = lo_write(conn_,fd,buf,bytes_read);
if(n < 0) {
throw pqerror(conn_,"failed writing to large object");
}
}
if(bytes_read < int(sizeof(buf)))
break;
}
int r = lo_close(conn_,fd);
fd=-1;
if(r < 0)
throw pqerror(conn_,"error closing large object after write");
bind(col,id);
}
catch(...) {
if(fd<-1)
lo_close(conn_,fd);
if(id!=0)
lo_unlink(conn_,id);
throw;
}
}
}
/*
* importFile -
* import file "in_filename" into database as large object "lobjOid"
*
*/
static Oid
importFile(PGconn *conn, char *filename)
{
Oid lobjId;
int lobj_fd;
char buf[BUFSIZE];
int nbytes,
tmp;
int fd;
/*
* open the file to be read in
*/
fd = open(filename, O_RDONLY, 0666);
if (fd < 0)
{ /* error */
fprintf(stderr, "cannot open unix file\"%s\"\n", filename);
}
/*
* create the large object
*/
lobjId = lo_creat(conn, INV_READ | INV_WRITE);
if (lobjId == 0)
fprintf(stderr, "cannot create large object");
lobj_fd = lo_open(conn, lobjId, INV_WRITE);
/*
* read in from the Unix file and write to the inversion file
*/
while ((nbytes = read(fd, buf, BUFSIZE)) > 0)
{
tmp = lo_write(conn, lobj_fd, buf, nbytes);
if (tmp < nbytes)
fprintf(stderr, "error while reading \"%s\"", filename);
}
close(fd);
lo_close(conn, lobj_fd);
return lobjId;
}
/* {{{ pdo_pgsql_create_lob_stream */
static size_t pgsql_lob_write(php_stream *stream, const char *buf, size_t count)
{
struct pdo_pgsql_lob_self *self = (struct pdo_pgsql_lob_self*)stream->abstract;
return lo_write(self->conn, self->lfd, (char*)buf, count);
}
static Oid
lo_import_internal(PGconn *conn, const char *filename, const Oid oid)
{
int fd;
int nbytes,
tmp;
char buf[LO_BUFSIZE];
Oid lobjOid;
int lobj;
char sebuf[256];
/*
* open the file to be read in
*/
fd = open(filename, O_RDONLY | PG_BINARY, 0666);
if (fd < 0)
{ /* error */
printfPQExpBuffer(&conn->errorMessage,
libpq_gettext("could not open file \"%s\": %s\n"),
filename, pqStrerror(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)
{
printfPQExpBuffer(&conn->errorMessage,
libpq_gettext("could not read from file \"%s\": %s\n"),
filename, pqStrerror(errno, sebuf, sizeof(sebuf)));
lobjOid = InvalidOid;
}
(void) close(fd);
if (lo_close(conn, lobj) != 0)
{
/* we assume lo_close() already set a suitable error message */
return InvalidOid;
}
return lobjOid;
}
