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
|
2003-05-14 05:26:03 +02:00
|
|
|
* $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.99 2003/05/14 03:26:01 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"
|
2003-01-02 20:29:22 +01:00
|
|
|
#include "catalog/heap.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"
|
2003-01-02 20:29:22 +01:00
|
|
|
#include "commands/tablecmds.h"
|
2002-12-13 20:46:01 +01:00
|
|
|
#include "executor/executor.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-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-09-23 02:42:48 +02:00
|
|
|
!IndexesAreActive(rel))
|
2002-01-04 00:21:32 +01:00
|
|
|
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.
|
2002-09-04 22:31:48 +02:00
|
|
|
* (Presumably we did when the rel was created, but maybe not
|
|
|
|
* anymore.) Skip check if bootstrapping, since permissions machinery
|
|
|
|
* may not 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
|
|
|
*/
|
2002-12-12 16:49:42 +01:00
|
|
|
if (predicate)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
2001-08-06 20:09:45 +02:00
|
|
|
cnfPred = canonicalize_qual((Expr *) copyObject(predicate), true);
|
1997-09-07 07:04:48 +02:00
|
|
|
CheckPredicate(cnfPred, rangetable, relationId);
|
|
|
|
}
|
|
|
|
|
2003-01-02 20:29:22 +01:00
|
|
|
/*
|
|
|
|
* Check that all of the attributes in a primary key are marked
|
|
|
|
* as not null, otherwise attempt to ALTER TABLE .. SET NOT NULL
|
|
|
|
*/
|
|
|
|
if (primary && !IsFuncIndex(attributeList))
|
|
|
|
{
|
|
|
|
List *keys;
|
|
|
|
|
|
|
|
foreach(keys, attributeList)
|
|
|
|
{
|
|
|
|
IndexElem *key = (IndexElem *) lfirst(keys);
|
|
|
|
HeapTuple atttuple;
|
|
|
|
|
|
|
|
/* System attributes are never null, so no problem */
|
|
|
|
if (SystemAttributeByName(key->name, rel->rd_rel->relhasoids))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
atttuple = SearchSysCacheAttName(relationId, key->name);
|
|
|
|
if (HeapTupleIsValid(atttuple))
|
|
|
|
{
|
|
|
|
if (! ((Form_pg_attribute) GETSTRUCT(atttuple))->attnotnull)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Try to make it NOT NULL.
|
|
|
|
*
|
|
|
|
* XXX: Shouldn't the ALTER TABLE .. SET NOT NULL cascade
|
|
|
|
* to child tables? Currently, since the PRIMARY KEY
|
|
|
|
* itself doesn't cascade, we don't cascade the notnull
|
|
|
|
* constraint either; but this is pretty debatable.
|
|
|
|
*/
|
|
|
|
AlterTableAlterColumnSetNotNull(relationId, false,
|
|
|
|
key->name);
|
|
|
|
}
|
|
|
|
ReleaseSysCache(atttuple);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* This shouldn't happen if parser did its job ... */
|
|
|
|
elog(ERROR, "DefineIndex: column \"%s\" named in key does not exist",
|
|
|
|
key->name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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;
|
2002-12-15 17:17:59 +01:00
|
|
|
indexInfo->ii_PredicateState = NIL;
|
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-09-04 22:31:48 +02:00
|
|
|
* A predicate using mutable functions is probably wrong, for the same
|
|
|
|
* reasons that we don't allow a functional index to use one.
|
2001-07-17 23:53:01 +02:00
|
|
|
*/
|
2002-04-05 02:31:36 +02:00
|
|
|
if (contain_mutable_functions((Node *) predList))
|
2003-01-23 16:18:40 +01:00
|
|
|
elog(ERROR, "Functions in index predicate must be marked IMMUTABLE");
|
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))
|
2003-01-02 20:29:22 +01:00
|
|
|
elog(ERROR, "DefineIndex: column \"%s\" named in key does not exist", 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
|
|
|
{
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
if (!IsBinaryCoercible(argTypes[i], true_typeids[i]))
|
|
|
|
func_error("DefineIndex", funcIndex->funcname, nargs, true_typeids,
|
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)
|
2003-01-23 16:18:40 +01:00
|
|
|
elog(ERROR, "DefineIndex: index function must be marked IMMUTABLE");
|
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 */
|
2002-09-04 22:31:48 +02:00
|
|
|
Oid namespaceId;
|
2002-04-17 22:57:57 +02:00
|
|
|
|
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);
|
|
|
|
|
|
|
|
/*
|
2002-09-04 22:31:48 +02:00
|
|
|
* Verify that the index operator class accepts this datatype. Note
|
|
|
|
* we will accept binary compatibility.
|
2002-04-17 22:57:57 +02:00
|
|
|
*/
|
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
|
|
|
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
if (!IsBinaryCoercible(attrType, opInputType))
|
2001-08-21 18:36:06 +02:00
|
|
|
elog(ERROR, "operator class \"%s\" does not accept data type %s",
|
2002-09-04 22:31:48 +02:00
|
|
|
NameListToString(attribute->opclass), format_type_be(attrType));
|
2002-04-17 22:57:57 +02:00
|
|
|
|
|
|
|
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
|
|
|
}
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
else if (IsBinaryCoercible(attrType, opclass->opcintype))
|
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;
|
2002-09-20 01:40:56 +02:00
|
|
|
char relkind;
|
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);
|
2002-09-20 01:40:56 +02:00
|
|
|
relkind = get_rel_relkind(indOid);
|
|
|
|
if (relkind != RELKIND_INDEX)
|
1998-01-05 17:40:20 +01:00
|
|
|
elog(ERROR, "relation \"%s\" is of type \"%c\"",
|
2002-09-20 01:40:56 +02:00
|
|
|
relation->relname, relkind);
|
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;
|
2002-10-22 00:06:20 +02:00
|
|
|
bool overwrite;
|
2000-02-18 10:30:20 +01:00
|
|
|
|
2002-10-22 00:06:20 +02:00
|
|
|
/* Choose in-place-or-not mode */
|
|
|
|
overwrite = IsIgnoringSystemIndexes();
|
2000-11-08 23:10:03 +01:00
|
|
|
|
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
|
|
|
|
2002-10-22 00:06:20 +02:00
|
|
|
/*
|
|
|
|
* In-place 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.
|
|
|
|
*/
|
|
|
|
if (overwrite)
|
|
|
|
PreventTransactionChain((void *) indexRelation, "REINDEX");
|
|
|
|
|
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;
|
2002-08-29 17:56:20 +02:00
|
|
|
char relkind;
|
2000-02-18 10:30:20 +01:00
|
|
|
|
2002-03-26 20:17:02 +01:00
|
|
|
heapOid = RangeVarGetRelid(relation, false);
|
2002-09-20 01:40:56 +02:00
|
|
|
relkind = get_rel_relkind(heapOid);
|
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
|
|
|
|
2002-10-22 00:06:20 +02:00
|
|
|
/*
|
|
|
|
* In-place 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.
|
|
|
|
*
|
|
|
|
* XXX we assume that in-place reindex will only be done if
|
|
|
|
* IsIgnoringSystemIndexes() is true.
|
|
|
|
*/
|
|
|
|
if (IsIgnoringSystemIndexes())
|
|
|
|
PreventTransactionChain((void *) relation, "REINDEX");
|
|
|
|
|
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
|
|
|
*/
|
2002-10-22 00:06:20 +02:00
|
|
|
PreventTransactionChain((void *) dbname, "REINDEX");
|
2002-10-19 22:15:09 +02:00
|
|
|
|
2000-06-28 05:33:33 +02:00
|
|
|
/*
|
2001-03-22 05:01:46 +01:00
|
|
|
* Create a memory context that will survive forced transaction
|
2003-05-02 22:54:36 +02:00
|
|
|
* commits we do below. Since it is a child of PortalContext, it will
|
2001-03-22 05:01:46 +01:00
|
|
|
* 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
|
|
|
*/
|
2003-05-02 22:54:36 +02:00
|
|
|
private_context = AllocSetContextCreate(PortalContext,
|
2000-06-28 05:33:33 +02:00
|
|
|
"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-09-04 22:31:48 +02:00
|
|
|
char relkind;
|
2002-08-29 17:56:20 +02:00
|
|
|
|
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 */
|
2003-05-14 05:26:03 +02:00
|
|
|
CommitTransactionCommand();
|
2000-02-18 10:30:20 +01:00
|
|
|
for (i = 0; i < relcnt; i++)
|
|
|
|
{
|
2003-05-14 05:26:03 +02:00
|
|
|
StartTransactionCommand();
|
2002-10-19 22:15:09 +02:00
|
|
|
SetQuerySnapshot(); /* might be needed for functional index */
|
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]);
|
2003-05-14 05:26:03 +02:00
|
|
|
CommitTransactionCommand();
|
2000-02-18 10:30:20 +01:00
|
|
|
}
|
2003-05-14 05:26:03 +02:00
|
|
|
StartTransactionCommand();
|
2000-06-28 05:33:33 +02:00
|
|
|
|
|
|
|
MemoryContextDelete(private_context);
|
2000-02-18 10:30:20 +01:00
|
|
|
}
|