#include "postgres.h"
#include "access/htup_details.h"
+#include "access/tuptoaster.h"
#include "catalog/heap.h"
#include "catalog/pg_type.h"
#include "utils/builtins.h"
/* Other local functions */
static void ER_mc_callback(void *arg);
-static MemoryContext get_domain_check_cxt(ExpandedRecordHeader *erh);
+static MemoryContext get_short_term_cxt(ExpandedRecordHeader *erh);
static void build_dummy_expanded_header(ExpandedRecordHeader *main_erh);
static pg_noinline void check_domain_for_new_field(ExpandedRecordHeader *erh,
int fnumber,
*
* The expanded record is initially "empty", having a state logically
* equivalent to a NULL composite value (not ROW(NULL, NULL, ...)).
- * Note that this might not be a valid state for a domain type; if the
- * caller needs to check that, call expanded_record_set_tuple(erh, NULL).
+ * Note that this might not be a valid state for a domain type;
+ * if the caller needs to check that, call
+ * expanded_record_set_tuple(erh, NULL, false, false).
*
* The expanded object will be a child of parentcontext.
*/
*
* The tuple is physically copied into the expanded record's local storage
* if "copy" is true, otherwise it's caller's responsibility that the tuple
- * will live as long as the expanded record does. In any case, out-of-line
- * fields in the tuple are not automatically inlined.
+ * will live as long as the expanded record does.
+ *
+ * Out-of-line field values in the tuple are automatically inlined if
+ * "expand_external" is true, otherwise not. (The combination copy = false,
+ * expand_external = true is not sensible and not supported.)
*
* Alternatively, tuple can be NULL, in which case we just set the expanded
* record to be empty.
void
expanded_record_set_tuple(ExpandedRecordHeader *erh,
HeapTuple tuple,
- bool copy)
+ bool copy,
+ bool expand_external)
{
int oldflags;
HeapTuple oldtuple;
if (erh->flags & ER_FLAG_IS_DOMAIN)
check_domain_for_new_tuple(erh, tuple);
+ /*
+ * If we need to get rid of out-of-line field values, do so, using the
+ * short-term context to avoid leaking whatever cruft the toast fetch
+ * might generate.
+ */
+ if (expand_external && tuple)
+ {
+ /* Assert caller didn't ask for unsupported case */
+ Assert(copy);
+ if (HeapTupleHasExternal(tuple))
+ {
+ oldcxt = MemoryContextSwitchTo(get_short_term_cxt(erh));
+ tuple = toast_flatten_tuple(tuple, erh->er_tupdesc);
+ MemoryContextSwitchTo(oldcxt);
+ }
+ else
+ expand_external = false; /* need not clean up below */
+ }
+
/*
* Initialize new flags, keeping only non-data status bits.
*/
newtuple = heap_copytuple(tuple);
newflags |= ER_FLAG_FVALUE_ALLOCED;
MemoryContextSwitchTo(oldcxt);
+
+ /* We can now flush anything that detoasting might have leaked. */
+ if (expand_external)
+ MemoryContextReset(erh->er_short_term_cxt);
}
else
newtuple = tuple;
VARATT_IS_EXTERNAL(DatumGetPointer(erh->dvalues[i])))
{
/*
- * It's an external toasted value, so we need to dereference
- * it so that the flat representation will be self-contained.
- * Do this step in the caller's context because the TOAST
- * fetch might leak memory. That means making an extra copy,
- * which is a tad annoying, but repetitive leaks in the
- * record's context would be worse.
+ * expanded_record_set_field_internal can do the actual work
+ * of detoasting. It needn't recheck domain constraints.
*/
- Datum newValue;
-
- newValue = PointerGetDatum(PG_DETOAST_DATUM(erh->dvalues[i]));
- /* expanded_record_set_field can do the rest */
- /* ... and we don't need it to recheck domain constraints */
expanded_record_set_field_internal(erh, i + 1,
- newValue, false,
+ erh->dvalues[i], false,
+ true,
false);
- /* Might as well free the detoasted value */
- pfree(DatumGetPointer(newValue));
}
}
* (without changing the record's state) if the domain's constraints would
* be violated.
*
+ * If expand_external is true and newValue is an out-of-line value, we'll
+ * forcibly detoast it so that the record does not depend on external storage.
+ *
* Internal callers can pass check_constraints = false to skip application
* of domain constraints. External callers should never do that.
*/
void
expanded_record_set_field_internal(ExpandedRecordHeader *erh, int fnumber,
Datum newValue, bool isnull,
+ bool expand_external,
bool check_constraints)
{
TupleDesc tupdesc;
elog(ERROR, "cannot assign to field %d of expanded record", fnumber);
/*
- * Copy new field value into record's context, if needed.
+ * Copy new field value into record's context, and deal with detoasting,
+ * if needed.
*/
attr = TupleDescAttr(tupdesc, fnumber - 1);
if (!isnull && !attr->attbyval)
{
MemoryContext oldcxt;
+ /* If requested, detoast any external value */
+ if (expand_external)
+ {
+ if (attr->attlen == -1 &&
+ VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
+ {
+ /* Detoasting should be done in short-lived context. */
+ oldcxt = MemoryContextSwitchTo(get_short_term_cxt(erh));
+ newValue = PointerGetDatum(heap_tuple_fetch_attr((struct varlena *) DatumGetPointer(newValue)));
+ MemoryContextSwitchTo(oldcxt);
+ }
+ else
+ expand_external = false; /* need not clean up below */
+ }
+
+ /* Copy value into record's context */
oldcxt = MemoryContextSwitchTo(erh->hdr.eoh_context);
newValue = datumCopy(newValue, false, attr->attlen);
MemoryContextSwitchTo(oldcxt);
+ /* We can now flush anything that detoasting might have leaked */
+ if (expand_external)
+ MemoryContextReset(erh->er_short_term_cxt);
+
/* Remember that we have field(s) that may need to be pfree'd */
erh->flags |= ER_FLAG_DVALUES_ALLOCED;
/*
* While we're here, note whether it's an external toasted value,
- * because that could mean we need to inline it later.
+ * because that could mean we need to inline it later. (Think not to
+ * merge this into the previous expand_external logic: datumCopy could
+ * by itself have made the value non-external.)
*/
if (attr->attlen == -1 &&
VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
* Caller must ensure that the provided datums are of the right types
* to match the record's previously assigned rowtype.
*
+ * If expand_external is true, we'll forcibly detoast out-of-line field values
+ * so that the record does not depend on external storage.
+ *
* Unlike repeated application of expanded_record_set_field(), this does not
* guarantee to leave the expanded record in a non-corrupt state in event
* of an error. Typically it would only be used for initializing a new
- * expanded record.
+ * expanded record. Also, because we expect this to be applied at most once
+ * in the lifespan of an expanded record, we do not worry about any cruft
+ * that detoasting might leak.
*/
void
expanded_record_set_fields(ExpandedRecordHeader *erh,
- const Datum *newValues, const bool *isnulls)
+ const Datum *newValues, const bool *isnulls,
+ bool expand_external)
{
TupleDesc tupdesc;
Datum *dvalues;
if (!attr->attbyval)
{
/*
- * Copy new field value into record's context, if needed.
+ * Copy new field value into record's context, and deal with
+ * detoasting, if needed.
*/
if (!isnull)
{
- newValue = datumCopy(newValue, false, attr->attlen);
+ /* Is it an external toasted value? */
+ if (attr->attlen == -1 &&
+ VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
+ {
+ if (expand_external)
+ {
+ /* Detoast as requested while copying the value */
+ newValue = PointerGetDatum(heap_tuple_fetch_attr((struct varlena *) DatumGetPointer(newValue)));
+ }
+ else
+ {
+ /* Just copy the value */
+ newValue = datumCopy(newValue, false, -1);
+ /* If it's still external, remember that */
+ if (VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
+ erh->flags |= ER_FLAG_HAVE_EXTERNAL;
+ }
+ }
+ else
+ {
+ /* Not an external value, just copy it */
+ newValue = datumCopy(newValue, false, attr->attlen);
+ }
/* Remember that we have field(s) that need to be pfree'd */
erh->flags |= ER_FLAG_DVALUES_ALLOCED;
-
- /*
- * While we're here, note whether it's an external toasted
- * value, because that could mean we need to inline it later.
- */
- if (attr->attlen == -1 &&
- VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
- erh->flags |= ER_FLAG_HAVE_EXTERNAL;
}
/*
if (erh->flags & ER_FLAG_IS_DOMAIN)
{
/* We run domain_check in a short-lived context to limit cruft */
- MemoryContextSwitchTo(get_domain_check_cxt(erh));
+ MemoryContextSwitchTo(get_short_term_cxt(erh));
domain_check(ExpandedRecordGetRODatum(erh), false,
erh->er_decltypeid,
}
/*
- * Construct (or reset) working memory context for domain checks.
+ * Construct (or reset) working memory context for short-term operations.
+ *
+ * This context is used for domain check evaluation and for detoasting.
*
- * If we don't have a working memory context for domain checking, make one;
- * if we have one, reset it to get rid of any leftover cruft. (It is a tad
- * annoying to need a whole context for this, since it will often go unused
- * --- but it's hard to avoid memory leaks otherwise. We can make the
- * context small, at least.)
+ * If we don't have a short-lived memory context, make one; if we have one,
+ * reset it to get rid of any leftover cruft. (It is a tad annoying to need a
+ * whole context for this, since it will often go unused --- but it's hard to
+ * avoid memory leaks otherwise. We can make the context small, at least.)
*/
static MemoryContext
-get_domain_check_cxt(ExpandedRecordHeader *erh)
+get_short_term_cxt(ExpandedRecordHeader *erh)
{
- if (erh->er_domain_check_cxt == NULL)
- erh->er_domain_check_cxt =
+ if (erh->er_short_term_cxt == NULL)
+ erh->er_short_term_cxt =
AllocSetContextCreate(erh->hdr.eoh_context,
- "expanded record domain checks",
+ "expanded record short-term context",
ALLOCSET_SMALL_SIZES);
else
- MemoryContextReset(erh->er_domain_check_cxt);
- return erh->er_domain_check_cxt;
+ MemoryContextReset(erh->er_short_term_cxt);
+ return erh->er_short_term_cxt;
}
/*
ExpandedRecordHeader *erh;
TupleDesc tupdesc = expanded_record_get_tupdesc(main_erh);
- /* Ensure we have a domain_check_cxt */
- (void) get_domain_check_cxt(main_erh);
+ /* Ensure we have a short-lived context */
+ (void) get_short_term_cxt(main_erh);
/*
* Allocate dummy header on first time through, or in the unlikely event
* nothing else is authorized to delete or transfer ownership of the
* object's context, so it should be safe enough.
*/
- EOH_init_header(&erh->hdr, &ER_methods, main_erh->er_domain_check_cxt);
+ EOH_init_header(&erh->hdr, &ER_methods, main_erh->er_short_term_cxt);
erh->er_magic = ER_MAGIC;
/* Set up dvalues/dnulls, with no valid contents as yet */
* We call domain_check in the short-lived context, so that any cruft
* leaked by expression evaluation can be reclaimed.
*/
- oldcxt = MemoryContextSwitchTo(erh->er_domain_check_cxt);
+ oldcxt = MemoryContextSwitchTo(erh->er_short_term_cxt);
/*
* And now we can apply the check. Note we use main header's domain cache
MemoryContextSwitchTo(oldcxt);
/* We might as well clean up cruft immediately. */
- MemoryContextReset(erh->er_domain_check_cxt);
+ MemoryContextReset(erh->er_short_term_cxt);
}
/*
if (tuple == NULL)
{
/* We run domain_check in a short-lived context to limit cruft */
- oldcxt = MemoryContextSwitchTo(get_domain_check_cxt(erh));
+ oldcxt = MemoryContextSwitchTo(get_short_term_cxt(erh));
domain_check((Datum) 0, true,
erh->er_decltypeid,
MemoryContextSwitchTo(oldcxt);
/* We might as well clean up cruft immediately. */
- MemoryContextReset(erh->er_domain_check_cxt);
+ MemoryContextReset(erh->er_short_term_cxt);
return;
}
* We call domain_check in the short-lived context, so that any cruft
* leaked by expression evaluation can be reclaimed.
*/
- oldcxt = MemoryContextSwitchTo(erh->er_domain_check_cxt);
+ oldcxt = MemoryContextSwitchTo(erh->er_short_term_cxt);
/*
* And now we can apply the check. Note we use main header's domain cache
MemoryContextSwitchTo(oldcxt);
/* We might as well clean up cruft immediately. */
- MemoryContextReset(erh->er_domain_check_cxt);
+ MemoryContextReset(erh->er_short_term_cxt);
}
projects / postgresql / blobdiff