PostgreSQL Source Code  git master
large_object.h File Reference
#include "utils/snapshot.h"
Include dependency graph for large_object.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  LargeObjectDesc
 

Macros

#define IFS_RDLOCK   (1 << 0) /* LO was opened for reading */
 
#define IFS_WRLOCK   (1 << 1) /* LO was opened for writing */
 
#define LOBLKSIZE   (BLCKSZ / 4)
 
#define MAX_LARGE_OBJECT_SIZE   ((int64) INT_MAX * LOBLKSIZE)
 

Typedefs

typedef struct LargeObjectDesc LargeObjectDesc
 

Functions

void close_lo_relation (bool isCommit)
 
Oid inv_create (Oid lobjId)
 
LargeObjectDescinv_open (Oid lobjId, int flags, MemoryContext mcxt)
 
void inv_close (LargeObjectDesc *obj_desc)
 
int inv_drop (Oid lobjId)
 
int64 inv_seek (LargeObjectDesc *obj_desc, int64 offset, int whence)
 
int64 inv_tell (LargeObjectDesc *obj_desc)
 
int inv_read (LargeObjectDesc *obj_desc, char *buf, int nbytes)
 
int inv_write (LargeObjectDesc *obj_desc, const char *buf, int nbytes)
 
void inv_truncate (LargeObjectDesc *obj_desc, int64 len)
 

Variables

PGDLLIMPORT bool lo_compat_privileges
 

Macro Definition Documentation

◆ IFS_RDLOCK

#define IFS_RDLOCK   (1 << 0) /* LO was opened for reading */

Definition at line 48 of file large_object.h.

◆ IFS_WRLOCK

#define IFS_WRLOCK   (1 << 1) /* LO was opened for writing */

Definition at line 49 of file large_object.h.

◆ LOBLKSIZE

#define LOBLKSIZE   (BLCKSZ / 4)

Definition at line 70 of file large_object.h.

◆ MAX_LARGE_OBJECT_SIZE

#define MAX_LARGE_OBJECT_SIZE   ((int64) INT_MAX * LOBLKSIZE)

Definition at line 76 of file large_object.h.

Typedef Documentation

◆ LargeObjectDesc

Function Documentation

◆ close_lo_relation()

void close_lo_relation ( bool  isCommit)

Definition at line 97 of file inv_api.c.

98 {
99  if (lo_heap_r || lo_index_r)
100  {
101  /*
102  * Only bother to close if committing; else abort cleanup will handle
103  * it
104  */
105  if (isCommit)
106  {
107  ResourceOwner currentOwner;
108 
109  currentOwner = CurrentResourceOwner;
111 
112  if (lo_index_r)
114  if (lo_heap_r)
116 
117  CurrentResourceOwner = currentOwner;
118  }
119  lo_heap_r = NULL;
120  lo_index_r = NULL;
121  }
122 }
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:177
static Relation lo_index_r
Definition: inv_api.c:66
static Relation lo_heap_r
Definition: inv_api.c:65
#define NoLock
Definition: lockdefs.h:34
ResourceOwner TopTransactionResourceOwner
Definition: resowner.c:167
ResourceOwner CurrentResourceOwner
Definition: resowner.c:165
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126

References CurrentResourceOwner, index_close(), lo_heap_r, lo_index_r, NoLock, table_close(), and TopTransactionResourceOwner.

Referenced by AtEOXact_LargeObject().

◆ inv_close()

void inv_close ( LargeObjectDesc obj_desc)

Definition at line 299 of file inv_api.c.

300 {
301  Assert(PointerIsValid(obj_desc));
302  pfree(obj_desc);
303 }
#define Assert(condition)
Definition: c.h:812
#define PointerIsValid(pointer)
Definition: c.h:717
void pfree(void *pointer)
Definition: mcxt.c:1521

References Assert, pfree(), and PointerIsValid.

Referenced by be_lo_export(), be_lo_from_bytea(), be_lo_put(), closeLOfd(), lo_get_fragment_internal(), and lo_import_internal().

◆ inv_create()

Oid inv_create ( Oid  lobjId)

Definition at line 173 of file inv_api.c.

174 {
175  Oid lobjId_new;
176 
177  /*
178  * Create a new largeobject with empty data pages
179  */
180  lobjId_new = LargeObjectCreate(lobjId);
181 
182  /*
183  * dependency on the owner of largeobject
184  *
185  * Note that LO dependencies are recorded using classId
186  * LargeObjectRelationId for backwards-compatibility reasons. Using
187  * LargeObjectMetadataRelationId instead would simplify matters for the
188  * backend, but it'd complicate pg_dump and possibly break other clients.
189  */
190  recordDependencyOnOwner(LargeObjectRelationId,
191  lobjId_new, GetUserId());
192 
193  /* Post creation hook for new large object */
194  InvokeObjectPostCreateHook(LargeObjectRelationId, lobjId_new, 0);
195 
196  /*
197  * Advance command counter to make new tuple visible to later operations.
198  */
200 
201  return lobjId_new;
202 }
Oid GetUserId(void)
Definition: miscinit.c:524
#define InvokeObjectPostCreateHook(classId, objectId, subId)
Definition: objectaccess.h:173
Oid LargeObjectCreate(Oid loid)
void recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner)
Definition: pg_shdepend.c:168
unsigned int Oid
Definition: postgres_ext.h:31
void CommandCounterIncrement(void)
Definition: xact.c:1099

References CommandCounterIncrement(), GetUserId(), InvokeObjectPostCreateHook, LargeObjectCreate(), and recordDependencyOnOwner().

Referenced by be_lo_creat(), be_lo_create(), be_lo_from_bytea(), and lo_import_internal().

◆ inv_drop()

int inv_drop ( Oid  lobjId)

Definition at line 311 of file inv_api.c.

312 {
313  ObjectAddress object;
314 
315  /*
316  * Delete any comments and dependencies on the large object
317  */
318  object.classId = LargeObjectRelationId;
319  object.objectId = lobjId;
320  object.objectSubId = 0;
321  performDeletion(&object, DROP_CASCADE, 0);
322 
323  /*
324  * Advance command counter so that tuple removal will be seen by later
325  * large-object operations in this transaction.
326  */
328 
329  /* For historical reasons, we always return 1 on success. */
330  return 1;
331 }
void performDeletion(const ObjectAddress *object, DropBehavior behavior, int flags)
Definition: dependency.c:273
@ DROP_CASCADE
Definition: parsenodes.h:2342

References ObjectAddress::classId, CommandCounterIncrement(), DROP_CASCADE, and performDeletion().

Referenced by be_lo_unlink().

◆ inv_open()

LargeObjectDesc* inv_open ( Oid  lobjId,
int  flags,
MemoryContext  mcxt 
)

Definition at line 215 of file inv_api.c.

216 {
217  LargeObjectDesc *retval;
218  Snapshot snapshot = NULL;
219  int descflags = 0;
220 
221  /*
222  * Historically, no difference is made between (INV_WRITE) and (INV_WRITE
223  * | INV_READ), the caller being allowed to read the large object
224  * descriptor in either case.
225  */
226  if (flags & INV_WRITE)
227  descflags |= IFS_WRLOCK | IFS_RDLOCK;
228  if (flags & INV_READ)
229  descflags |= IFS_RDLOCK;
230 
231  if (descflags == 0)
232  ereport(ERROR,
233  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
234  errmsg("invalid flags for opening a large object: %d",
235  flags)));
236 
237  /* Get snapshot. If write is requested, use an instantaneous snapshot. */
238  if (descflags & IFS_WRLOCK)
239  snapshot = NULL;
240  else
241  snapshot = GetActiveSnapshot();
242 
243  /* Can't use LargeObjectExists here because we need to specify snapshot */
244  if (!LargeObjectExistsWithSnapshot(lobjId, snapshot))
245  ereport(ERROR,
246  (errcode(ERRCODE_UNDEFINED_OBJECT),
247  errmsg("large object %u does not exist", lobjId)));
248 
249  /* Apply permission checks, again specifying snapshot */
250  if ((descflags & IFS_RDLOCK) != 0)
251  {
252  if (!lo_compat_privileges &&
254  GetUserId(),
255  ACL_SELECT,
256  snapshot) != ACLCHECK_OK)
257  ereport(ERROR,
258  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
259  errmsg("permission denied for large object %u",
260  lobjId)));
261  }
262  if ((descflags & IFS_WRLOCK) != 0)
263  {
264  if (!lo_compat_privileges &&
266  GetUserId(),
267  ACL_UPDATE,
268  snapshot) != ACLCHECK_OK)
269  ereport(ERROR,
270  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
271  errmsg("permission denied for large object %u",
272  lobjId)));
273  }
274 
275  /* OK to create a descriptor */
276  retval = (LargeObjectDesc *) MemoryContextAlloc(mcxt,
277  sizeof(LargeObjectDesc));
278  retval->id = lobjId;
279  retval->offset = 0;
280  retval->flags = descflags;
281 
282  /* caller sets if needed, not used by the functions in this file */
283  retval->subid = InvalidSubTransactionId;
284 
285  /*
286  * The snapshot (if any) is just the currently active snapshot. The
287  * caller will replace it with a longer-lived copy if needed.
288  */
289  retval->snapshot = snapshot;
290 
291  return retval;
292 }
@ ACLCHECK_OK
Definition: acl.h:183
AclResult pg_largeobject_aclcheck_snapshot(Oid lobj_oid, Oid roleid, AclMode mode, Snapshot snapshot)
Definition: aclchk.c:4050
#define InvalidSubTransactionId
Definition: c.h:612
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
bool lo_compat_privileges
Definition: inv_api.c:56
#define IFS_RDLOCK
Definition: large_object.h:48
#define IFS_WRLOCK
Definition: large_object.h:49
#define INV_READ
Definition: libpq-fs.h:22
#define INV_WRITE
Definition: libpq-fs.h:21
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1181
#define ACL_UPDATE
Definition: parsenodes.h:78
#define ACL_SELECT
Definition: parsenodes.h:77
bool LargeObjectExistsWithSnapshot(Oid loid, Snapshot snapshot)
Snapshot GetActiveSnapshot(void)
Definition: snapmgr.c:732
Snapshot snapshot
Definition: large_object.h:42
SubTransactionId subid
Definition: large_object.h:43

References ACL_SELECT, ACL_UPDATE, ACLCHECK_OK, ereport, errcode(), errmsg(), ERROR, LargeObjectDesc::flags, GetActiveSnapshot(), GetUserId(), LargeObjectDesc::id, IFS_RDLOCK, IFS_WRLOCK, INV_READ, INV_WRITE, InvalidSubTransactionId, LargeObjectExistsWithSnapshot(), lo_compat_privileges, MemoryContextAlloc(), LargeObjectDesc::offset, pg_largeobject_aclcheck_snapshot(), LargeObjectDesc::snapshot, and LargeObjectDesc::subid.

Referenced by be_lo_export(), be_lo_from_bytea(), be_lo_open(), be_lo_put(), lo_get_fragment_internal(), and lo_import_internal().

◆ inv_read()

int inv_read ( LargeObjectDesc obj_desc,
char *  buf,
int  nbytes 
)

Definition at line 450 of file inv_api.c.

451 {
452  int nread = 0;
453  int64 n;
454  int64 off;
455  int len;
456  int32 pageno = (int32) (obj_desc->offset / LOBLKSIZE);
457  uint64 pageoff;
458  ScanKeyData skey[2];
459  SysScanDesc sd;
460  HeapTuple tuple;
461 
462  Assert(PointerIsValid(obj_desc));
463  Assert(buf != NULL);
464 
465  if ((obj_desc->flags & IFS_RDLOCK) == 0)
466  ereport(ERROR,
467  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
468  errmsg("permission denied for large object %u",
469  obj_desc->id)));
470 
471  if (nbytes <= 0)
472  return 0;
473 
475 
476  ScanKeyInit(&skey[0],
477  Anum_pg_largeobject_loid,
478  BTEqualStrategyNumber, F_OIDEQ,
479  ObjectIdGetDatum(obj_desc->id));
480 
481  ScanKeyInit(&skey[1],
482  Anum_pg_largeobject_pageno,
484  Int32GetDatum(pageno));
485 
487  obj_desc->snapshot, 2, skey);
488 
489  while ((tuple = systable_getnext_ordered(sd, ForwardScanDirection)) != NULL)
490  {
492  bytea *datafield;
493  bool pfreeit;
494 
495  if (HeapTupleHasNulls(tuple)) /* paranoia */
496  elog(ERROR, "null field found in pg_largeobject");
498 
499  /*
500  * We expect the indexscan will deliver pages in order. However,
501  * there may be missing pages if the LO contains unwritten "holes". We
502  * want missing sections to read out as zeroes.
503  */
504  pageoff = ((uint64) data->pageno) * LOBLKSIZE;
505  if (pageoff > obj_desc->offset)
506  {
507  n = pageoff - obj_desc->offset;
508  n = (n <= (nbytes - nread)) ? n : (nbytes - nread);
509  MemSet(buf + nread, 0, n);
510  nread += n;
511  obj_desc->offset += n;
512  }
513 
514  if (nread < nbytes)
515  {
516  Assert(obj_desc->offset >= pageoff);
517  off = (int) (obj_desc->offset - pageoff);
518  Assert(off >= 0 && off < LOBLKSIZE);
519 
520  getdatafield(data, &datafield, &len, &pfreeit);
521  if (len > off)
522  {
523  n = len - off;
524  n = (n <= (nbytes - nread)) ? n : (nbytes - nread);
525  memcpy(buf + nread, VARDATA(datafield) + off, n);
526  nread += n;
527  obj_desc->offset += n;
528  }
529  if (pfreeit)
530  pfree(datafield);
531  }
532 
533  if (nread >= nbytes)
534  break;
535  }
536 
538 
539  return nread;
540 }
int64_t int64
Definition: c.h:482
int32_t int32
Definition: c.h:481
uint64_t uint64
Definition: c.h:486
#define MemSet(start, val, len)
Definition: c.h:974
#define elog(elevel,...)
Definition: elog.h:225
SysScanDesc systable_beginscan_ordered(Relation heapRelation, Relation indexRelation, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:653
void systable_endscan_ordered(SysScanDesc sysscan)
Definition: genam.c:760
HeapTuple systable_getnext_ordered(SysScanDesc sysscan, ScanDirection direction)
Definition: genam.c:735
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
#define HeapTupleHasNulls(tuple)
Definition: htup_details.h:659
static void getdatafield(Form_pg_largeobject tuple, bytea **pdatafield, int *plen, bool *pfreeit)
Definition: inv_api.c:131
static void open_lo_relation(void)
Definition: inv_api.c:73
#define LOBLKSIZE
Definition: large_object.h:70
const void size_t len
const void * data
FormData_pg_largeobject * Form_pg_largeobject
static char * buf
Definition: pg_test_fsync.c:72
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:212
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
@ ForwardScanDirection
Definition: sdir.h:28
#define BTEqualStrategyNumber
Definition: stratnum.h:31
#define BTGreaterEqualStrategyNumber
Definition: stratnum.h:32
Definition: c.h:641
#define VARDATA(PTR)
Definition: varatt.h:278

References Assert, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, buf, data, elog, ereport, errcode(), errmsg(), ERROR, LargeObjectDesc::flags, ForwardScanDirection, getdatafield(), GETSTRUCT, HeapTupleHasNulls, LargeObjectDesc::id, IFS_RDLOCK, Int32GetDatum(), len, lo_heap_r, lo_index_r, LOBLKSIZE, MemSet, ObjectIdGetDatum(), LargeObjectDesc::offset, open_lo_relation(), pfree(), PointerIsValid, ScanKeyInit(), LargeObjectDesc::snapshot, systable_beginscan_ordered(), systable_endscan_ordered(), systable_getnext_ordered(), and VARDATA.

Referenced by be_lo_export(), lo_get_fragment_internal(), and lo_read().

◆ inv_seek()

int64 inv_seek ( LargeObjectDesc obj_desc,
int64  offset,
int  whence 
)

Definition at line 388 of file inv_api.c.

389 {
390  int64 newoffset;
391 
392  Assert(PointerIsValid(obj_desc));
393 
394  /*
395  * We allow seek/tell if you have either read or write permission, so no
396  * need for a permission check here.
397  */
398 
399  /*
400  * Note: overflow in the additions is possible, but since we will reject
401  * negative results, we don't need any extra test for that.
402  */
403  switch (whence)
404  {
405  case SEEK_SET:
406  newoffset = offset;
407  break;
408  case SEEK_CUR:
409  newoffset = obj_desc->offset + offset;
410  break;
411  case SEEK_END:
412  newoffset = inv_getsize(obj_desc) + offset;
413  break;
414  default:
415  ereport(ERROR,
416  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
417  errmsg("invalid whence setting: %d", whence)));
418  newoffset = 0; /* keep compiler quiet */
419  break;
420  }
421 
422  /*
423  * use errmsg_internal here because we don't want to expose INT64_FORMAT
424  * in translatable strings; doing better is not worth the trouble
425  */
426  if (newoffset < 0 || newoffset > MAX_LARGE_OBJECT_SIZE)
427  ereport(ERROR,
428  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
429  errmsg_internal("invalid large object seek target: " INT64_FORMAT,
430  newoffset)));
431 
432  obj_desc->offset = newoffset;
433  return newoffset;
434 }
#define INT64_FORMAT
Definition: c.h:503
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1157
static uint64 inv_getsize(LargeObjectDesc *obj_desc)
Definition: inv_api.c:340
#define MAX_LARGE_OBJECT_SIZE
Definition: large_object.h:76

References Assert, ereport, errcode(), errmsg(), errmsg_internal(), ERROR, INT64_FORMAT, inv_getsize(), MAX_LARGE_OBJECT_SIZE, LargeObjectDesc::offset, and PointerIsValid.

Referenced by be_lo_lseek(), be_lo_lseek64(), be_lo_put(), and lo_get_fragment_internal().

◆ inv_tell()

int64 inv_tell ( LargeObjectDesc obj_desc)

Definition at line 437 of file inv_api.c.

438 {
439  Assert(PointerIsValid(obj_desc));
440 
441  /*
442  * We allow seek/tell if you have either read or write permission, so no
443  * need for a permission check here.
444  */
445 
446  return obj_desc->offset;
447 }

References Assert, LargeObjectDesc::offset, and PointerIsValid.

Referenced by be_lo_tell(), and be_lo_tell64().

◆ inv_truncate()

void inv_truncate ( LargeObjectDesc obj_desc,
int64  len 
)

Definition at line 740 of file inv_api.c.

741 {
742  int32 pageno = (int32) (len / LOBLKSIZE);
743  int32 off;
744  ScanKeyData skey[2];
745  SysScanDesc sd;
746  HeapTuple oldtuple;
747  Form_pg_largeobject olddata;
748  union
749  {
750  bytea hdr;
751  /* this is to make the union big enough for a LO data chunk: */
752  char data[LOBLKSIZE + VARHDRSZ];
753  /* ensure union is aligned well enough: */
754  int32 align_it;
755  } workbuf;
756  char *workb = VARDATA(&workbuf.hdr);
757  HeapTuple newtup;
758  Datum values[Natts_pg_largeobject];
759  bool nulls[Natts_pg_largeobject];
760  bool replace[Natts_pg_largeobject];
761  CatalogIndexState indstate;
762 
763  Assert(PointerIsValid(obj_desc));
764 
765  /* enforce writability because snapshot is probably wrong otherwise */
766  if ((obj_desc->flags & IFS_WRLOCK) == 0)
767  ereport(ERROR,
768  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
769  errmsg("permission denied for large object %u",
770  obj_desc->id)));
771 
772  /*
773  * use errmsg_internal here because we don't want to expose INT64_FORMAT
774  * in translatable strings; doing better is not worth the trouble
775  */
776  if (len < 0 || len > MAX_LARGE_OBJECT_SIZE)
777  ereport(ERROR,
778  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
779  errmsg_internal("invalid large object truncation target: " INT64_FORMAT,
780  len)));
781 
783 
784  indstate = CatalogOpenIndexes(lo_heap_r);
785 
786  /*
787  * Set up to find all pages with desired loid and pageno >= target
788  */
789  ScanKeyInit(&skey[0],
790  Anum_pg_largeobject_loid,
791  BTEqualStrategyNumber, F_OIDEQ,
792  ObjectIdGetDatum(obj_desc->id));
793 
794  ScanKeyInit(&skey[1],
795  Anum_pg_largeobject_pageno,
797  Int32GetDatum(pageno));
798 
800  obj_desc->snapshot, 2, skey);
801 
802  /*
803  * If possible, get the page the truncation point is in. The truncation
804  * point may be beyond the end of the LO or in a hole.
805  */
806  olddata = NULL;
807  if ((oldtuple = systable_getnext_ordered(sd, ForwardScanDirection)) != NULL)
808  {
809  if (HeapTupleHasNulls(oldtuple)) /* paranoia */
810  elog(ERROR, "null field found in pg_largeobject");
811  olddata = (Form_pg_largeobject) GETSTRUCT(oldtuple);
812  Assert(olddata->pageno >= pageno);
813  }
814 
815  /*
816  * If we found the page of the truncation point we need to truncate the
817  * data in it. Otherwise if we're in a hole, we need to create a page to
818  * mark the end of data.
819  */
820  if (olddata != NULL && olddata->pageno == pageno)
821  {
822  /* First, load old data into workbuf */
823  bytea *datafield;
824  int pagelen;
825  bool pfreeit;
826 
827  getdatafield(olddata, &datafield, &pagelen, &pfreeit);
828  memcpy(workb, VARDATA(datafield), pagelen);
829  if (pfreeit)
830  pfree(datafield);
831 
832  /*
833  * Fill any hole
834  */
835  off = len % LOBLKSIZE;
836  if (off > pagelen)
837  MemSet(workb + pagelen, 0, off - pagelen);
838 
839  /* compute length of new page */
840  SET_VARSIZE(&workbuf.hdr, off + VARHDRSZ);
841 
842  /*
843  * Form and insert updated tuple
844  */
845  memset(values, 0, sizeof(values));
846  memset(nulls, false, sizeof(nulls));
847  memset(replace, false, sizeof(replace));
848  values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
849  replace[Anum_pg_largeobject_data - 1] = true;
850  newtup = heap_modify_tuple(oldtuple, RelationGetDescr(lo_heap_r),
851  values, nulls, replace);
852  CatalogTupleUpdateWithInfo(lo_heap_r, &newtup->t_self, newtup,
853  indstate);
854  heap_freetuple(newtup);
855  }
856  else
857  {
858  /*
859  * If the first page we found was after the truncation point, we're in
860  * a hole that we'll fill, but we need to delete the later page
861  * because the loop below won't visit it again.
862  */
863  if (olddata != NULL)
864  {
865  Assert(olddata->pageno > pageno);
866  CatalogTupleDelete(lo_heap_r, &oldtuple->t_self);
867  }
868 
869  /*
870  * Write a brand new page.
871  *
872  * Fill the hole up to the truncation point
873  */
874  off = len % LOBLKSIZE;
875  if (off > 0)
876  MemSet(workb, 0, off);
877 
878  /* compute length of new page */
879  SET_VARSIZE(&workbuf.hdr, off + VARHDRSZ);
880 
881  /*
882  * Form and insert new tuple
883  */
884  memset(values, 0, sizeof(values));
885  memset(nulls, false, sizeof(nulls));
886  values[Anum_pg_largeobject_loid - 1] = ObjectIdGetDatum(obj_desc->id);
887  values[Anum_pg_largeobject_pageno - 1] = Int32GetDatum(pageno);
888  values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
889  newtup = heap_form_tuple(lo_heap_r->rd_att, values, nulls);
890  CatalogTupleInsertWithInfo(lo_heap_r, newtup, indstate);
891  heap_freetuple(newtup);
892  }
893 
894  /*
895  * Delete any pages after the truncation point. If the initial search
896  * didn't find a page, then of course there's nothing more to do.
897  */
898  if (olddata != NULL)
899  {
900  while ((oldtuple = systable_getnext_ordered(sd, ForwardScanDirection)) != NULL)
901  {
902  CatalogTupleDelete(lo_heap_r, &oldtuple->t_self);
903  }
904  }
905 
907 
908  CatalogCloseIndexes(indstate);
909 
910  /*
911  * Advance command counter so that tuple updates will be seen by later
912  * large-object operations in this transaction.
913  */
915 }
static Datum values[MAXATTR]
Definition: bootstrap.c:151
#define VARHDRSZ
Definition: c.h:646
HeapTuple heap_modify_tuple(HeapTuple tuple, TupleDesc tupleDesc, const Datum *replValues, const bool *replIsnull, const bool *doReplace)
Definition: heaptuple.c:1209
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1116
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1434
void CatalogTupleInsertWithInfo(Relation heapRel, HeapTuple tup, CatalogIndexState indstate)
Definition: indexing.c:256
void CatalogCloseIndexes(CatalogIndexState indstate)
Definition: indexing.c:61
CatalogIndexState CatalogOpenIndexes(Relation heapRel)
Definition: indexing.c:43
void CatalogTupleDelete(Relation heapRel, ItemPointer tid)
Definition: indexing.c:365
void CatalogTupleUpdateWithInfo(Relation heapRel, ItemPointer otid, HeapTuple tup, CatalogIndexState indstate)
Definition: indexing.c:337
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
uintptr_t Datum
Definition: postgres.h:64
#define RelationGetDescr(relation)
Definition: rel.h:531
ItemPointerData t_self
Definition: htup.h:65
TupleDesc rd_att
Definition: rel.h:112
#define SET_VARSIZE(PTR, len)
Definition: varatt.h:305

References Assert, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, CatalogCloseIndexes(), CatalogOpenIndexes(), CatalogTupleDelete(), CatalogTupleInsertWithInfo(), CatalogTupleUpdateWithInfo(), CommandCounterIncrement(), data, elog, ereport, errcode(), errmsg(), errmsg_internal(), ERROR, LargeObjectDesc::flags, ForwardScanDirection, getdatafield(), GETSTRUCT, heap_form_tuple(), heap_freetuple(), heap_modify_tuple(), HeapTupleHasNulls, LargeObjectDesc::id, IFS_WRLOCK, Int32GetDatum(), INT64_FORMAT, len, lo_heap_r, lo_index_r, LOBLKSIZE, MAX_LARGE_OBJECT_SIZE, MemSet, ObjectIdGetDatum(), open_lo_relation(), pfree(), PointerGetDatum(), PointerIsValid, RelationData::rd_att, RelationGetDescr, ScanKeyInit(), SET_VARSIZE, LargeObjectDesc::snapshot, systable_beginscan_ordered(), systable_endscan_ordered(), systable_getnext_ordered(), HeapTupleData::t_self, values, VARDATA, and VARHDRSZ.

Referenced by lo_truncate_internal().

◆ inv_write()

int inv_write ( LargeObjectDesc obj_desc,
const char *  buf,
int  nbytes 
)

Definition at line 543 of file inv_api.c.

544 {
545  int nwritten = 0;
546  int n;
547  int off;
548  int len;
549  int32 pageno = (int32) (obj_desc->offset / LOBLKSIZE);
550  ScanKeyData skey[2];
551  SysScanDesc sd;
552  HeapTuple oldtuple;
553  Form_pg_largeobject olddata;
554  bool neednextpage;
555  bytea *datafield;
556  bool pfreeit;
557  union
558  {
559  bytea hdr;
560  /* this is to make the union big enough for a LO data chunk: */
561  char data[LOBLKSIZE + VARHDRSZ];
562  /* ensure union is aligned well enough: */
563  int32 align_it;
564  } workbuf;
565  char *workb = VARDATA(&workbuf.hdr);
566  HeapTuple newtup;
567  Datum values[Natts_pg_largeobject];
568  bool nulls[Natts_pg_largeobject];
569  bool replace[Natts_pg_largeobject];
570  CatalogIndexState indstate;
571 
572  Assert(PointerIsValid(obj_desc));
573  Assert(buf != NULL);
574 
575  /* enforce writability because snapshot is probably wrong otherwise */
576  if ((obj_desc->flags & IFS_WRLOCK) == 0)
577  ereport(ERROR,
578  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
579  errmsg("permission denied for large object %u",
580  obj_desc->id)));
581 
582  if (nbytes <= 0)
583  return 0;
584 
585  /* this addition can't overflow because nbytes is only int32 */
586  if ((nbytes + obj_desc->offset) > MAX_LARGE_OBJECT_SIZE)
587  ereport(ERROR,
588  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
589  errmsg("invalid large object write request size: %d",
590  nbytes)));
591 
593 
594  indstate = CatalogOpenIndexes(lo_heap_r);
595 
596  ScanKeyInit(&skey[0],
597  Anum_pg_largeobject_loid,
598  BTEqualStrategyNumber, F_OIDEQ,
599  ObjectIdGetDatum(obj_desc->id));
600 
601  ScanKeyInit(&skey[1],
602  Anum_pg_largeobject_pageno,
604  Int32GetDatum(pageno));
605 
607  obj_desc->snapshot, 2, skey);
608 
609  oldtuple = NULL;
610  olddata = NULL;
611  neednextpage = true;
612 
613  while (nwritten < nbytes)
614  {
615  /*
616  * If possible, get next pre-existing page of the LO. We expect the
617  * indexscan will deliver these in order --- but there may be holes.
618  */
619  if (neednextpage)
620  {
621  if ((oldtuple = systable_getnext_ordered(sd, ForwardScanDirection)) != NULL)
622  {
623  if (HeapTupleHasNulls(oldtuple)) /* paranoia */
624  elog(ERROR, "null field found in pg_largeobject");
625  olddata = (Form_pg_largeobject) GETSTRUCT(oldtuple);
626  Assert(olddata->pageno >= pageno);
627  }
628  neednextpage = false;
629  }
630 
631  /*
632  * If we have a pre-existing page, see if it is the page we want to
633  * write, or a later one.
634  */
635  if (olddata != NULL && olddata->pageno == pageno)
636  {
637  /*
638  * Update an existing page with fresh data.
639  *
640  * First, load old data into workbuf
641  */
642  getdatafield(olddata, &datafield, &len, &pfreeit);
643  memcpy(workb, VARDATA(datafield), len);
644  if (pfreeit)
645  pfree(datafield);
646 
647  /*
648  * Fill any hole
649  */
650  off = (int) (obj_desc->offset % LOBLKSIZE);
651  if (off > len)
652  MemSet(workb + len, 0, off - len);
653 
654  /*
655  * Insert appropriate portion of new data
656  */
657  n = LOBLKSIZE - off;
658  n = (n <= (nbytes - nwritten)) ? n : (nbytes - nwritten);
659  memcpy(workb + off, buf + nwritten, n);
660  nwritten += n;
661  obj_desc->offset += n;
662  off += n;
663  /* compute valid length of new page */
664  len = (len >= off) ? len : off;
665  SET_VARSIZE(&workbuf.hdr, len + VARHDRSZ);
666 
667  /*
668  * Form and insert updated tuple
669  */
670  memset(values, 0, sizeof(values));
671  memset(nulls, false, sizeof(nulls));
672  memset(replace, false, sizeof(replace));
673  values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
674  replace[Anum_pg_largeobject_data - 1] = true;
675  newtup = heap_modify_tuple(oldtuple, RelationGetDescr(lo_heap_r),
676  values, nulls, replace);
677  CatalogTupleUpdateWithInfo(lo_heap_r, &newtup->t_self, newtup,
678  indstate);
679  heap_freetuple(newtup);
680 
681  /*
682  * We're done with this old page.
683  */
684  oldtuple = NULL;
685  olddata = NULL;
686  neednextpage = true;
687  }
688  else
689  {
690  /*
691  * Write a brand new page.
692  *
693  * First, fill any hole
694  */
695  off = (int) (obj_desc->offset % LOBLKSIZE);
696  if (off > 0)
697  MemSet(workb, 0, off);
698 
699  /*
700  * Insert appropriate portion of new data
701  */
702  n = LOBLKSIZE - off;
703  n = (n <= (nbytes - nwritten)) ? n : (nbytes - nwritten);
704  memcpy(workb + off, buf + nwritten, n);
705  nwritten += n;
706  obj_desc->offset += n;
707  /* compute valid length of new page */
708  len = off + n;
709  SET_VARSIZE(&workbuf.hdr, len + VARHDRSZ);
710 
711  /*
712  * Form and insert updated tuple
713  */
714  memset(values, 0, sizeof(values));
715  memset(nulls, false, sizeof(nulls));
716  values[Anum_pg_largeobject_loid - 1] = ObjectIdGetDatum(obj_desc->id);
717  values[Anum_pg_largeobject_pageno - 1] = Int32GetDatum(pageno);
718  values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
719  newtup = heap_form_tuple(lo_heap_r->rd_att, values, nulls);
720  CatalogTupleInsertWithInfo(lo_heap_r, newtup, indstate);
721  heap_freetuple(newtup);
722  }
723  pageno++;
724  }
725 
727 
728  CatalogCloseIndexes(indstate);
729 
730  /*
731  * Advance command counter so that my tuple updates will be seen by later
732  * large-object operations in this transaction.
733  */
735 
736  return nwritten;
737 }

References Assert, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, buf, CatalogCloseIndexes(), CatalogOpenIndexes(), CatalogTupleInsertWithInfo(), CatalogTupleUpdateWithInfo(), CommandCounterIncrement(), data, elog, ereport, errcode(), errmsg(), ERROR, LargeObjectDesc::flags, ForwardScanDirection, getdatafield(), GETSTRUCT, heap_form_tuple(), heap_freetuple(), heap_modify_tuple(), HeapTupleHasNulls, LargeObjectDesc::id, IFS_WRLOCK, Int32GetDatum(), len, lo_heap_r, lo_index_r, LOBLKSIZE, MAX_LARGE_OBJECT_SIZE, MemSet, ObjectIdGetDatum(), LargeObjectDesc::offset, open_lo_relation(), pfree(), PointerGetDatum(), PointerIsValid, RelationData::rd_att, RelationGetDescr, ScanKeyInit(), SET_VARSIZE, LargeObjectDesc::snapshot, systable_beginscan_ordered(), systable_endscan_ordered(), systable_getnext_ordered(), HeapTupleData::t_self, values, VARDATA, and VARHDRSZ.

Referenced by be_lo_from_bytea(), be_lo_put(), lo_import_internal(), and lo_write().

Variable Documentation

◆ lo_compat_privileges

PGDLLIMPORT bool lo_compat_privileges
extern

Definition at line 56 of file inv_api.c.

Referenced by be_lo_unlink(), check_object_ownership(), has_lo_priv_byid(), and inv_open().