2006-07-31 03:16:38 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* toasting.c
|
|
|
|
* This file contains routines to support creation of toast tables
|
|
|
|
*
|
|
|
|
*
|
2010-01-02 17:58:17 +01:00
|
|
|
* Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group
|
2006-07-31 03:16:38 +02:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2010-01-29 00:21:13 +01:00
|
|
|
* $PostgreSQL: pgsql/src/backend/catalog/toasting.c,v 1.28 2010/01/28 23:21:11 petere Exp $
|
2006-07-31 03:16:38 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
|
|
|
|
#include "access/heapam.h"
|
|
|
|
#include "access/tuptoaster.h"
|
|
|
|
#include "access/xact.h"
|
|
|
|
#include "catalog/dependency.h"
|
|
|
|
#include "catalog/heap.h"
|
|
|
|
#include "catalog/index.h"
|
|
|
|
#include "catalog/indexing.h"
|
2007-07-26 00:16:18 +02:00
|
|
|
#include "catalog/namespace.h"
|
2006-07-31 03:16:38 +02:00
|
|
|
#include "catalog/pg_namespace.h"
|
|
|
|
#include "catalog/pg_opclass.h"
|
|
|
|
#include "catalog/pg_type.h"
|
|
|
|
#include "catalog/toasting.h"
|
|
|
|
#include "miscadmin.h"
|
|
|
|
#include "nodes/makefuncs.h"
|
|
|
|
#include "utils/builtins.h"
|
|
|
|
#include "utils/syscache.h"
|
|
|
|
|
2009-12-28 19:49:05 +01:00
|
|
|
Oid binary_upgrade_next_pg_type_toast_oid = InvalidOid;
|
2010-01-06 04:04:03 +01:00
|
|
|
extern Oid binary_upgrade_next_toast_relfilenode;
|
2006-07-31 03:16:38 +02:00
|
|
|
|
2009-02-02 20:31:40 +01:00
|
|
|
static bool create_toast_table(Relation rel, Oid toastOid, Oid toastIndexOid,
|
2010-01-06 04:04:03 +01:00
|
|
|
Datum reloptions);
|
2006-07-31 03:16:38 +02:00
|
|
|
static bool needs_toast_table(Relation rel);
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* AlterTableCreateToastTable
|
|
|
|
* If the table needs a toast table, and doesn't already have one,
|
2010-01-06 04:04:03 +01:00
|
|
|
* then create a toast table for it.
|
2009-06-11 22:46:11 +02:00
|
|
|
*
|
2009-05-08 00:58:28 +02:00
|
|
|
* reloptions for the toast table can be passed, too. Pass (Datum) 0
|
|
|
|
* for default reloptions.
|
2006-07-31 03:16:38 +02:00
|
|
|
*
|
|
|
|
* We expect the caller to have verified that the relation is a table and have
|
|
|
|
* already done any necessary permission checks. Callers expect this function
|
|
|
|
* to end with CommandCounterIncrement if it makes any changes.
|
|
|
|
*/
|
|
|
|
void
|
2010-01-06 04:04:03 +01:00
|
|
|
AlterTableCreateToastTable(Oid relOid, Datum reloptions)
|
2006-07-31 03:16:38 +02:00
|
|
|
{
|
|
|
|
Relation rel;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Grab an exclusive lock on the target table, which we will NOT release
|
|
|
|
* until end of transaction. (This is probably redundant in all present
|
|
|
|
* uses...)
|
|
|
|
*/
|
|
|
|
rel = heap_open(relOid, AccessExclusiveLock);
|
|
|
|
|
|
|
|
/* create_toast_table does all the work */
|
2010-01-06 04:04:03 +01:00
|
|
|
(void) create_toast_table(rel, InvalidOid, InvalidOid, reloptions);
|
2006-07-31 03:16:38 +02:00
|
|
|
|
|
|
|
heap_close(rel, NoLock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a toast table during bootstrap
|
|
|
|
*
|
|
|
|
* Here we need to prespecify the OIDs of the toast table and its index
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
BootstrapToastTable(char *relName, Oid toastOid, Oid toastIndexOid)
|
|
|
|
{
|
2006-10-04 02:30:14 +02:00
|
|
|
Relation rel;
|
2006-07-31 03:16:38 +02:00
|
|
|
|
2008-09-01 22:42:46 +02:00
|
|
|
rel = heap_openrv(makeRangeVar(NULL, relName, -1), AccessExclusiveLock);
|
2006-07-31 03:16:38 +02:00
|
|
|
|
|
|
|
/* Note: during bootstrap may see uncataloged relation */
|
|
|
|
if (rel->rd_rel->relkind != RELKIND_RELATION &&
|
|
|
|
rel->rd_rel->relkind != RELKIND_UNCATALOGED)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
|
|
|
|
errmsg("\"%s\" is not a table",
|
|
|
|
relName)));
|
|
|
|
|
|
|
|
/* create_toast_table does all the work */
|
2010-01-06 04:04:03 +01:00
|
|
|
if (!create_toast_table(rel, toastOid, toastIndexOid, (Datum) 0))
|
2006-07-31 03:16:38 +02:00
|
|
|
elog(ERROR, "\"%s\" does not require a toast table",
|
|
|
|
relName);
|
|
|
|
|
|
|
|
heap_close(rel, NoLock);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* create_toast_table --- internal workhorse
|
|
|
|
*
|
|
|
|
* rel is already opened and exclusive-locked
|
2010-01-06 04:04:03 +01:00
|
|
|
* toastOid and toastIndexOid are normally InvalidOid, but during
|
|
|
|
* bootstrap they can be nonzero to specify hand-assigned OIDs
|
2006-07-31 03:16:38 +02:00
|
|
|
*/
|
|
|
|
static bool
|
2010-01-06 04:04:03 +01:00
|
|
|
create_toast_table(Relation rel, Oid toastOid, Oid toastIndexOid, Datum reloptions)
|
2006-07-31 03:16:38 +02:00
|
|
|
{
|
|
|
|
Oid relOid = RelationGetRelid(rel);
|
|
|
|
HeapTuple reltup;
|
|
|
|
TupleDesc tupdesc;
|
|
|
|
bool shared_relation;
|
|
|
|
Relation class_rel;
|
|
|
|
Oid toast_relid;
|
|
|
|
Oid toast_idxid;
|
2009-12-24 23:09:24 +01:00
|
|
|
Oid toast_typid = InvalidOid;
|
2007-07-26 00:16:18 +02:00
|
|
|
Oid namespaceid;
|
2006-07-31 03:16:38 +02:00
|
|
|
char toast_relname[NAMEDATALEN];
|
|
|
|
char toast_idxname[NAMEDATALEN];
|
|
|
|
IndexInfo *indexInfo;
|
|
|
|
Oid classObjectId[2];
|
2007-01-09 03:14:16 +01:00
|
|
|
int16 coloptions[2];
|
2006-07-31 03:16:38 +02:00
|
|
|
ObjectAddress baseobject,
|
|
|
|
toastobject;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Toast table is shared if and only if its parent is.
|
|
|
|
*
|
|
|
|
* We cannot allow toasting a shared relation after initdb (because
|
|
|
|
* there's no way to mark it toasted in other databases' pg_class).
|
|
|
|
*/
|
|
|
|
shared_relation = rel->rd_rel->relisshared;
|
|
|
|
if (shared_relation && !IsBootstrapProcessingMode())
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
|
|
|
errmsg("shared tables cannot be toasted after initdb")));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Is it already toasted?
|
|
|
|
*/
|
|
|
|
if (rel->rd_rel->reltoastrelid != InvalidOid)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check to see whether the table actually needs a TOAST table.
|
2010-01-06 04:04:03 +01:00
|
|
|
* If the relfilenode is specified, force toast file creation.
|
2006-07-31 03:16:38 +02:00
|
|
|
*/
|
2010-01-06 04:04:03 +01:00
|
|
|
if (!needs_toast_table(rel) &&
|
|
|
|
!OidIsValid(binary_upgrade_next_toast_relfilenode))
|
2006-07-31 03:16:38 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the toast table and its index
|
|
|
|
*/
|
|
|
|
snprintf(toast_relname, sizeof(toast_relname),
|
|
|
|
"pg_toast_%u", relOid);
|
|
|
|
snprintf(toast_idxname, sizeof(toast_idxname),
|
|
|
|
"pg_toast_%u_index", relOid);
|
|
|
|
|
|
|
|
/* this is pretty painful... need a tuple descriptor */
|
|
|
|
tupdesc = CreateTemplateTupleDesc(3, false);
|
|
|
|
TupleDescInitEntry(tupdesc, (AttrNumber) 1,
|
|
|
|
"chunk_id",
|
|
|
|
OIDOID,
|
|
|
|
-1, 0);
|
|
|
|
TupleDescInitEntry(tupdesc, (AttrNumber) 2,
|
|
|
|
"chunk_seq",
|
|
|
|
INT4OID,
|
|
|
|
-1, 0);
|
|
|
|
TupleDescInitEntry(tupdesc, (AttrNumber) 3,
|
|
|
|
"chunk_data",
|
|
|
|
BYTEAOID,
|
|
|
|
-1, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ensure that the toast table doesn't itself get toasted, or we'll be
|
|
|
|
* toast :-(. This is essential for chunk_data because type bytea is
|
|
|
|
* toastable; hit the other two just to be sure.
|
|
|
|
*/
|
|
|
|
tupdesc->attrs[0]->attstorage = 'p';
|
|
|
|
tupdesc->attrs[1]->attstorage = 'p';
|
|
|
|
tupdesc->attrs[2]->attstorage = 'p';
|
|
|
|
|
|
|
|
/*
|
2007-07-26 00:16:18 +02:00
|
|
|
* Toast tables for regular relations go in pg_toast; those for temp
|
|
|
|
* relations go into the per-backend temp-toast-table namespace.
|
|
|
|
*/
|
2009-04-01 00:12:48 +02:00
|
|
|
if (rel->rd_islocaltemp)
|
2007-07-26 00:16:18 +02:00
|
|
|
namespaceid = GetTempToastNamespace();
|
|
|
|
else
|
|
|
|
namespaceid = PG_TOAST_NAMESPACE;
|
|
|
|
|
2009-12-24 23:09:24 +01:00
|
|
|
if (OidIsValid(binary_upgrade_next_pg_type_toast_oid))
|
|
|
|
{
|
|
|
|
toast_typid = binary_upgrade_next_pg_type_toast_oid;
|
|
|
|
binary_upgrade_next_pg_type_toast_oid = InvalidOid;
|
|
|
|
}
|
|
|
|
|
2006-07-31 03:16:38 +02:00
|
|
|
toast_relid = heap_create_with_catalog(toast_relname,
|
2007-07-26 00:16:18 +02:00
|
|
|
namespaceid,
|
2006-07-31 03:16:38 +02:00
|
|
|
rel->rd_rel->reltablespace,
|
|
|
|
toastOid,
|
2009-12-24 23:09:24 +01:00
|
|
|
toast_typid,
|
2010-01-29 00:21:13 +01:00
|
|
|
InvalidOid,
|
2006-07-31 03:16:38 +02:00
|
|
|
rel->rd_rel->relowner,
|
|
|
|
tupdesc,
|
2008-05-10 01:32:05 +02:00
|
|
|
NIL,
|
2006-07-31 03:16:38 +02:00
|
|
|
RELKIND_TOASTVALUE,
|
|
|
|
shared_relation,
|
|
|
|
true,
|
|
|
|
0,
|
|
|
|
ONCOMMIT_NOOP,
|
2009-02-02 20:31:40 +01:00
|
|
|
reloptions,
|
2009-10-05 21:24:49 +02:00
|
|
|
false,
|
2006-07-31 03:16:38 +02:00
|
|
|
true);
|
|
|
|
|
|
|
|
/* make the toast relation visible, else index creation will fail */
|
|
|
|
CommandCounterIncrement();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create unique index on chunk_id, chunk_seq.
|
|
|
|
*
|
|
|
|
* NOTE: the normal TOAST access routines could actually function with a
|
|
|
|
* single-column index on chunk_id only. However, the slice access
|
|
|
|
* routines use both columns for faster access to an individual chunk. In
|
|
|
|
* addition, we want it to be unique as a check against the possibility of
|
|
|
|
* duplicate TOAST chunk OIDs. The index might also be a little more
|
|
|
|
* efficient this way, since btree isn't all that happy with large numbers
|
|
|
|
* of equal keys.
|
|
|
|
*/
|
|
|
|
|
|
|
|
indexInfo = makeNode(IndexInfo);
|
|
|
|
indexInfo->ii_NumIndexAttrs = 2;
|
|
|
|
indexInfo->ii_KeyAttrNumbers[0] = 1;
|
|
|
|
indexInfo->ii_KeyAttrNumbers[1] = 2;
|
|
|
|
indexInfo->ii_Expressions = NIL;
|
|
|
|
indexInfo->ii_ExpressionsState = NIL;
|
|
|
|
indexInfo->ii_Predicate = NIL;
|
|
|
|
indexInfo->ii_PredicateState = NIL;
|
2009-12-07 06:22:23 +01:00
|
|
|
indexInfo->ii_ExclusionOps = NULL;
|
|
|
|
indexInfo->ii_ExclusionProcs = NULL;
|
|
|
|
indexInfo->ii_ExclusionStrats = NULL;
|
2006-07-31 03:16:38 +02:00
|
|
|
indexInfo->ii_Unique = true;
|
2007-09-20 19:56:33 +02:00
|
|
|
indexInfo->ii_ReadyForInserts = true;
|
2006-08-25 06:06:58 +02:00
|
|
|
indexInfo->ii_Concurrent = false;
|
2007-09-20 19:56:33 +02:00
|
|
|
indexInfo->ii_BrokenHotChain = false;
|
2006-07-31 03:16:38 +02:00
|
|
|
|
|
|
|
classObjectId[0] = OID_BTREE_OPS_OID;
|
|
|
|
classObjectId[1] = INT4_BTREE_OPS_OID;
|
|
|
|
|
2007-01-09 03:14:16 +01:00
|
|
|
coloptions[0] = 0;
|
|
|
|
coloptions[1] = 0;
|
|
|
|
|
2006-07-31 03:16:38 +02:00
|
|
|
toast_idxid = index_create(toast_relid, toast_idxname, toastIndexOid,
|
|
|
|
indexInfo,
|
Adjust naming of indexes and their columns per recent discussion.
Index expression columns are now named after the FigureColname result for
their expressions, rather than always being "pg_expression_N". Digits are
appended to this name if needed to make the column name unique within the
index. (That happens for regular columns too, thus fixing the old problem
that CREATE INDEX fooi ON foo (f1, f1) fails. Before exclusion indexes
there was no real reason to do such a thing, but now maybe there is.)
Default names for indexes and associated constraints now include the column
names of all their columns, not only the first one as in previous practice.
(Of course, this will be truncated as needed to fit in NAMEDATALEN. Also,
pkey indexes retain the historical behavior of not naming specific columns
at all.)
An example of the results:
regression=# create table foo (f1 int, f2 text,
regression(# exclude (f1 with =, lower(f2) with =));
NOTICE: CREATE TABLE / EXCLUDE will create implicit index "foo_f1_lower_exclusion" for table "foo"
CREATE TABLE
regression=# \d foo_f1_lower_exclusion
Index "public.foo_f1_lower_exclusion"
Column | Type | Definition
--------+---------+------------
f1 | integer | f1
lower | text | lower(f2)
btree, for table "public.foo"
2009-12-23 03:35:25 +01:00
|
|
|
list_make2("chunk_id", "chunk_seq"),
|
2006-07-31 03:16:38 +02:00
|
|
|
BTREE_AM_OID,
|
|
|
|
rel->rd_rel->reltablespace,
|
2007-01-09 03:14:16 +01:00
|
|
|
classObjectId, coloptions, (Datum) 0,
|
2009-07-29 22:56:21 +02:00
|
|
|
true, false, false, false,
|
|
|
|
true, false, false);
|
2006-07-31 03:16:38 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Store the toast table's OID in the parent relation's pg_class row
|
|
|
|
*/
|
|
|
|
class_rel = heap_open(RelationRelationId, RowExclusiveLock);
|
|
|
|
|
|
|
|
reltup = SearchSysCacheCopy(RELOID,
|
|
|
|
ObjectIdGetDatum(relOid),
|
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(reltup))
|
|
|
|
elog(ERROR, "cache lookup failed for relation %u", relOid);
|
|
|
|
|
|
|
|
((Form_pg_class) GETSTRUCT(reltup))->reltoastrelid = toast_relid;
|
|
|
|
|
|
|
|
if (!IsBootstrapProcessingMode())
|
|
|
|
{
|
|
|
|
/* normal case, use a transactional update */
|
|
|
|
simple_heap_update(class_rel, &reltup->t_self, reltup);
|
|
|
|
|
|
|
|
/* Keep catalog indexes current */
|
|
|
|
CatalogUpdateIndexes(class_rel, reltup);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* While bootstrapping, we cannot UPDATE, so overwrite in-place */
|
|
|
|
heap_inplace_update(class_rel, reltup);
|
|
|
|
}
|
|
|
|
|
|
|
|
heap_freetuple(reltup);
|
|
|
|
|
|
|
|
heap_close(class_rel, RowExclusiveLock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Register dependency from the toast table to the master, so that the
|
|
|
|
* toast table will be deleted if the master is. Skip this in bootstrap
|
|
|
|
* mode.
|
|
|
|
*/
|
|
|
|
if (!IsBootstrapProcessingMode())
|
|
|
|
{
|
|
|
|
baseobject.classId = RelationRelationId;
|
|
|
|
baseobject.objectId = relOid;
|
|
|
|
baseobject.objectSubId = 0;
|
|
|
|
toastobject.classId = RelationRelationId;
|
|
|
|
toastobject.objectId = toast_relid;
|
|
|
|
toastobject.objectSubId = 0;
|
|
|
|
|
|
|
|
recordDependencyOn(&toastobject, &baseobject, DEPENDENCY_INTERNAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make changes visible
|
|
|
|
*/
|
|
|
|
CommandCounterIncrement();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check to see whether the table needs a TOAST table. It does only if
|
|
|
|
* (1) there are any toastable attributes, and (2) the maximum length
|
|
|
|
* of a tuple could exceed TOAST_TUPLE_THRESHOLD. (We don't want to
|
|
|
|
* create a toast table for something like "f1 varchar(20)".)
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
needs_toast_table(Relation rel)
|
|
|
|
{
|
|
|
|
int32 data_length = 0;
|
|
|
|
bool maxlength_unknown = false;
|
|
|
|
bool has_toastable_attrs = false;
|
|
|
|
TupleDesc tupdesc;
|
|
|
|
Form_pg_attribute *att;
|
|
|
|
int32 tuple_length;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
tupdesc = rel->rd_att;
|
|
|
|
att = tupdesc->attrs;
|
|
|
|
|
|
|
|
for (i = 0; i < tupdesc->natts; i++)
|
|
|
|
{
|
|
|
|
if (att[i]->attisdropped)
|
|
|
|
continue;
|
2007-04-06 06:21:44 +02:00
|
|
|
data_length = att_align_nominal(data_length, att[i]->attalign);
|
2006-07-31 03:16:38 +02:00
|
|
|
if (att[i]->attlen > 0)
|
|
|
|
{
|
|
|
|
/* Fixed-length types are never toastable */
|
|
|
|
data_length += att[i]->attlen;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int32 maxlen = type_maximum_size(att[i]->atttypid,
|
|
|
|
att[i]->atttypmod);
|
|
|
|
|
|
|
|
if (maxlen < 0)
|
|
|
|
maxlength_unknown = true;
|
|
|
|
else
|
|
|
|
data_length += maxlen;
|
|
|
|
if (att[i]->attstorage != 'p')
|
|
|
|
has_toastable_attrs = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!has_toastable_attrs)
|
|
|
|
return false; /* nothing to toast? */
|
|
|
|
if (maxlength_unknown)
|
|
|
|
return true; /* any unlimited-length attrs? */
|
|
|
|
tuple_length = MAXALIGN(offsetof(HeapTupleHeaderData, t_bits) +
|
|
|
|
BITMAPLEN(tupdesc->natts)) +
|
|
|
|
MAXALIGN(data_length);
|
|
|
|
return (tuple_length > TOAST_TUPLE_THRESHOLD);
|
|
|
|
}
|