IndexElem *n = makeNode(IndexElem);
n->name = $1;
n->expr = NULL;
+ n->indexcolname = NULL;
n->opclass = list_make1(makeString($2));
n->ordering = SORTBY_DEFAULT;
n->nulls_ordering = SORTBY_NULLS_DEFAULT;
/* non-export function prototypes */
static TupleDesc ConstructTupleDescriptor(Relation heapRelation,
IndexInfo *indexInfo,
+ List *indexColNames,
Oid accessMethodObjectId,
Oid *classObjectId);
static void InitializeAttributeOids(Relation indexRelation,
static TupleDesc
ConstructTupleDescriptor(Relation heapRelation,
IndexInfo *indexInfo,
+ List *indexColNames,
Oid accessMethodObjectId,
Oid *classObjectId)
{
int numatts = indexInfo->ii_NumIndexAttrs;
+ ListCell *colnames_item = list_head(indexColNames);
ListCell *indexpr_item = list_head(indexInfo->ii_Expressions);
HeapTuple amtuple;
Form_pg_am amform;
indexkey = (Node *) lfirst(indexpr_item);
indexpr_item = lnext(indexpr_item);
- /*
- * Make the attribute's name "pg_expresssion_nnn" (maybe think of
- * something better later)
- */
- sprintf(NameStr(to->attname), "pg_expression_%d", i + 1);
-
/*
* Lookup the expression type in pg_type for the type length etc.
*/
*/
to->attrelid = InvalidOid;
+ /*
+ * Set the attribute name as specified by caller.
+ */
+ if (colnames_item == NULL) /* shouldn't happen */
+ elog(ERROR, "too few entries in colnames list");
+ namestrcpy(&to->attname, (const char *) lfirst(colnames_item));
+ colnames_item = lnext(colnames_item);
+
/*
* Check the opclass and index AM to see if either provides a keytype
* (overriding the attribute type). Opclass takes precedence.
* generate an OID for the index. During bootstrap this may be
* nonzero to specify a preselected OID.
* indexInfo: same info executor uses to insert into the index
+ * indexColNames: column names to use for index (List of char *)
* accessMethodObjectId: OID of index AM to use
* tableSpaceId: OID of tablespace to use
* classObjectId: array of index opclass OIDs, one per index column
const char *indexRelationName,
Oid indexRelationId,
IndexInfo *indexInfo,
+ List *indexColNames,
Oid accessMethodObjectId,
Oid tableSpaceId,
Oid *classObjectId,
*/
indexTupDesc = ConstructTupleDescriptor(heapRelation,
indexInfo,
+ indexColNames,
accessMethodObjectId,
classObjectId);
toast_idxid = index_create(toast_relid, toast_idxname, toastIndexOid,
indexInfo,
+ list_make2("chunk_id", "chunk_seq"),
BTREE_AM_OID,
rel->rd_rel->reltablespace,
classObjectId, coloptions, (Datum) 0,
bool isconstraint);
static Oid GetIndexOpClass(List *opclass, Oid attrType,
char *accessMethodName, Oid accessMethodId);
+static char *ChooseIndexNameAddition(List *colnames);
static bool relationHasPrimaryKey(Relation rel);
Oid relationId;
Oid namespaceId;
Oid tablespaceId;
+ List *indexColNames;
Relation rel;
Relation indexRelation;
HeapTuple tuple;
if (rel->rd_rel->relisshared)
tablespaceId = GLOBALTABLESPACE_OID;
+ /*
+ * Choose the index column names.
+ */
+ indexColNames = ChooseIndexColumnNames(attributeList);
+
/*
* Select name for index if caller didn't specify
*/
if (indexRelationName == NULL)
- {
- if (primary)
- {
- indexRelationName = ChooseRelationName(RelationGetRelationName(rel),
- NULL,
- "pkey",
- namespaceId);
- }
- else if (exclusionOpNames != NIL)
- {
- IndexElem *iparam = (IndexElem *) linitial(attributeList);
-
- indexRelationName = ChooseRelationName(RelationGetRelationName(rel),
- iparam->name,
- "exclusion",
- namespaceId);
- }
- else
- {
- IndexElem *iparam = (IndexElem *) linitial(attributeList);
-
- indexRelationName = ChooseRelationName(RelationGetRelationName(rel),
- iparam->name,
- "key",
- namespaceId);
- }
- }
+ indexRelationName = ChooseIndexName(RelationGetRelationName(rel),
+ namespaceId,
+ indexColNames,
+ exclusionOpNames,
+ primary,
+ isconstraint);
/*
* look up the access method, verify it can handle the requested features
SET_LOCKTAG_RELATION(heaplocktag, heaprelid.dbId, heaprelid.relId);
heap_close(rel, NoLock);
- if (!concurrent)
- {
- indexRelationId =
- index_create(relationId, indexRelationName, indexRelationId,
- indexInfo, accessMethodId, tablespaceId, classObjectId,
- coloptions, reloptions, primary,
- isconstraint, deferrable, initdeferred,
- allowSystemTableMods, skip_build, concurrent);
-
- return; /* We're done, in the standard case */
- }
-
/*
- * For a concurrent build, we next insert the catalog entry and add
- * constraints. We don't build the index just yet; we must first make the
- * catalog entry so that the new index is visible to updating
- * transactions. That will prevent them from making incompatible HOT
- * updates. The new index will be marked not indisready and not
- * indisvalid, so that no one else tries to either insert into it or use
- * it for queries. We pass skip_build = true to prevent the build.
+ * Make the catalog entries for the index, including constraints.
+ * Then, if not skip_build || concurrent, actually build the index.
*/
indexRelationId =
index_create(relationId, indexRelationName, indexRelationId,
- indexInfo, accessMethodId, tablespaceId, classObjectId,
+ indexInfo, indexColNames,
+ accessMethodId, tablespaceId, classObjectId,
coloptions, reloptions, primary,
isconstraint, deferrable, initdeferred,
- allowSystemTableMods, true, concurrent);
+ allowSystemTableMods,
+ skip_build || concurrent,
+ concurrent);
+
+ if (!concurrent)
+ return; /* We're done, in the standard case */
/*
+ * For a concurrent build, it's important to make the catalog entries
+ * visible to other transactions before we start to build the index.
+ * That will prevent them from making incompatible HOT updates. The new
+ * index will be marked not indisready and not indisvalid, so that no one
+ * else tries to either insert into it or use it for queries.
+ *
* We must commit our current transaction so that the index becomes
* visible; then start another. Note that all the data structures we just
* built are lost in the commit. The only data we keep past here are the
return relname;
}
+/*
+ * Select the name to be used for an index.
+ *
+ * The argument list is pretty ad-hoc :-(
+ */
+char *
+ChooseIndexName(const char *tabname, Oid namespaceId,
+ List *colnames, List *exclusionOpNames,
+ bool primary, bool isconstraint)
+{
+ char *indexname;
+
+ if (primary)
+ {
+ /* the primary key's name does not depend on the specific column(s) */
+ indexname = ChooseRelationName(tabname,
+ NULL,
+ "pkey",
+ namespaceId);
+ }
+ else if (exclusionOpNames != NIL)
+ {
+ indexname = ChooseRelationName(tabname,
+ ChooseIndexNameAddition(colnames),
+ "exclusion",
+ namespaceId);
+ }
+ else if (isconstraint)
+ {
+ indexname = ChooseRelationName(tabname,
+ ChooseIndexNameAddition(colnames),
+ "key",
+ namespaceId);
+ }
+ else
+ {
+ indexname = ChooseRelationName(tabname,
+ ChooseIndexNameAddition(colnames),
+ "idx",
+ namespaceId);
+ }
+
+ return indexname;
+}
+
+/*
+ * Generate "name2" for a new index given the list of column names for it
+ * (as produced by ChooseIndexColumnNames). This will be passed to
+ * ChooseRelationName along with the parent table name and a suitable label.
+ *
+ * We know that less than NAMEDATALEN characters will actually be used,
+ * so we can truncate the result once we've generated that many.
+ */
+static char *
+ChooseIndexNameAddition(List *colnames)
+{
+ char buf[NAMEDATALEN * 2];
+ int buflen = 0;
+ ListCell *lc;
+
+ buf[0] = '\0';
+ foreach(lc, colnames)
+ {
+ const char *name = (const char *) lfirst(lc);
+
+ if (buflen > 0)
+ buf[buflen++] = '_'; /* insert _ between names */
+
+ /*
+ * At this point we have buflen <= NAMEDATALEN. name should be less
+ * than NAMEDATALEN already, but use strlcpy for paranoia.
+ */
+ strlcpy(buf + buflen, name, NAMEDATALEN);
+ buflen += strlen(buf + buflen);
+ if (buflen >= NAMEDATALEN)
+ break;
+ }
+ return pstrdup(buf);
+}
+
+/*
+ * Select the actual names to be used for the columns of an index, given the
+ * list of IndexElems for the columns. This is mostly about ensuring the
+ * names are unique so we don't get a conflicting-attribute-names error.
+ *
+ * Returns a List of plain strings (char *, not String nodes).
+ */
+List *
+ChooseIndexColumnNames(List *indexElems)
+{
+ List *result = NIL;
+ ListCell *lc;
+
+ foreach(lc, indexElems)
+ {
+ IndexElem *ielem = (IndexElem *) lfirst(lc);
+ const char *origname;
+ const char *curname;
+ int i;
+ char buf[NAMEDATALEN];
+
+ /* Get the preliminary name from the IndexElem */
+ if (ielem->indexcolname)
+ origname = ielem->indexcolname; /* caller-specified name */
+ else if (ielem->name)
+ origname = ielem->name; /* simple column reference */
+ else
+ origname = "expr"; /* default name for expression */
+
+ /* If it conflicts with any previous column, tweak it */
+ curname = origname;
+ for (i = 1;; i++)
+ {
+ ListCell *lc2;
+ char nbuf[32];
+ int nlen;
+
+ foreach(lc2, result)
+ {
+ if (strcmp(curname, (char *) lfirst(lc2)) == 0)
+ break;
+ }
+ if (lc2 == NULL)
+ break; /* found nonconflicting name */
+
+ sprintf(nbuf, "%d", i);
+
+ /* Ensure generated names are shorter than NAMEDATALEN */
+ nlen = pg_mbcliplen(origname, strlen(origname),
+ NAMEDATALEN - 1 - strlen(nbuf));
+ memcpy(buf, origname, nlen);
+ strcpy(buf + nlen, nbuf);
+ curname = buf;
+ }
+
+ /* And attach to the result list */
+ result = lappend(result, pstrdup(curname));
+ }
+ return result;
+}
+
/*
* relationHasPrimaryKey -
*
COPY_STRING_FIELD(name);
COPY_NODE_FIELD(expr);
+ COPY_STRING_FIELD(indexcolname);
COPY_NODE_FIELD(opclass);
COPY_SCALAR_FIELD(ordering);
COPY_SCALAR_FIELD(nulls_ordering);
{
COMPARE_STRING_FIELD(name);
COMPARE_NODE_FIELD(expr);
+ COMPARE_STRING_FIELD(indexcolname);
COMPARE_NODE_FIELD(opclass);
COMPARE_SCALAR_FIELD(ordering);
COMPARE_SCALAR_FIELD(nulls_ordering);
WRITE_STRING_FIELD(name);
WRITE_NODE_FIELD(expr);
+ WRITE_STRING_FIELD(indexcolname);
WRITE_NODE_FIELD(opclass);
WRITE_ENUM_FIELD(ordering, SortByDir);
WRITE_ENUM_FIELD(nulls_ordering, SortByNulls);
$$ = makeNode(IndexElem);
$$->name = $1;
$$->expr = NULL;
+ $$->indexcolname = NULL;
$$->opclass = $2;
$$->ordering = $3;
$$->nulls_ordering = $4;
$$ = makeNode(IndexElem);
$$->name = NULL;
$$->expr = $1;
+ $$->indexcolname = NULL;
$$->opclass = $2;
$$->ordering = $3;
$$->nulls_ordering = $4;
$$ = makeNode(IndexElem);
$$->name = NULL;
$$->expr = $2;
+ $$->indexcolname = NULL;
$$->opclass = $4;
$$->ordering = $5;
$$->nulls_ordering = $6;
{
char *name = NULL;
- FigureColnameInternal(node, &name);
+ (void) FigureColnameInternal(node, &name);
if (name != NULL)
return name;
/* default result if we can't guess anything */
return "?column?";
}
+/*
+ * FigureIndexColname -
+ * choose the name for an expression column in an index
+ *
+ * This is actually just like FigureColname, except we return NULL if
+ * we can't pick a good name.
+ */
+char *
+FigureIndexColname(Node *node)
+{
+ char *name = NULL;
+
+ (void) FigureColnameInternal(node, &name);
+ return name;
+}
+
+/*
+ * FigureColnameInternal -
+ * internal workhorse for FigureColname
+ *
+ * Return value indicates strength of confidence in result:
+ * 0 - no information
+ * 1 - second-best name choice
+ * 2 - good name choice
+ * The return value is actually only used internally.
+ * If the result isn't zero, *name is set to the chosen name.
+ */
static int
FigureColnameInternal(Node *node, char **name)
{
#include "parser/parse_clause.h"
#include "parser/parse_expr.h"
#include "parser/parse_relation.h"
+#include "parser/parse_target.h"
#include "parser/parse_type.h"
#include "parser/parse_utilcmd.h"
#include "parser/parser.h"
/*
* chooseIndexName
*
- * Set name for unnamed index. See also the same logic in DefineIndex.
+ * Compute name for an index. This must match code in indexcmds.c.
+ *
+ * XXX this is inherently broken because the indexes aren't created
+ * immediately, so we fail to resolve conflicts when the same name is
+ * derived for multiple indexes. However, that's a reasonably uncommon
+ * situation, so we'll live with it for now.
*/
static char *
chooseIndexName(const RangeVar *relation, IndexStmt *index_stmt)
{
- Oid namespaceId;
+ Oid namespaceId;
+ List *colnames;
namespaceId = RangeVarGetCreationNamespace(relation);
- if (index_stmt->primary)
- {
- /* no need for column list with pkey */
- return ChooseRelationName(relation->relname, NULL,
- "pkey", namespaceId);
- }
- else if (index_stmt->excludeOpNames != NIL)
- {
- IndexElem *iparam = (IndexElem *) linitial(index_stmt->indexParams);
-
- return ChooseRelationName(relation->relname, iparam->name,
- "exclusion", namespaceId);
- }
- else
- {
- IndexElem *iparam = (IndexElem *) linitial(index_stmt->indexParams);
-
- return ChooseRelationName(relation->relname, iparam->name,
- "key", namespaceId);
- }
+ colnames = ChooseIndexColumnNames(index_stmt->indexParams);
+ return ChooseIndexName(relation->relname, namespaceId,
+ colnames, index_stmt->excludeOpNames,
+ index_stmt->primary, index_stmt->isconstraint);
}
/*
AttrNumber *attmap)
{
Oid source_relid = RelationGetRelid(source_idx);
+ Form_pg_attribute *attrs = RelationGetDescr(source_idx)->attrs;
HeapTuple ht_idxrel;
HeapTuple ht_idx;
Form_pg_class idxrelrec;
keycoltype = exprType(indexkey);
}
+ /* Copy the original index column name */
+ iparam->indexcolname = pstrdup(NameStr(attrs[keyno]->attname));
+
/* Add the operator class name, if non-default */
iparam->opclass = get_opclass(indclass->values[keyno], keycoltype);
iparam = makeNode(IndexElem);
iparam->name = pstrdup(key);
iparam->expr = NULL;
+ iparam->indexcolname = NULL;
iparam->opclass = NIL;
iparam->ordering = SORTBY_DEFAULT;
iparam->nulls_ordering = SORTBY_NULLS_DEFAULT;
if (ielem->expr)
{
+ /* Extract preliminary index col name before transforming expr */
+ if (ielem->indexcolname == NULL)
+ ielem->indexcolname = FigureIndexColname(ielem->expr);
+
+ /* Now do parse transformation of the expression */
ielem->expr = transformExpr(pstate, ielem->expr);
/*
const char *indexRelationName,
Oid indexRelationId,
IndexInfo *indexInfo,
+ List *indexColNames,
Oid accessMethodObjectId,
Oid tableSpaceId,
Oid *classObjectId,
const char *label);
extern char *ChooseRelationName(const char *name1, const char *name2,
const char *label, Oid namespaceid);
+extern char *ChooseIndexName(const char *tabname, Oid namespaceId,
+ List *colnames, List *exclusionOpNames,
+ bool primary, bool isconstraint);
+extern List *ChooseIndexColumnNames(List *indexElems);
extern Oid GetDefaultOpClass(Oid type_id, Oid am_id);
/* commands/functioncmds.c */
NodeTag type;
char *name; /* name of attribute to index, or NULL */
Node *expr; /* expression to index, or NULL */
+ char *indexcolname; /* name for index column; NULL = default */
List *opclass; /* name of desired opclass; NIL = default */
SortByDir ordering; /* ASC/DESC/default */
SortByNulls nulls_ordering; /* FIRST/LAST/default */
extern TupleDesc expandRecordVariable(ParseState *pstate, Var *var,
int levelsup);
extern char *FigureColname(Node *node);
+extern char *FigureIndexColname(Node *node);
#endif /* PARSE_TARGET_H */
NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "tmp2_pkey" for table "tmp2"
CREATE TABLE tmp3 (a int, b int);
CREATE TABLE tmp4 (a int, b int, unique(a,b));
-NOTICE: CREATE TABLE / UNIQUE will create implicit index "tmp4_a_key" for table "tmp4"
+NOTICE: CREATE TABLE / UNIQUE will create implicit index "tmp4_a_b_key" for table "tmp4"
CREATE TABLE tmp5 (a int, b int);
-- Insert rows into tmp2 (pktable)
INSERT INTO tmp2 values (1);
DROP TABLE PKTABLE;
-- Test for referencing column number smaller than referenced constraint
CREATE TABLE PKTABLE (ptest1 int, ptest2 int, UNIQUE(ptest1, ptest2));
-NOTICE: CREATE TABLE / UNIQUE will create implicit index "pktable_ptest1_key" for table "pktable"
+NOTICE: CREATE TABLE / UNIQUE will create implicit index "pktable_ptest1_ptest2_key" for table "pktable"
CREATE TABLE FKTABLE_FAIL1 (ftest1 int REFERENCES pktable(ptest1));
ERROR: there is no unique constraint matching given keys for referenced table "pktable"
DROP TABLE FKTABLE_FAIL1;
create table pktable_base (base1 int not null);
create table pktable (ptest1 int, primary key(base1), unique(base1, ptest1)) inherits (pktable_base);
NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "pktable_pkey" for table "pktable"
-NOTICE: CREATE TABLE / UNIQUE will create implicit index "pktable_base1_key" for table "pktable"
+NOTICE: CREATE TABLE / UNIQUE will create implicit index "pktable_base1_ptest1_key" for table "pktable"
create table fktable (ftest1 int references pktable(base1));
-- now some ins, upd, del
insert into pktable(base1) values (1);
NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "pktable_pkey" for table "pktable"
NOTICE: CREATE TABLE / UNIQUE will create implicit index "pktable_id2_key" for table "pktable"
NOTICE: CREATE TABLE / UNIQUE will create implicit index "pktable_id3_key" for table "pktable"
-NOTICE: CREATE TABLE / UNIQUE will create implicit index "pktable_id1_key" for table "pktable"
+NOTICE: CREATE TABLE / UNIQUE will create implicit index "pktable_id1_id2_id3_key" for table "pktable"
CREATE TEMP TABLE fktable (
x1 INT4 REFERENCES pktable(id1),
x2 VARCHAR(4) REFERENCES pktable(id2),
b | text | | extended | B
Indexes:
"t_all_pkey" PRIMARY KEY, btree (a)
- "t_all_b_key" btree (b)
- "t_all_key" btree ((a || b))
+ "t_all_b_idx" btree (b)
+ "t_all_expr_idx" btree ((a || b))
Check constraints:
"t1_a_check" CHECK (length(a) > 2)
Has OIDs: no
SELECT c.relname, objsubid, description FROM pg_description, pg_index i, pg_class c WHERE classoid = 'pg_class'::regclass AND objoid = i.indexrelid AND c.oid = i.indexrelid AND i.indrelid = 't_all'::regclass ORDER BY c.relname, objsubid;
relname | objsubid | description
-------------+----------+-------------
- t_all_b_key | 0 | index b_key
+ t_all_b_idx | 0 | index b_key
t_all_pkey | 0 | index pkey
(2 rows)
DROP TABLE UNIQUE_TBL;
CREATE TABLE UNIQUE_TBL (i int, t text,
UNIQUE(i,t));
-NOTICE: CREATE TABLE / UNIQUE will create implicit index "unique_tbl_i_key" for table "unique_tbl"
+NOTICE: CREATE TABLE / UNIQUE will create implicit index "unique_tbl_i_t_key" for table "unique_tbl"
INSERT INTO UNIQUE_TBL VALUES (1, 'one');
INSERT INTO UNIQUE_TBL VALUES (2, 'two');
INSERT INTO UNIQUE_TBL VALUES (1, 'three');
INSERT INTO UNIQUE_TBL VALUES (1, 'one');
-ERROR: duplicate key value violates unique constraint "unique_tbl_i_key"
+ERROR: duplicate key value violates unique constraint "unique_tbl_i_t_key"
DETAIL: Key (i, t)=(1, one) already exists.
INSERT INTO UNIQUE_TBL VALUES (5, 'one');
INSERT INTO UNIQUE_TBL (t) VALUES ('six');
(c1 WITH &&, (c2::circle) WITH ~=)
WHERE (circle_center(c1) <> '(0,0)')
);
-NOTICE: CREATE TABLE / EXCLUDE will create implicit index "circles_c1_exclusion" for table "circles"
+NOTICE: CREATE TABLE / EXCLUDE will create implicit index "circles_c1_c2_exclusion" for table "circles"
-- these should succeed because they don't match the index predicate
INSERT INTO circles VALUES('<(0,0), 5>', '<(0,0), 5>');
INSERT INTO circles VALUES('<(0,0), 5>', '<(0,0), 5>');
INSERT INTO circles VALUES('<(10,10), 10>', '<(0,0), 5>');
-- fail, overlaps
INSERT INTO circles VALUES('<(20,20), 10>', '<(0,0), 5>');
-ERROR: conflicting key value violates exclusion constraint "circles_c1_exclusion"
+ERROR: conflicting key value violates exclusion constraint "circles_c1_c2_exclusion"
DETAIL: Key (c1, (c2::circle))=(<(20,20),10>, <(0,0),5>) conflicts with existing key (c1, (c2::circle))=(<(10,10),10>, <(0,0),5>).
-- succeed because c1 doesn't overlap
INSERT INTO circles VALUES('<(20,20), 1>', '<(0,0), 5>');
-- should fail on existing data without the WHERE clause
ALTER TABLE circles ADD EXCLUDE USING gist
(c1 WITH &&, (c2::circle) WITH ~=);
-NOTICE: ALTER TABLE / ADD EXCLUDE will create implicit index "circles_c1_exclusion1" for table "circles"
-ERROR: could not create exclusion constraint "circles_c1_exclusion1"
+NOTICE: ALTER TABLE / ADD EXCLUDE will create implicit index "circles_c1_c2_exclusion1" for table "circles"
+ERROR: could not create exclusion constraint "circles_c1_c2_exclusion1"
DETAIL: Key (c1, (c2::circle))=(<(0,0),5>, <(0,0),5>) conflicts with key (c1, (c2::circle))=(<(0,0),5>, <(0,0),5>).
DROP TABLE circles;
-- Check deferred exclusion constraint
projects / users / andresfreund / postgres.git / commitdiff