1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
2000-01-12 06:04:42 +01:00
|
|
|
* indexcmds.c
|
2001-07-17 23:53:01 +02:00
|
|
|
* POSTGRES define and remove index code.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2002-06-20 22:29:54 +02:00
|
|
|
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2002-08-29 17:56:20 +02:00
|
|
|
* $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.85 2002/08/29 15:56:20 tgl Exp $
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
1996-11-04 00:57:43 +01:00
|
|
|
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "postgres.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "access/heapam.h"
|
2000-07-04 08:11:54 +02:00
|
|
|
#include "catalog/catalog.h"
|
2000-02-18 10:30:20 +01:00
|
|
|
#include "catalog/catname.h"
|
2002-07-12 20:43:19 +02:00
|
|
|
#include "catalog/dependency.h"
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "catalog/index.h"
|
2002-03-26 20:17:02 +01:00
|
|
|
#include "catalog/namespace.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "catalog/pg_opclass.h"
|
2002-04-05 02:31:36 +02:00
|
|
|
#include "catalog/pg_proc.h"
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "commands/defrem.h"
|
2000-07-04 08:11:54 +02:00
|
|
|
#include "miscadmin.h"
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "optimizer/clauses.h"
|
1999-08-22 22:15:04 +02:00
|
|
|
#include "optimizer/planmain.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "optimizer/prep.h"
|
|
|
|
#include "parser/parsetree.h"
|
2000-04-25 04:45:54 +02:00
|
|
|
#include "parser/parse_coerce.h"
|
2000-02-25 03:58:48 +01:00
|
|
|
#include "parser/parse_func.h"
|
2002-04-27 05:45:03 +02:00
|
|
|
#include "utils/acl.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "utils/builtins.h"
|
2001-07-17 23:53:01 +02:00
|
|
|
#include "utils/lsyscache.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "utils/syscache.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2001-07-17 23:53:01 +02:00
|
|
|
|
2002-04-09 22:35:55 +02:00
|
|
|
#define IsFuncIndex(ATTR_LIST) (((IndexElem*)lfirst(ATTR_LIST))->funcname != NIL)
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/* non-export function prototypes */
|
1997-09-08 23:56:23 +02:00
|
|
|
static void CheckPredicate(List *predList, List *rangeTable, Oid baseRelOid);
|
2000-07-15 00:18:02 +02:00
|
|
|
static void FuncIndexArgs(IndexInfo *indexInfo, Oid *classOidP,
|
2001-03-22 05:01:46 +01:00
|
|
|
IndexElem *funcIndex,
|
|
|
|
Oid relId,
|
|
|
|
char *accessMethodName, Oid accessMethodId);
|
2000-07-15 00:18:02 +02:00
|
|
|
static void NormIndexAttrs(IndexInfo *indexInfo, Oid *classOidP,
|
2001-03-22 05:01:46 +01:00
|
|
|
List *attList,
|
|
|
|
Oid relId,
|
|
|
|
char *accessMethodName, Oid accessMethodId);
|
|
|
|
static Oid GetAttrOpClass(IndexElem *attribute, Oid attrType,
|
|
|
|
char *accessMethodName, Oid accessMethodId);
|
2001-10-25 07:50:21 +02:00
|
|
|
static Oid GetDefaultOpClass(Oid attrType, Oid accessMethodId);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
1999-05-25 18:15:34 +02:00
|
|
|
* DefineIndex
|
1997-09-07 07:04:48 +02:00
|
|
|
* Creates a new index.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* 'attributeList' is a list of IndexElem specifying either a functional
|
1997-09-07 07:04:48 +02:00
|
|
|
* index or a list of attributes to index on.
|
1996-07-09 08:22:35 +02:00
|
|
|
* 'predicate' is the qual specified in the where clause.
|
2001-08-21 18:36:06 +02:00
|
|
|
* 'rangetable' is needed to interpret the predicate.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
void
|
2002-03-26 20:17:02 +01:00
|
|
|
DefineIndex(RangeVar *heapRelation,
|
1997-09-07 07:04:48 +02:00
|
|
|
char *indexRelationName,
|
|
|
|
char *accessMethodName,
|
1997-09-08 23:56:23 +02:00
|
|
|
List *attributeList,
|
1997-09-07 07:04:48 +02:00
|
|
|
bool unique,
|
1999-01-21 23:48:20 +01:00
|
|
|
bool primary,
|
2002-07-12 20:43:19 +02:00
|
|
|
bool isconstraint,
|
1997-09-08 23:56:23 +02:00
|
|
|
Expr *predicate,
|
|
|
|
List *rangetable)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
Oid *classObjectId;
|
|
|
|
Oid accessMethodId;
|
|
|
|
Oid relationId;
|
2002-04-27 05:45:03 +02:00
|
|
|
Oid namespaceId;
|
2002-01-04 00:21:32 +01:00
|
|
|
Relation rel;
|
Restructure index AM interface for index building and index tuple deletion,
per previous discussion on pghackers. Most of the duplicate code in
different AMs' ambuild routines has been moved out to a common routine
in index.c; this means that all index types now do the right things about
inserting recently-dead tuples, etc. (I also removed support for EXTEND
INDEX in the ambuild routines, since that's about to go away anyway, and
it cluttered the code a lot.) The retail indextuple deletion routines have
been replaced by a "bulk delete" routine in which the indexscan is inside
the access method. I haven't pushed this change as far as it should go yet,
but it should allow considerable simplification of the internal bookkeeping
for deletions. Also, add flag columns to pg_am to eliminate various
hardcoded tests on AM OIDs, and remove unused pg_am columns.
Fix rtree and gist index types to not attempt to store NULLs; before this,
gist usually crashed, while rtree managed not to crash but computed wacko
bounding boxes for NULL entries (which might have had something to do with
the performance problems we've heard about occasionally).
Add AtEOXact routines to hash, rtree, and gist, all of which have static
state that needs to be reset after an error. We discovered this need long
ago for btree, but missed the other guys.
Oh, one more thing: concurrent VACUUM is now the default.
2001-07-16 00:48:19 +02:00
|
|
|
HeapTuple tuple;
|
|
|
|
Form_pg_am accessMethodForm;
|
2000-07-15 00:18:02 +02:00
|
|
|
IndexInfo *indexInfo;
|
1997-09-08 04:41:22 +02:00
|
|
|
int numberOfAttributes;
|
2000-07-15 00:18:02 +02:00
|
|
|
List *cnfPred = NIL;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*
|
2000-07-15 00:18:02 +02:00
|
|
|
* count attributes in index
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
numberOfAttributes = length(attributeList);
|
|
|
|
if (numberOfAttributes <= 0)
|
1998-01-05 17:40:20 +01:00
|
|
|
elog(ERROR, "DefineIndex: must specify at least one attribute");
|
2000-01-12 06:04:42 +01:00
|
|
|
if (numberOfAttributes > INDEX_MAX_KEYS)
|
|
|
|
elog(ERROR, "Cannot use more than %d attributes in an index",
|
|
|
|
INDEX_MAX_KEYS);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*
|
2002-01-04 00:21:32 +01:00
|
|
|
* Open heap relation, acquire a suitable lock on it, remember its OID
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2002-03-26 20:17:02 +01:00
|
|
|
rel = heap_openrv(heapRelation, ShareLock);
|
2002-01-04 00:21:32 +01:00
|
|
|
|
|
|
|
/* Note: during bootstrap may see uncataloged relation */
|
|
|
|
if (rel->rd_rel->relkind != RELKIND_RELATION &&
|
|
|
|
rel->rd_rel->relkind != RELKIND_UNCATALOGED)
|
|
|
|
elog(ERROR, "DefineIndex: relation \"%s\" is not a table",
|
2002-03-26 20:17:02 +01:00
|
|
|
heapRelation->relname);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2002-01-04 00:21:32 +01:00
|
|
|
relationId = RelationGetRelid(rel);
|
2002-04-27 05:45:03 +02:00
|
|
|
namespaceId = RelationGetNamespace(rel);
|
2002-01-04 00:21:32 +01:00
|
|
|
|
|
|
|
if (!IsBootstrapProcessingMode() &&
|
2002-04-12 22:38:31 +02:00
|
|
|
IsSystemRelation(rel) &&
|
2002-01-04 00:21:32 +01:00
|
|
|
!IndexesAreActive(relationId, false))
|
|
|
|
elog(ERROR, "Existing indexes are inactive. REINDEX first");
|
|
|
|
|
2002-04-12 22:38:31 +02:00
|
|
|
heap_close(rel, NoLock);
|
|
|
|
|
2002-04-27 05:45:03 +02:00
|
|
|
/*
|
|
|
|
* Verify we (still) have CREATE rights in the rel's namespace.
|
|
|
|
* (Presumably we did when the rel was created, but maybe not anymore.)
|
|
|
|
* Skip check if bootstrapping, since permissions machinery may not
|
2002-08-07 23:45:02 +02:00
|
|
|
* be working yet.
|
2002-04-27 05:45:03 +02:00
|
|
|
*/
|
2002-08-07 23:45:02 +02:00
|
|
|
if (!IsBootstrapProcessingMode())
|
2002-04-27 05:45:03 +02:00
|
|
|
{
|
|
|
|
AclResult aclresult;
|
|
|
|
|
|
|
|
aclresult = pg_namespace_aclcheck(namespaceId, GetUserId(),
|
|
|
|
ACL_CREATE);
|
|
|
|
if (aclresult != ACLCHECK_OK)
|
|
|
|
aclcheck_error(aclresult, get_namespace_name(namespaceId));
|
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/*
|
2001-10-25 07:50:21 +02:00
|
|
|
* look up the access method, verify it can handle the requested
|
|
|
|
* features
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
Restructure index AM interface for index building and index tuple deletion,
per previous discussion on pghackers. Most of the duplicate code in
different AMs' ambuild routines has been moved out to a common routine
in index.c; this means that all index types now do the right things about
inserting recently-dead tuples, etc. (I also removed support for EXTEND
INDEX in the ambuild routines, since that's about to go away anyway, and
it cluttered the code a lot.) The retail indextuple deletion routines have
been replaced by a "bulk delete" routine in which the indexscan is inside
the access method. I haven't pushed this change as far as it should go yet,
but it should allow considerable simplification of the internal bookkeeping
for deletions. Also, add flag columns to pg_am to eliminate various
hardcoded tests on AM OIDs, and remove unused pg_am columns.
Fix rtree and gist index types to not attempt to store NULLs; before this,
gist usually crashed, while rtree managed not to crash but computed wacko
bounding boxes for NULL entries (which might have had something to do with
the performance problems we've heard about occasionally).
Add AtEOXact routines to hash, rtree, and gist, all of which have static
state that needs to be reset after an error. We discovered this need long
ago for btree, but missed the other guys.
Oh, one more thing: concurrent VACUUM is now the default.
2001-07-16 00:48:19 +02:00
|
|
|
tuple = SearchSysCache(AMNAME,
|
|
|
|
PointerGetDatum(accessMethodName),
|
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
2000-04-23 03:44:55 +02:00
|
|
|
elog(ERROR, "DefineIndex: access method \"%s\" not found",
|
1997-09-07 07:04:48 +02:00
|
|
|
accessMethodName);
|
2002-07-20 07:16:59 +02:00
|
|
|
accessMethodId = HeapTupleGetOid(tuple);
|
Restructure index AM interface for index building and index tuple deletion,
per previous discussion on pghackers. Most of the duplicate code in
different AMs' ambuild routines has been moved out to a common routine
in index.c; this means that all index types now do the right things about
inserting recently-dead tuples, etc. (I also removed support for EXTEND
INDEX in the ambuild routines, since that's about to go away anyway, and
it cluttered the code a lot.) The retail indextuple deletion routines have
been replaced by a "bulk delete" routine in which the indexscan is inside
the access method. I haven't pushed this change as far as it should go yet,
but it should allow considerable simplification of the internal bookkeeping
for deletions. Also, add flag columns to pg_am to eliminate various
hardcoded tests on AM OIDs, and remove unused pg_am columns.
Fix rtree and gist index types to not attempt to store NULLs; before this,
gist usually crashed, while rtree managed not to crash but computed wacko
bounding boxes for NULL entries (which might have had something to do with
the performance problems we've heard about occasionally).
Add AtEOXact routines to hash, rtree, and gist, all of which have static
state that needs to be reset after an error. We discovered this need long
ago for btree, but missed the other guys.
Oh, one more thing: concurrent VACUUM is now the default.
2001-07-16 00:48:19 +02:00
|
|
|
accessMethodForm = (Form_pg_am) GETSTRUCT(tuple);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-10-25 07:50:21 +02:00
|
|
|
if (unique && !accessMethodForm->amcanunique)
|
Restructure index AM interface for index building and index tuple deletion,
per previous discussion on pghackers. Most of the duplicate code in
different AMs' ambuild routines has been moved out to a common routine
in index.c; this means that all index types now do the right things about
inserting recently-dead tuples, etc. (I also removed support for EXTEND
INDEX in the ambuild routines, since that's about to go away anyway, and
it cluttered the code a lot.) The retail indextuple deletion routines have
been replaced by a "bulk delete" routine in which the indexscan is inside
the access method. I haven't pushed this change as far as it should go yet,
but it should allow considerable simplification of the internal bookkeeping
for deletions. Also, add flag columns to pg_am to eliminate various
hardcoded tests on AM OIDs, and remove unused pg_am columns.
Fix rtree and gist index types to not attempt to store NULLs; before this,
gist usually crashed, while rtree managed not to crash but computed wacko
bounding boxes for NULL entries (which might have had something to do with
the performance problems we've heard about occasionally).
Add AtEOXact routines to hash, rtree, and gist, all of which have static
state that needs to be reset after an error. We discovered this need long
ago for btree, but missed the other guys.
Oh, one more thing: concurrent VACUUM is now the default.
2001-07-16 00:48:19 +02:00
|
|
|
elog(ERROR, "DefineIndex: access method \"%s\" does not support UNIQUE indexes",
|
|
|
|
accessMethodName);
|
2001-10-25 07:50:21 +02:00
|
|
|
if (numberOfAttributes > 1 && !accessMethodForm->amcanmulticol)
|
Restructure index AM interface for index building and index tuple deletion,
per previous discussion on pghackers. Most of the duplicate code in
different AMs' ambuild routines has been moved out to a common routine
in index.c; this means that all index types now do the right things about
inserting recently-dead tuples, etc. (I also removed support for EXTEND
INDEX in the ambuild routines, since that's about to go away anyway, and
it cluttered the code a lot.) The retail indextuple deletion routines have
been replaced by a "bulk delete" routine in which the indexscan is inside
the access method. I haven't pushed this change as far as it should go yet,
but it should allow considerable simplification of the internal bookkeeping
for deletions. Also, add flag columns to pg_am to eliminate various
hardcoded tests on AM OIDs, and remove unused pg_am columns.
Fix rtree and gist index types to not attempt to store NULLs; before this,
gist usually crashed, while rtree managed not to crash but computed wacko
bounding boxes for NULL entries (which might have had something to do with
the performance problems we've heard about occasionally).
Add AtEOXact routines to hash, rtree, and gist, all of which have static
state that needs to be reset after an error. We discovered this need long
ago for btree, but missed the other guys.
Oh, one more thing: concurrent VACUUM is now the default.
2001-07-16 00:48:19 +02:00
|
|
|
elog(ERROR, "DefineIndex: access method \"%s\" does not support multi-column indexes",
|
|
|
|
accessMethodName);
|
2000-07-15 00:18:02 +02:00
|
|
|
|
Restructure index AM interface for index building and index tuple deletion,
per previous discussion on pghackers. Most of the duplicate code in
different AMs' ambuild routines has been moved out to a common routine
in index.c; this means that all index types now do the right things about
inserting recently-dead tuples, etc. (I also removed support for EXTEND
INDEX in the ambuild routines, since that's about to go away anyway, and
it cluttered the code a lot.) The retail indextuple deletion routines have
been replaced by a "bulk delete" routine in which the indexscan is inside
the access method. I haven't pushed this change as far as it should go yet,
but it should allow considerable simplification of the internal bookkeeping
for deletions. Also, add flag columns to pg_am to eliminate various
hardcoded tests on AM OIDs, and remove unused pg_am columns.
Fix rtree and gist index types to not attempt to store NULLs; before this,
gist usually crashed, while rtree managed not to crash but computed wacko
bounding boxes for NULL entries (which might have had something to do with
the performance problems we've heard about occasionally).
Add AtEOXact routines to hash, rtree, and gist, all of which have static
state that needs to be reset after an error. We discovered this need long
ago for btree, but missed the other guys.
Oh, one more thing: concurrent VACUUM is now the default.
2001-07-16 00:48:19 +02:00
|
|
|
ReleaseSysCache(tuple);
|
2000-07-15 00:18:02 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/*
|
2001-10-25 07:50:21 +02:00
|
|
|
* Convert the partial-index predicate from parsetree form to an
|
|
|
|
* implicit-AND qual expression, for easier evaluation at runtime.
|
2001-08-06 20:09:45 +02:00
|
|
|
* While we are at it, we reduce it to a canonical (CNF or DNF) form
|
|
|
|
* to simplify the task of proving implications.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
if (predicate != NULL && rangetable != NIL)
|
|
|
|
{
|
2001-08-06 20:09:45 +02:00
|
|
|
cnfPred = canonicalize_qual((Expr *) copyObject(predicate), true);
|
1999-08-22 22:15:04 +02:00
|
|
|
fix_opids((Node *) cnfPred);
|
1997-09-07 07:04:48 +02:00
|
|
|
CheckPredicate(cnfPred, rangetable, relationId);
|
|
|
|
}
|
|
|
|
|
2000-07-15 00:18:02 +02:00
|
|
|
/*
|
2001-03-22 05:01:46 +01:00
|
|
|
* Prepare arguments for index_create, primarily an IndexInfo
|
|
|
|
* structure
|
2000-07-15 00:18:02 +02:00
|
|
|
*/
|
|
|
|
indexInfo = makeNode(IndexInfo);
|
2001-07-16 07:07:00 +02:00
|
|
|
indexInfo->ii_Predicate = cnfPred;
|
2000-07-15 00:18:02 +02:00
|
|
|
indexInfo->ii_FuncOid = InvalidOid;
|
|
|
|
indexInfo->ii_Unique = unique;
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (IsFuncIndex(attributeList))
|
|
|
|
{
|
2000-07-15 00:18:02 +02:00
|
|
|
IndexElem *funcIndex = (IndexElem *) lfirst(attributeList);
|
1997-09-08 04:41:22 +02:00
|
|
|
int nargs;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-15 00:18:02 +02:00
|
|
|
/* Parser should have given us only one list item, but check */
|
|
|
|
if (numberOfAttributes != 1)
|
|
|
|
elog(ERROR, "Functional index can only have one attribute");
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
nargs = length(funcIndex->args);
|
|
|
|
if (nargs > INDEX_MAX_KEYS)
|
2000-01-12 06:04:42 +01:00
|
|
|
elog(ERROR, "Index function can take at most %d arguments",
|
|
|
|
INDEX_MAX_KEYS);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-15 00:18:02 +02:00
|
|
|
indexInfo->ii_NumIndexAttrs = 1;
|
|
|
|
indexInfo->ii_NumKeyAttrs = nargs;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-02-25 03:58:48 +01:00
|
|
|
classObjectId = (Oid *) palloc(sizeof(Oid));
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-15 00:18:02 +02:00
|
|
|
FuncIndexArgs(indexInfo, classObjectId, funcIndex,
|
|
|
|
relationId, accessMethodName, accessMethodId);
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2000-07-15 00:18:02 +02:00
|
|
|
indexInfo->ii_NumIndexAttrs = numberOfAttributes;
|
|
|
|
indexInfo->ii_NumKeyAttrs = numberOfAttributes;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-02-25 03:58:48 +01:00
|
|
|
classObjectId = (Oid *) palloc(numberOfAttributes * sizeof(Oid));
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-15 00:18:02 +02:00
|
|
|
NormIndexAttrs(indexInfo, classObjectId, attributeList,
|
|
|
|
relationId, accessMethodName, accessMethodId);
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
2000-02-25 03:58:48 +01:00
|
|
|
|
2002-03-26 20:17:02 +01:00
|
|
|
index_create(relationId, indexRelationName,
|
2000-07-15 00:18:02 +02:00
|
|
|
indexInfo, accessMethodId, classObjectId,
|
2002-07-12 20:43:19 +02:00
|
|
|
primary, isconstraint, allowSystemTableMods);
|
2000-07-15 00:18:02 +02:00
|
|
|
|
2000-06-17 23:49:04 +02:00
|
|
|
/*
|
|
|
|
* We update the relation's pg_class tuple even if it already has
|
2001-03-22 05:01:46 +01:00
|
|
|
* relhasindex = true. This is needed to cause a shared-cache-inval
|
2000-06-17 23:49:04 +02:00
|
|
|
* message to be sent for the pg_class tuple, which will cause other
|
|
|
|
* backends to flush their relcache entries and in particular their
|
|
|
|
* cached lists of the indexes for this relation.
|
|
|
|
*/
|
2001-08-10 20:57:42 +02:00
|
|
|
setRelhasindex(relationId, true, primary, InvalidOid);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CheckPredicate
|
1997-09-07 07:04:48 +02:00
|
|
|
* Checks that the given list of partial-index predicates refer
|
2001-07-16 07:07:00 +02:00
|
|
|
* (via the given range table) only to the given base relation oid.
|
|
|
|
*
|
|
|
|
* This used to also constrain the form of the predicate to forms that
|
2001-10-25 07:50:21 +02:00
|
|
|
* indxpath.c could do something with. However, that seems overly
|
2001-07-16 07:07:00 +02:00
|
|
|
* restrictive. One useful application of partial indexes is to apply
|
|
|
|
* a UNIQUE constraint across a subset of a table, and in that scenario
|
|
|
|
* any evaluatable predicate will work. So accept any predicate here
|
|
|
|
* (except ones requiring a plan), and let indxpath.c fend for itself.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
1997-09-08 23:56:23 +02:00
|
|
|
CheckPredicate(List *predList, List *rangeTable, Oid baseRelOid)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2001-07-16 07:07:00 +02:00
|
|
|
if (length(rangeTable) != 1 || getrelid(1, rangeTable) != baseRelOid)
|
1998-01-05 17:40:20 +01:00
|
|
|
elog(ERROR,
|
2001-10-25 07:50:21 +02:00
|
|
|
"Partial-index predicates may refer only to the base relation");
|
2001-07-16 07:07:00 +02:00
|
|
|
|
2001-07-17 23:53:01 +02:00
|
|
|
/*
|
|
|
|
* We don't currently support generation of an actual query plan for a
|
2001-10-25 07:50:21 +02:00
|
|
|
* predicate, only simple scalar expressions; hence these
|
|
|
|
* restrictions.
|
2001-07-17 23:53:01 +02:00
|
|
|
*/
|
2001-07-16 07:07:00 +02:00
|
|
|
if (contain_subplans((Node *) predList))
|
|
|
|
elog(ERROR, "Cannot use subselect in index predicate");
|
|
|
|
if (contain_agg_clause((Node *) predList))
|
|
|
|
elog(ERROR, "Cannot use aggregate in index predicate");
|
2001-07-17 23:53:01 +02:00
|
|
|
|
|
|
|
/*
|
2002-04-05 02:31:36 +02:00
|
|
|
* A predicate using mutable functions is probably wrong, for the
|
2001-07-17 23:53:01 +02:00
|
|
|
* same reasons that we don't allow a functional index to use one.
|
|
|
|
*/
|
2002-04-05 02:31:36 +02:00
|
|
|
if (contain_mutable_functions((Node *) predList))
|
|
|
|
elog(ERROR, "Functions in index predicate must be marked isImmutable");
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
static void
|
2000-07-15 00:18:02 +02:00
|
|
|
FuncIndexArgs(IndexInfo *indexInfo,
|
|
|
|
Oid *classOidP,
|
|
|
|
IndexElem *funcIndex,
|
2000-04-23 03:44:55 +02:00
|
|
|
Oid relId,
|
|
|
|
char *accessMethodName,
|
|
|
|
Oid accessMethodId)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2000-07-15 00:18:02 +02:00
|
|
|
Oid argTypes[FUNC_MAX_ARGS];
|
|
|
|
List *arglist;
|
2000-08-20 02:44:19 +02:00
|
|
|
int nargs = 0;
|
|
|
|
int i;
|
2001-10-25 07:50:21 +02:00
|
|
|
FuncDetailCode fdresult;
|
2000-08-20 02:44:19 +02:00
|
|
|
Oid funcid;
|
|
|
|
Oid rettype;
|
|
|
|
bool retset;
|
|
|
|
Oid *true_typeids;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*
|
2000-02-25 03:58:48 +01:00
|
|
|
* process the function arguments, which are a list of T_String
|
|
|
|
* (someday ought to allow more general expressions?)
|
2000-07-15 00:18:02 +02:00
|
|
|
*
|
|
|
|
* Note caller already checked that list is not too long.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
2000-07-15 00:18:02 +02:00
|
|
|
MemSet(argTypes, 0, sizeof(argTypes));
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-15 00:18:02 +02:00
|
|
|
foreach(arglist, funcIndex->args)
|
2000-02-25 03:58:48 +01:00
|
|
|
{
|
2000-07-15 00:18:02 +02:00
|
|
|
char *arg = strVal(lfirst(arglist));
|
2000-08-20 02:44:19 +02:00
|
|
|
HeapTuple tuple;
|
2000-02-25 03:58:48 +01:00
|
|
|
Form_pg_attribute att;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2002-08-02 20:15:10 +02:00
|
|
|
tuple = SearchSysCacheAttName(relId, arg);
|
1997-09-07 07:04:48 +02:00
|
|
|
if (!HeapTupleIsValid(tuple))
|
2000-02-25 03:58:48 +01:00
|
|
|
elog(ERROR, "DefineIndex: attribute \"%s\" not found", arg);
|
1998-09-01 05:29:17 +02:00
|
|
|
att = (Form_pg_attribute) GETSTRUCT(tuple);
|
2000-08-20 02:44:19 +02:00
|
|
|
indexInfo->ii_KeyAttrNumbers[nargs] = att->attnum;
|
|
|
|
argTypes[nargs] = att->atttypid;
|
2000-11-16 23:30:52 +01:00
|
|
|
ReleaseSysCache(tuple);
|
2000-08-20 02:44:19 +02:00
|
|
|
nargs++;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
2000-02-25 03:58:48 +01:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
2000-02-25 03:58:48 +01:00
|
|
|
* Lookup the function procedure to get its OID and result type.
|
2000-07-15 00:18:02 +02:00
|
|
|
*
|
2001-03-22 07:16:21 +01:00
|
|
|
* We rely on parse_func.c to find the correct function in the possible
|
|
|
|
* presence of binary-compatible types. However, parse_func may do
|
|
|
|
* too much: it will accept a function that requires run-time coercion
|
|
|
|
* of input types, and the executor is not currently set up to support
|
|
|
|
* that. So, check to make sure that the selected function has
|
|
|
|
* exact-match or binary-compatible input types.
|
2000-02-25 03:58:48 +01:00
|
|
|
*/
|
2002-04-09 22:35:55 +02:00
|
|
|
fdresult = func_get_detail(funcIndex->funcname, funcIndex->args,
|
2001-10-05 00:06:46 +02:00
|
|
|
nargs, argTypes,
|
|
|
|
&funcid, &rettype, &retset,
|
|
|
|
&true_typeids);
|
|
|
|
if (fdresult != FUNCDETAIL_NORMAL)
|
|
|
|
{
|
2002-04-11 22:00:18 +02:00
|
|
|
if (fdresult == FUNCDETAIL_AGGREGATE)
|
|
|
|
elog(ERROR, "DefineIndex: functional index may not use an aggregate function");
|
|
|
|
else if (fdresult == FUNCDETAIL_COERCION)
|
2001-10-05 00:06:46 +02:00
|
|
|
elog(ERROR, "DefineIndex: functional index must use a real function, not a type coercion"
|
|
|
|
"\n\tTry specifying the index opclass you want to use, instead");
|
|
|
|
else
|
2002-04-09 22:35:55 +02:00
|
|
|
func_error("DefineIndex", funcIndex->funcname, nargs, argTypes,
|
|
|
|
NULL);
|
2001-10-05 00:06:46 +02:00
|
|
|
}
|
2000-08-20 02:44:19 +02:00
|
|
|
|
|
|
|
if (retset)
|
|
|
|
elog(ERROR, "DefineIndex: cannot index on a function returning a set");
|
|
|
|
|
|
|
|
for (i = 0; i < nargs; i++)
|
2000-02-25 03:58:48 +01:00
|
|
|
{
|
2002-03-20 20:45:13 +01:00
|
|
|
if (!IsBinaryCompatible(argTypes[i], true_typeids[i]))
|
2002-04-09 22:35:55 +02:00
|
|
|
func_error("DefineIndex", funcIndex->funcname, nargs, argTypes,
|
2000-08-20 02:44:19 +02:00
|
|
|
"Index function must be binary-compatible with table datatype");
|
2000-02-25 03:58:48 +01:00
|
|
|
}
|
|
|
|
|
2001-07-17 23:53:01 +02:00
|
|
|
/*
|
2002-04-05 02:31:36 +02:00
|
|
|
* Require that the function be marked immutable. Using a mutable
|
2001-10-25 07:50:21 +02:00
|
|
|
* function for a functional index is highly questionable, since if
|
|
|
|
* you aren't going to get the same result for the same data every
|
|
|
|
* time, it's not clear what the index entries mean at all.
|
2001-07-17 23:53:01 +02:00
|
|
|
*/
|
2002-04-05 02:31:36 +02:00
|
|
|
if (func_volatile(funcid) != PROVOLATILE_IMMUTABLE)
|
|
|
|
elog(ERROR, "DefineIndex: index function must be marked isImmutable");
|
2001-07-17 23:53:01 +02:00
|
|
|
|
2000-07-15 00:18:02 +02:00
|
|
|
/* Process opclass, using func return type as default type */
|
|
|
|
|
2000-08-20 02:44:19 +02:00
|
|
|
classOidP[0] = GetAttrOpClass(funcIndex, rettype,
|
2000-07-15 00:18:02 +02:00
|
|
|
accessMethodName, accessMethodId);
|
2000-02-25 03:58:48 +01:00
|
|
|
|
2000-08-20 02:44:19 +02:00
|
|
|
/* OK, return results */
|
2000-02-25 03:58:48 +01:00
|
|
|
|
2000-08-20 02:44:19 +02:00
|
|
|
indexInfo->ii_FuncOid = funcid;
|
|
|
|
/* Need to do the fmgr function lookup now, too */
|
2001-03-22 05:01:46 +01:00
|
|
|
fmgr_info(funcid, &indexInfo->ii_FuncInfo);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
static void
|
2000-07-15 00:18:02 +02:00
|
|
|
NormIndexAttrs(IndexInfo *indexInfo,
|
1998-08-26 07:22:58 +02:00
|
|
|
Oid *classOidP,
|
2000-07-15 00:18:02 +02:00
|
|
|
List *attList, /* list of IndexElem's */
|
2000-04-23 03:44:55 +02:00
|
|
|
Oid relId,
|
|
|
|
char *accessMethodName,
|
|
|
|
Oid accessMethodId)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
List *rest;
|
2000-07-15 00:18:02 +02:00
|
|
|
int attn = 0;
|
1996-08-15 09:42:52 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/*
|
|
|
|
* process attributeList
|
|
|
|
*/
|
2000-02-25 03:58:48 +01:00
|
|
|
foreach(rest, attList)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
2000-07-15 00:18:02 +02:00
|
|
|
IndexElem *attribute = (IndexElem *) lfirst(rest);
|
2000-02-25 03:58:48 +01:00
|
|
|
HeapTuple atttuple;
|
1998-09-01 05:29:17 +02:00
|
|
|
Form_pg_attribute attform;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if (attribute->name == NULL)
|
1998-01-05 17:40:20 +01:00
|
|
|
elog(ERROR, "missing attribute for define index");
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2002-08-02 20:15:10 +02:00
|
|
|
atttuple = SearchSysCacheAttName(relId, attribute->name);
|
1998-08-26 18:43:54 +02:00
|
|
|
if (!HeapTupleIsValid(atttuple))
|
2000-02-25 03:58:48 +01:00
|
|
|
elog(ERROR, "DefineIndex: attribute \"%s\" not found",
|
1997-09-07 07:04:48 +02:00
|
|
|
attribute->name);
|
1998-09-01 05:29:17 +02:00
|
|
|
attform = (Form_pg_attribute) GETSTRUCT(atttuple);
|
2000-02-25 03:58:48 +01:00
|
|
|
|
2000-07-15 00:18:02 +02:00
|
|
|
indexInfo->ii_KeyAttrNumbers[attn] = attform->attnum;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-07-15 00:18:02 +02:00
|
|
|
classOidP[attn] = GetAttrOpClass(attribute, attform->atttypid,
|
2001-03-22 05:01:46 +01:00
|
|
|
accessMethodName, accessMethodId);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-11-16 23:30:52 +01:00
|
|
|
ReleaseSysCache(atttuple);
|
2000-07-15 00:18:02 +02:00
|
|
|
attn++;
|
2000-02-25 03:58:48 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static Oid
|
2000-04-23 03:44:55 +02:00
|
|
|
GetAttrOpClass(IndexElem *attribute, Oid attrType,
|
|
|
|
char *accessMethodName, Oid accessMethodId)
|
2000-02-25 03:58:48 +01:00
|
|
|
{
|
2002-07-30 01:46:35 +02:00
|
|
|
char *schemaname;
|
|
|
|
char *opcname;
|
2000-02-25 03:58:48 +01:00
|
|
|
HeapTuple tuple;
|
2000-04-25 04:45:54 +02:00
|
|
|
Oid opClassId,
|
2001-08-21 18:36:06 +02:00
|
|
|
opInputType;
|
2000-02-25 03:58:48 +01:00
|
|
|
|
2002-04-17 22:57:57 +02:00
|
|
|
if (attribute->opclass == NIL)
|
2000-02-25 03:58:48 +01:00
|
|
|
{
|
|
|
|
/* no operator class specified, so find the default */
|
2001-08-21 18:36:06 +02:00
|
|
|
opClassId = GetDefaultOpClass(attrType, accessMethodId);
|
|
|
|
if (!OidIsValid(opClassId))
|
|
|
|
elog(ERROR, "data type %s has no default operator class for access method \"%s\""
|
2001-08-09 20:28:18 +02:00
|
|
|
"\n\tYou must specify an operator class for the index or define a"
|
|
|
|
"\n\tdefault operator class for the data type",
|
2001-08-21 18:36:06 +02:00
|
|
|
format_type_be(attrType), accessMethodName);
|
|
|
|
return opClassId;
|
2000-02-25 03:58:48 +01:00
|
|
|
}
|
|
|
|
|
2000-04-23 03:44:55 +02:00
|
|
|
/*
|
2002-04-17 22:57:57 +02:00
|
|
|
* Specific opclass name given, so look up the opclass.
|
2000-04-23 03:44:55 +02:00
|
|
|
*/
|
2002-04-17 22:57:57 +02:00
|
|
|
|
|
|
|
/* deconstruct the name list */
|
2002-07-30 01:46:35 +02:00
|
|
|
DeconstructQualifiedName(attribute->opclass, &schemaname, &opcname);
|
2002-04-17 22:57:57 +02:00
|
|
|
|
|
|
|
if (schemaname)
|
|
|
|
{
|
|
|
|
/* Look in specific schema only */
|
|
|
|
Oid namespaceId;
|
|
|
|
|
2002-07-30 01:46:35 +02:00
|
|
|
namespaceId = LookupExplicitNamespace(schemaname);
|
2002-04-17 22:57:57 +02:00
|
|
|
tuple = SearchSysCache(CLAAMNAMENSP,
|
|
|
|
ObjectIdGetDatum(accessMethodId),
|
|
|
|
PointerGetDatum(opcname),
|
|
|
|
ObjectIdGetDatum(namespaceId),
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Unqualified opclass name, so search the search path */
|
|
|
|
opClassId = OpclassnameGetOpcid(accessMethodId, opcname);
|
|
|
|
if (!OidIsValid(opClassId))
|
|
|
|
elog(ERROR, "DefineIndex: operator class \"%s\" not supported by access method \"%s\"",
|
|
|
|
opcname, accessMethodName);
|
|
|
|
tuple = SearchSysCache(CLAOID,
|
|
|
|
ObjectIdGetDatum(opClassId),
|
|
|
|
0, 0, 0);
|
|
|
|
}
|
|
|
|
|
2001-08-21 18:36:06 +02:00
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "DefineIndex: operator class \"%s\" not supported by access method \"%s\"",
|
2002-04-17 22:57:57 +02:00
|
|
|
NameListToString(attribute->opclass), accessMethodName);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Verify that the index operator class accepts this
|
|
|
|
* datatype. Note we will accept binary compatibility.
|
|
|
|
*/
|
2002-07-20 07:16:59 +02:00
|
|
|
opClassId = HeapTupleGetOid(tuple);
|
2001-08-21 18:36:06 +02:00
|
|
|
opInputType = ((Form_pg_opclass) GETSTRUCT(tuple))->opcintype;
|
2000-04-23 03:44:55 +02:00
|
|
|
|
2002-03-20 20:45:13 +01:00
|
|
|
if (!IsBinaryCompatible(attrType, opInputType))
|
2001-08-21 18:36:06 +02:00
|
|
|
elog(ERROR, "operator class \"%s\" does not accept data type %s",
|
2002-04-17 22:57:57 +02:00
|
|
|
NameListToString(attribute->opclass), format_type_be(attrType));
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
2000-04-25 04:45:54 +02:00
|
|
|
|
2001-08-21 18:36:06 +02:00
|
|
|
return opClassId;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Oid
|
|
|
|
GetDefaultOpClass(Oid attrType, Oid accessMethodId)
|
|
|
|
{
|
2002-04-17 22:57:57 +02:00
|
|
|
OpclassCandidateList opclass;
|
2001-08-21 18:36:06 +02:00
|
|
|
int nexact = 0;
|
|
|
|
int ncompatible = 0;
|
|
|
|
Oid exactOid = InvalidOid;
|
|
|
|
Oid compatibleOid = InvalidOid;
|
2000-02-25 03:58:48 +01:00
|
|
|
|
2002-08-16 22:55:09 +02:00
|
|
|
/* If it's a domain, look at the base type instead */
|
|
|
|
attrType = getBaseType(attrType);
|
|
|
|
|
2000-04-25 04:45:54 +02:00
|
|
|
/*
|
2001-08-21 18:36:06 +02:00
|
|
|
* We scan through all the opclasses available for the access method,
|
|
|
|
* looking for one that is marked default and matches the target type
|
|
|
|
* (either exactly or binary-compatibly, but prefer an exact match).
|
|
|
|
*
|
|
|
|
* We could find more than one binary-compatible match, in which case we
|
2001-10-25 07:50:21 +02:00
|
|
|
* require the user to specify which one he wants. If we find more
|
|
|
|
* than one exact match, then someone put bogus entries in pg_opclass.
|
2000-04-25 04:45:54 +02:00
|
|
|
*
|
2002-04-17 22:57:57 +02:00
|
|
|
* The initial search is done by namespace.c so that we only consider
|
|
|
|
* opclasses visible in the current namespace search path.
|
2000-04-25 04:45:54 +02:00
|
|
|
*/
|
2002-04-17 22:57:57 +02:00
|
|
|
for (opclass = OpclassGetCandidates(accessMethodId);
|
|
|
|
opclass != NULL;
|
|
|
|
opclass = opclass->next)
|
2000-04-25 04:45:54 +02:00
|
|
|
{
|
2001-08-21 18:36:06 +02:00
|
|
|
if (opclass->opcdefault)
|
2000-04-25 04:45:54 +02:00
|
|
|
{
|
2001-08-21 18:36:06 +02:00
|
|
|
if (opclass->opcintype == attrType)
|
|
|
|
{
|
|
|
|
nexact++;
|
2002-04-17 22:57:57 +02:00
|
|
|
exactOid = opclass->oid;
|
2001-08-21 18:36:06 +02:00
|
|
|
}
|
2002-03-20 20:45:13 +01:00
|
|
|
else if (IsBinaryCompatible(opclass->opcintype, attrType))
|
2001-08-21 18:36:06 +02:00
|
|
|
{
|
|
|
|
ncompatible++;
|
2002-04-17 22:57:57 +02:00
|
|
|
compatibleOid = opclass->oid;
|
2001-08-21 18:36:06 +02:00
|
|
|
}
|
2000-04-25 04:45:54 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-08-21 18:36:06 +02:00
|
|
|
if (nexact == 1)
|
|
|
|
return exactOid;
|
|
|
|
if (nexact != 0)
|
2002-04-17 22:57:57 +02:00
|
|
|
elog(ERROR, "pg_opclass contains multiple default opclasses for data type %s",
|
2001-08-21 18:36:06 +02:00
|
|
|
format_type_be(attrType));
|
|
|
|
if (ncompatible == 1)
|
|
|
|
return compatibleOid;
|
2000-11-16 23:30:52 +01:00
|
|
|
|
2001-08-21 18:36:06 +02:00
|
|
|
return InvalidOid;
|
1996-08-15 09:42:52 +02:00
|
|
|
}
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
1999-05-25 18:15:34 +02:00
|
|
|
* RemoveIndex
|
1997-09-07 07:04:48 +02:00
|
|
|
* Deletes an index.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
void
|
2002-07-01 17:27:56 +02:00
|
|
|
RemoveIndex(RangeVar *relation, DropBehavior behavior)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2002-03-26 20:17:02 +01:00
|
|
|
Oid indOid;
|
1997-09-08 04:41:22 +02:00
|
|
|
HeapTuple tuple;
|
2002-07-12 20:43:19 +02:00
|
|
|
ObjectAddress object;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2002-03-26 20:17:02 +01:00
|
|
|
indOid = RangeVarGetRelid(relation, false);
|
|
|
|
tuple = SearchSysCache(RELOID,
|
|
|
|
ObjectIdGetDatum(indOid),
|
2000-11-16 23:30:52 +01:00
|
|
|
0, 0, 0);
|
1997-09-07 07:04:48 +02:00
|
|
|
if (!HeapTupleIsValid(tuple))
|
2002-03-26 20:17:02 +01:00
|
|
|
elog(ERROR, "index \"%s\" does not exist", relation->relname);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
if (((Form_pg_class) GETSTRUCT(tuple))->relkind != RELKIND_INDEX)
|
1998-01-05 17:40:20 +01:00
|
|
|
elog(ERROR, "relation \"%s\" is of type \"%c\"",
|
2002-03-26 20:17:02 +01:00
|
|
|
relation->relname, ((Form_pg_class) GETSTRUCT(tuple))->relkind);
|
2000-11-16 23:30:52 +01:00
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
2002-03-26 20:17:02 +01:00
|
|
|
|
2002-07-12 20:43:19 +02:00
|
|
|
object.classId = RelOid_pg_class;
|
|
|
|
object.objectId = indOid;
|
|
|
|
object.objectSubId = 0;
|
|
|
|
|
|
|
|
performDeletion(&object, behavior);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
2000-02-18 10:30:20 +01:00
|
|
|
|
|
|
|
/*
|
2002-08-29 17:56:20 +02:00
|
|
|
* ReindexIndex
|
2000-02-18 10:30:20 +01:00
|
|
|
* Recreate an index.
|
|
|
|
*/
|
|
|
|
void
|
2002-03-26 20:17:02 +01:00
|
|
|
ReindexIndex(RangeVar *indexRelation, bool force /* currently unused */ )
|
2000-02-18 10:30:20 +01:00
|
|
|
{
|
2002-03-26 20:17:02 +01:00
|
|
|
Oid indOid;
|
2000-02-18 10:30:20 +01:00
|
|
|
HeapTuple tuple;
|
2001-02-23 10:26:14 +01:00
|
|
|
bool overwrite = false;
|
2000-02-18 10:30:20 +01:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* REINDEX within a transaction block is dangerous, because if the
|
|
|
|
* transaction is later rolled back we have no way to undo truncation
|
|
|
|
* of the index's physical file. Disallow it.
|
2000-11-08 23:10:03 +01:00
|
|
|
*/
|
|
|
|
if (IsTransactionBlock())
|
|
|
|
elog(ERROR, "REINDEX cannot run inside a BEGIN/END block");
|
|
|
|
|
2002-03-26 20:17:02 +01:00
|
|
|
indOid = RangeVarGetRelid(indexRelation, false);
|
|
|
|
tuple = SearchSysCache(RELOID,
|
|
|
|
ObjectIdGetDatum(indOid),
|
2000-11-16 23:30:52 +01:00
|
|
|
0, 0, 0);
|
2000-02-18 10:30:20 +01:00
|
|
|
if (!HeapTupleIsValid(tuple))
|
2002-03-26 20:17:02 +01:00
|
|
|
elog(ERROR, "index \"%s\" does not exist", indexRelation->relname);
|
2000-02-18 10:30:20 +01:00
|
|
|
|
|
|
|
if (((Form_pg_class) GETSTRUCT(tuple))->relkind != RELKIND_INDEX)
|
|
|
|
elog(ERROR, "relation \"%s\" is of type \"%c\"",
|
2002-03-26 20:17:02 +01:00
|
|
|
indexRelation->relname,
|
|
|
|
((Form_pg_class) GETSTRUCT(tuple))->relkind);
|
|
|
|
|
2002-08-29 17:56:20 +02:00
|
|
|
if (IsSystemClass((Form_pg_class) GETSTRUCT(tuple)) &&
|
|
|
|
!IsToastClass((Form_pg_class) GETSTRUCT(tuple)))
|
2002-04-12 22:38:31 +02:00
|
|
|
{
|
|
|
|
if (!allowSystemTableMods)
|
|
|
|
elog(ERROR, "\"%s\" is a system index. call REINDEX under standalone postgres with -O -P options",
|
|
|
|
indexRelation->relname);
|
|
|
|
if (!IsIgnoringSystemIndexes())
|
|
|
|
elog(ERROR, "\"%s\" is a system index. call REINDEX under standalone postgres with -P -O options",
|
|
|
|
indexRelation->relname);
|
|
|
|
}
|
|
|
|
|
2002-03-26 20:17:02 +01:00
|
|
|
ReleaseSysCache(tuple);
|
2000-02-18 10:30:20 +01:00
|
|
|
|
2001-02-23 10:26:14 +01:00
|
|
|
if (IsIgnoringSystemIndexes())
|
|
|
|
overwrite = true;
|
2002-03-26 20:17:02 +01:00
|
|
|
if (!reindex_index(indOid, force, overwrite))
|
|
|
|
elog(WARNING, "index \"%s\" wasn't reindexed", indexRelation->relname);
|
2000-02-18 10:30:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ReindexTable
|
|
|
|
* Recreate indexes of a table.
|
|
|
|
*/
|
|
|
|
void
|
2002-03-26 20:17:02 +01:00
|
|
|
ReindexTable(RangeVar *relation, bool force)
|
2000-02-18 10:30:20 +01:00
|
|
|
{
|
2002-03-26 20:17:02 +01:00
|
|
|
Oid heapOid;
|
2000-02-18 10:30:20 +01:00
|
|
|
HeapTuple tuple;
|
2002-08-29 17:56:20 +02:00
|
|
|
char relkind;
|
2000-02-18 10:30:20 +01:00
|
|
|
|
2001-03-22 07:16:21 +01:00
|
|
|
/*
|
|
|
|
* REINDEX within a transaction block is dangerous, because if the
|
|
|
|
* transaction is later rolled back we have no way to undo truncation
|
|
|
|
* of the index's physical file. Disallow it.
|
2000-11-08 23:10:03 +01:00
|
|
|
*/
|
|
|
|
if (IsTransactionBlock())
|
|
|
|
elog(ERROR, "REINDEX cannot run inside a BEGIN/END block");
|
|
|
|
|
2002-03-26 20:17:02 +01:00
|
|
|
heapOid = RangeVarGetRelid(relation, false);
|
|
|
|
tuple = SearchSysCache(RELOID,
|
|
|
|
ObjectIdGetDatum(heapOid),
|
2000-11-16 23:30:52 +01:00
|
|
|
0, 0, 0);
|
2000-02-18 10:30:20 +01:00
|
|
|
if (!HeapTupleIsValid(tuple))
|
2002-03-26 20:17:02 +01:00
|
|
|
elog(ERROR, "table \"%s\" does not exist", relation->relname);
|
2002-08-29 17:56:20 +02:00
|
|
|
relkind = ((Form_pg_class) GETSTRUCT(tuple))->relkind;
|
2000-02-18 10:30:20 +01:00
|
|
|
|
2002-08-29 17:56:20 +02:00
|
|
|
if (relkind != RELKIND_RELATION && relkind != RELKIND_TOASTVALUE)
|
2000-02-18 10:30:20 +01:00
|
|
|
elog(ERROR, "relation \"%s\" is of type \"%c\"",
|
2002-08-29 17:56:20 +02:00
|
|
|
relation->relname, relkind);
|
2000-11-16 23:30:52 +01:00
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
2002-03-26 20:17:02 +01:00
|
|
|
|
|
|
|
if (!reindex_relation(heapOid, force))
|
|
|
|
elog(WARNING, "table \"%s\" wasn't reindexed", relation->relname);
|
2000-02-18 10:30:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ReindexDatabase
|
|
|
|
* Recreate indexes of a database.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ReindexDatabase(const char *dbname, bool force, bool all)
|
|
|
|
{
|
2001-06-13 23:44:41 +02:00
|
|
|
Relation relationRelation;
|
2000-04-12 19:17:23 +02:00
|
|
|
HeapScanDesc scan;
|
2001-06-13 23:44:41 +02:00
|
|
|
HeapTuple tuple;
|
2000-06-28 05:33:33 +02:00
|
|
|
MemoryContext private_context;
|
2000-04-12 19:17:23 +02:00
|
|
|
MemoryContext old;
|
|
|
|
int relcnt,
|
|
|
|
relalc,
|
|
|
|
i,
|
|
|
|
oncealc = 200;
|
|
|
|
Oid *relids = (Oid *) NULL;
|
2000-02-18 10:30:20 +01:00
|
|
|
|
|
|
|
AssertArg(dbname);
|
|
|
|
|
2001-06-13 23:44:41 +02:00
|
|
|
if (strcmp(dbname, DatabaseName) != 0)
|
|
|
|
elog(ERROR, "REINDEX DATABASE: Can be executed only on the currently open database.");
|
2000-06-28 05:33:33 +02:00
|
|
|
|
2001-10-25 07:50:21 +02:00
|
|
|
if (!(superuser() || is_dbadmin(MyDatabaseId)))
|
2000-02-18 10:30:20 +01:00
|
|
|
elog(ERROR, "REINDEX DATABASE: Permission denied.");
|
|
|
|
|
2002-04-12 22:38:31 +02:00
|
|
|
if (!allowSystemTableMods)
|
|
|
|
elog(ERROR, "must be called under standalone postgres with -O -P options");
|
|
|
|
if (!IsIgnoringSystemIndexes())
|
|
|
|
elog(ERROR, "must be called under standalone postgres with -P -O options");
|
|
|
|
|
2000-06-28 05:33:33 +02:00
|
|
|
/*
|
2001-03-22 05:01:46 +01:00
|
|
|
* We cannot run inside a user transaction block; if we were inside a
|
|
|
|
* transaction, then our commit- and start-transaction-command calls
|
|
|
|
* would not have the intended effect!
|
2000-06-28 05:33:33 +02:00
|
|
|
*/
|
|
|
|
if (IsTransactionBlock())
|
|
|
|
elog(ERROR, "REINDEX DATABASE cannot run inside a BEGIN/END block");
|
|
|
|
|
|
|
|
/*
|
2001-03-22 05:01:46 +01:00
|
|
|
* Create a memory context that will survive forced transaction
|
|
|
|
* commits we do below. Since it is a child of QueryContext, it will
|
|
|
|
* go away eventually even if we suffer an error; there's no need for
|
|
|
|
* special abort cleanup logic.
|
2000-06-28 05:33:33 +02:00
|
|
|
*/
|
|
|
|
private_context = AllocSetContextCreate(QueryContext,
|
|
|
|
"ReindexDatabase",
|
|
|
|
ALLOCSET_DEFAULT_MINSIZE,
|
|
|
|
ALLOCSET_DEFAULT_INITSIZE,
|
|
|
|
ALLOCSET_DEFAULT_MAXSIZE);
|
2000-02-18 10:30:20 +01:00
|
|
|
|
2001-11-20 03:46:13 +01:00
|
|
|
/*
|
|
|
|
* Scan pg_class to build a list of the relations we need to reindex.
|
|
|
|
*/
|
2000-02-18 10:30:20 +01:00
|
|
|
relationRelation = heap_openr(RelationRelationName, AccessShareLock);
|
2002-05-21 01:51:44 +02:00
|
|
|
scan = heap_beginscan(relationRelation, SnapshotNow, 0, NULL);
|
2000-02-18 10:30:20 +01:00
|
|
|
relcnt = relalc = 0;
|
2002-05-21 01:51:44 +02:00
|
|
|
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
|
2000-02-18 10:30:20 +01:00
|
|
|
{
|
2002-08-29 17:56:20 +02:00
|
|
|
char relkind;
|
|
|
|
|
2000-02-18 10:30:20 +01:00
|
|
|
if (!all)
|
|
|
|
{
|
2002-08-29 17:56:20 +02:00
|
|
|
if (!(IsSystemClass((Form_pg_class) GETSTRUCT(tuple)) &&
|
|
|
|
!IsToastClass((Form_pg_class) GETSTRUCT(tuple))))
|
2000-02-18 10:30:20 +01:00
|
|
|
continue;
|
|
|
|
}
|
2002-08-29 17:56:20 +02:00
|
|
|
relkind = ((Form_pg_class) GETSTRUCT(tuple))->relkind;
|
|
|
|
if (relkind == RELKIND_RELATION || relkind == RELKIND_TOASTVALUE)
|
2000-02-18 10:30:20 +01:00
|
|
|
{
|
2000-06-28 05:33:33 +02:00
|
|
|
old = MemoryContextSwitchTo(private_context);
|
2000-02-18 10:30:20 +01:00
|
|
|
if (relcnt == 0)
|
|
|
|
{
|
|
|
|
relalc = oncealc;
|
|
|
|
relids = palloc(sizeof(Oid) * relalc);
|
|
|
|
}
|
|
|
|
else if (relcnt >= relalc)
|
|
|
|
{
|
|
|
|
relalc *= 2;
|
|
|
|
relids = repalloc(relids, sizeof(Oid) * relalc);
|
|
|
|
}
|
|
|
|
MemoryContextSwitchTo(old);
|
2002-07-20 07:16:59 +02:00
|
|
|
relids[relcnt] = HeapTupleGetOid(tuple);
|
2000-02-18 10:30:20 +01:00
|
|
|
relcnt++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
heap_endscan(scan);
|
|
|
|
heap_close(relationRelation, AccessShareLock);
|
|
|
|
|
2001-11-20 03:46:13 +01:00
|
|
|
/* Now reindex each rel in a separate transaction */
|
2000-02-18 10:30:20 +01:00
|
|
|
CommitTransactionCommand();
|
|
|
|
for (i = 0; i < relcnt; i++)
|
|
|
|
{
|
|
|
|
StartTransactionCommand();
|
2000-04-25 12:38:38 +02:00
|
|
|
if (reindex_relation(relids[i], force))
|
2002-08-29 17:56:20 +02:00
|
|
|
elog(NOTICE, "relation %u was reindexed", relids[i]);
|
2000-02-18 10:30:20 +01:00
|
|
|
CommitTransactionCommand();
|
|
|
|
}
|
|
|
|
StartTransactionCommand();
|
2000-06-28 05:33:33 +02:00
|
|
|
|
|
|
|
MemoryContextDelete(private_context);
|
2000-02-18 10:30:20 +01:00
|
|
|
}
|