database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-11-10 17:42:29 +03:00
Code Activity

Massive commit to run PGINDENT on all *.c and *.h files.

Browse Source
This commit is contained in:
Bruce Momjian
1997-09-07 05:04:48 +00:00
parent 8fecd4febf
commit 1ccd423235
687 changed files with 150775 additions and 136888 deletions
Download Patch File Download Diff File Expand all files Collapse all files

462
src/backend/libpq/be-fsstubs.c
View File

@@ -1,24 +1,24 @@
/*-------------------------------------------------------------------------
*
* be-fsstubs.c--
* support for filesystem operations on large objects
* support for filesystem operations on large objects
*
* Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/libpq/be-fsstubs.c,v 1.12 1997/08/12 22:52:48 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/libpq/be-fsstubs.c,v 1.13 1997/09/07 04:42:15 momjian Exp $
*
* NOTES
* This should be moved to a more appropriate place. It is here
* for lack of a better place.
* This should be moved to a more appropriate place. It is here
* for lack of a better place.
*
* Builtin functions for open/close/read/write operations on large objects.
* Builtin functions for open/close/read/write operations on large objects.
*
* These functions operate in the current portal variable context, which
* means the large object descriptors hang around between transactions and
* are not deallocated until explicitly closed, or until the portal is
* closed.
* These functions operate in the current portal variable context, which
* means the large object descriptors hang around between transactions and
* are not deallocated until explicitly closed, or until the portal is
* closed.
*-------------------------------------------------------------------------
*/
@@ -37,340 +37,364 @@
#include <utils/memutils.h>
#include <lib/fstack.h>
#include <utils/mcxt.h>
#include <storage/fd.h> /* for O_ */
#include <storage/fd.h> /* for O_ */
#include <storage/large_object.h>
#include <libpq/be-fsstubs.h>
/*#define FSDB 1*/
#define MAX_LOBJ_FDS 256
static LargeObjectDesc *cookies[MAX_LOBJ_FDS];
static LargeObjectDesc *cookies[MAX_LOBJ_FDS];
static GlobalMemory fscxt = NULL;
static int newLOfd(LargeObjectDesc *lobjCookie);
static void deleteLOfd(int fd);
static int newLOfd(LargeObjectDesc * lobjCookie);
static void deleteLOfd(int fd);
/*****************************************************************************
* File Interfaces for Large Objects
* File Interfaces for Large Objects
*****************************************************************************/
int
lo_open(Oid lobjId, int mode)
{
LargeObjectDesc *lobjDesc;
int fd;
MemoryContext currentContext;
LargeObjectDesc *lobjDesc;
int fd;
MemoryContext currentContext;
#if FSDB
elog(NOTICE,"LOopen(%d,%d)",lobjId,mode);
elog(NOTICE, "LOopen(%d,%d)", lobjId, mode);
#endif
if (fscxt == NULL) {
fscxt = CreateGlobalMemory("Filesystem");
}
currentContext = MemoryContextSwitchTo((MemoryContext)fscxt);
if (fscxt == NULL)
{
fscxt = CreateGlobalMemory("Filesystem");
}
currentContext = MemoryContextSwitchTo((MemoryContext) fscxt);
lobjDesc = inv_open(lobjId, mode);
if (lobjDesc == NULL) { /* lookup failed */
lobjDesc = inv_open(lobjId, mode);
if (lobjDesc == NULL)
{ /* lookup failed */
MemoryContextSwitchTo(currentContext);
#if FSDB
elog(NOTICE, "cannot open large object %d", lobjId);
#endif
return -1;
}
fd = newLOfd(lobjDesc);
/* switch context back to orig. */
MemoryContextSwitchTo(currentContext);
#if FSDB
elog(NOTICE,"cannot open large object %d", lobjId);
#endif
return -1;
}
fd = newLOfd(lobjDesc);
/* switch context back to orig. */
MemoryContextSwitchTo(currentContext);
return fd;
return fd;
}
int
lo_close(int fd)
{
MemoryContext currentContext;
MemoryContext currentContext;
if (fd >= MAX_LOBJ_FDS) {
elog(WARN,"lo_close: large obj descriptor (%d) out of range", fd);
return -2;
}
if (cookies[fd] == NULL) {
elog(WARN,"lo_close: invalid large obj descriptor (%d)", fd);
return -3;
}
if (fd >= MAX_LOBJ_FDS)
{
elog(WARN, "lo_close: large obj descriptor (%d) out of range", fd);
return -2;
}
if (cookies[fd] == NULL)
{
elog(WARN, "lo_close: invalid large obj descriptor (%d)", fd);
return -3;
}
#if FSDB
elog(NOTICE,"LOclose(%d)",fd);
elog(NOTICE, "LOclose(%d)", fd);
#endif
Assert(fscxt != NULL);
currentContext = MemoryContextSwitchTo((MemoryContext)fscxt);
Assert(fscxt != NULL);
currentContext = MemoryContextSwitchTo((MemoryContext) fscxt);
inv_close(cookies[fd]);
inv_close(cookies[fd]);
MemoryContextSwitchTo(currentContext);
MemoryContextSwitchTo(currentContext);
deleteLOfd(fd);
return 0;
deleteLOfd(fd);
return 0;
}
/*
* We assume the large object supports byte oriented reads and seeks so
* that our work is easier.
* We assume the large object supports byte oriented reads and seeks so
* that our work is easier.
*/
int
lo_read(int fd, char *buf, int len)
{
Assert(cookies[fd]!=NULL);
return inv_read(cookies[fd], buf, len);
Assert(cookies[fd] != NULL);
return inv_read(cookies[fd], buf, len);
}
int
lo_write(int fd, char *buf, int len)
{
Assert(cookies[fd]!=NULL);
return inv_write(cookies[fd], buf, len);
Assert(cookies[fd] != NULL);
return inv_write(cookies[fd], buf, len);
}
int
lo_lseek(int fd, int offset, int whence)
{
MemoryContext currentContext;
int ret;
MemoryContext currentContext;
int ret;
if (fd >= MAX_LOBJ_FDS) {
elog(WARN,"lo_seek: large obj descriptor (%d) out of range", fd);
return -2;
}
if (fd >= MAX_LOBJ_FDS)
{
elog(WARN, "lo_seek: large obj descriptor (%d) out of range", fd);
return -2;
}
currentContext = MemoryContextSwitchTo((MemoryContext)fscxt);
currentContext = MemoryContextSwitchTo((MemoryContext) fscxt);
ret = inv_seek(cookies[fd], offset, whence);
ret = inv_seek(cookies[fd], offset, whence);
MemoryContextSwitchTo(currentContext);
MemoryContextSwitchTo(currentContext);
return ret;
return ret;
}
Oid
lo_creat(int mode)
{
LargeObjectDesc *lobjDesc;
MemoryContext currentContext;
Oid lobjId;
if (fscxt == NULL) {
fscxt = CreateGlobalMemory("Filesystem");
}
currentContext = MemoryContextSwitchTo((MemoryContext)fscxt);
lobjDesc = inv_create(mode);
if (lobjDesc == NULL) {
MemoryContextSwitchTo(currentContext);
return InvalidOid;
}
LargeObjectDesc *lobjDesc;
MemoryContext currentContext;
Oid lobjId;
lobjId = lobjDesc->heap_r->rd_id;
inv_close(lobjDesc);
/* switch context back to original memory context */
MemoryContextSwitchTo(currentContext);
return lobjId;
if (fscxt == NULL)
{
fscxt = CreateGlobalMemory("Filesystem");
}
currentContext = MemoryContextSwitchTo((MemoryContext) fscxt);
lobjDesc = inv_create(mode);
if (lobjDesc == NULL)
{
MemoryContextSwitchTo(currentContext);
return InvalidOid;
}
lobjId = lobjDesc->heap_r->rd_id;
inv_close(lobjDesc);
/* switch context back to original memory context */
MemoryContextSwitchTo(currentContext);
return lobjId;
}
int
lo_tell(int fd)
{
if (fd >= MAX_LOBJ_FDS) {
elog(WARN,"lo_tell: large object descriptor (%d) out of range",fd);
return -2;
}
if (cookies[fd] == NULL) {
elog(WARN,"lo_tell: invalid large object descriptor (%d)",fd);
return -3;
}
return inv_tell(cookies[fd]);
if (fd >= MAX_LOBJ_FDS)
{
elog(WARN, "lo_tell: large object descriptor (%d) out of range", fd);
return -2;
}
if (cookies[fd] == NULL)
{
elog(WARN, "lo_tell: invalid large object descriptor (%d)", fd);
return -3;
}
return inv_tell(cookies[fd]);
}
int
lo_unlink(Oid lobjId)
{
return (inv_destroy(lobjId));
return (inv_destroy(lobjId));
}
/*****************************************************************************
* Read/Write using varlena
* Read/Write using varlena
*****************************************************************************/
struct varlena *
loread(int fd, int len)
{
struct varlena *retval;
int totalread = 0;
retval = (struct varlena *)palloc(sizeof(int32) + len);
totalread = lo_read(fd, VARDATA(retval), len);
VARSIZE(retval) = totalread + sizeof(int32);
return retval;
struct varlena *retval;
int totalread = 0;
retval = (struct varlena *) palloc(sizeof(int32) + len);
totalread = lo_read(fd, VARDATA(retval), len);
VARSIZE(retval) = totalread + sizeof(int32);
return retval;
}
int lowrite(int fd, struct varlena *wbuf)
int
lowrite(int fd, struct varlena * wbuf)
{
int totalwritten;
int bytestowrite;
bytestowrite = VARSIZE(wbuf) - sizeof(int32);
totalwritten = lo_write(fd, VARDATA(wbuf), bytestowrite);
return totalwritten;
int totalwritten;
int bytestowrite;
bytestowrite = VARSIZE(wbuf) - sizeof(int32);
totalwritten = lo_write(fd, VARDATA(wbuf), bytestowrite);
return totalwritten;
}
/*****************************************************************************
* Import/Export of Large Object
* Import/Export of Large Object
*****************************************************************************/
/*
* lo_import -
* imports a file as an (inversion) large object.
* imports a file as an (inversion) large object.
*/
Oid
lo_import(text *filename)
lo_import(text * filename)
{
int fd;
int nbytes, tmp;
#define BUFSIZE 1024
char buf[BUFSIZE];
char fnamebuf[8192];
LargeObjectDesc *lobj;
Oid lobjOid;
int fd;
int nbytes,
tmp;
/*
* open the file to be read in
*/
strNcpy(fnamebuf, VARDATA(filename), VARSIZE(filename) - VARHDRSZ);
fd = open(fnamebuf, O_RDONLY, 0666);
if (fd < 0) { /* error */
elog(WARN, "be_lo_import: can't open unix file\"%s\"\n",
fnamebuf);
}
#define BUFSIZE 1024
char buf[BUFSIZE];
char fnamebuf[8192];
LargeObjectDesc *lobj;
Oid lobjOid;
/*
* create an inversion "object"
*/
lobj = inv_create(INV_READ|INV_WRITE);
if (lobj == NULL) {
elog(WARN, "lo_import: can't create inv object for \"%s\"",
fnamebuf);
}
/*
* the oid for the large object is just the oid of the relation
* XInv??? which contains the data.
*/
lobjOid = lobj->heap_r->rd_id;
/*
* read in from the Unix file and write to the inversion file
*/
while ((nbytes = read(fd, buf, BUFSIZE)) > 0) {
tmp = inv_write(lobj, buf, nbytes);
if (tmp < nbytes) {
elog(WARN, "lo_import: error while reading \"%s\"",
fnamebuf);
/*
* open the file to be read in
*/
strNcpy(fnamebuf, VARDATA(filename), VARSIZE(filename) - VARHDRSZ);
fd = open(fnamebuf, O_RDONLY, 0666);
if (fd < 0)
{ /* error */
elog(WARN, "be_lo_import: can't open unix file\"%s\"\n",
fnamebuf);
}
}
close(fd);
inv_close(lobj);
/*
* create an inversion "object"
*/
lobj = inv_create(INV_READ | INV_WRITE);
if (lobj == NULL)
{
elog(WARN, "lo_import: can't create inv object for \"%s\"",
fnamebuf);
}
return lobjOid;
/*
* the oid for the large object is just the oid of the relation
* XInv??? which contains the data.
*/
lobjOid = lobj->heap_r->rd_id;
/*
* read in from the Unix file and write to the inversion file
*/
while ((nbytes = read(fd, buf, BUFSIZE)) > 0)
{
tmp = inv_write(lobj, buf, nbytes);
if (tmp < nbytes)
{
elog(WARN, "lo_import: error while reading \"%s\"",
fnamebuf);
}
}
close(fd);
inv_close(lobj);
return lobjOid;
}
/*
* lo_export -
* exports an (inversion) large object.
* exports an (inversion) large object.
*/
int4
lo_export(Oid lobjId, text *filename)
lo_export(Oid lobjId, text * filename)
{
int fd;
int nbytes, tmp;
#define BUFSIZE 1024
char buf[BUFSIZE];
char fnamebuf[8192];
LargeObjectDesc *lobj;
mode_t oumask;
int fd;
int nbytes,
tmp;
/*
* create an inversion "object"
*/
lobj = inv_open(lobjId, INV_READ);
if (lobj == NULL) {
elog(WARN, "lo_export: can't open inv object %d",
lobjId);
}
#define BUFSIZE 1024
char buf[BUFSIZE];
char fnamebuf[8192];
LargeObjectDesc *lobj;
mode_t oumask;
/*
* open the file to be written to
*/
oumask = umask((mode_t) 0);
strNcpy(fnamebuf, VARDATA(filename), VARSIZE(filename) - VARHDRSZ);
fd = open(fnamebuf, O_CREAT|O_WRONLY, 0666);
umask(oumask);
if (fd < 0) { /* error */
elog(WARN, "lo_export: can't open unix file\"%s\"",
fnamebuf);
}
/*
* read in from the Unix file and write to the inversion file
*/
while ((nbytes = inv_read(lobj, buf, BUFSIZE)) > 0) {
tmp = write(fd, buf, nbytes);
if (tmp < nbytes) {
elog(WARN, "lo_export: error while writing \"%s\"",
fnamebuf);
/*
* create an inversion "object"
*/
lobj = inv_open(lobjId, INV_READ);
if (lobj == NULL)
{
elog(WARN, "lo_export: can't open inv object %d",
lobjId);
}
}
inv_close(lobj);
close(fd);
/*
* open the file to be written to
*/
oumask = umask((mode_t) 0);
strNcpy(fnamebuf, VARDATA(filename), VARSIZE(filename) - VARHDRSZ);
fd = open(fnamebuf, O_CREAT | O_WRONLY, 0666);
umask(oumask);
if (fd < 0)
{ /* error */
elog(WARN, "lo_export: can't open unix file\"%s\"",
fnamebuf);
}
return 1;
/*
* read in from the Unix file and write to the inversion file
*/
while ((nbytes = inv_read(lobj, buf, BUFSIZE)) > 0)
{
tmp = write(fd, buf, nbytes);
if (tmp < nbytes)
{
elog(WARN, "lo_export: error while writing \"%s\"",
fnamebuf);
}
}
inv_close(lobj);
close(fd);
return 1;
}
/*****************************************************************************
* Support routines for this file
* Support routines for this file
*****************************************************************************/
static int
newLOfd(LargeObjectDesc *lobjCookie)
newLOfd(LargeObjectDesc * lobjCookie)
{
int i;
for (i = 0; i < MAX_LOBJ_FDS; i++) {
if (cookies[i] == NULL) {
cookies[i] = lobjCookie;
return i;
int i;
for (i = 0; i < MAX_LOBJ_FDS; i++)
{
if (cookies[i] == NULL)
{
cookies[i] = lobjCookie;
return i;
}
}
}
return -1;
return -1;
}
static void
static void
deleteLOfd(int fd)
{
cookies[fd] = NULL;
cookies[fd] = NULL;
}