开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
indexcmds.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：14k
源码类别：

数据库系统

开发平台：

Unix_Linux

indexcmds.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * defind.c
  4.  *   POSTGRES define, extend and remove index code.
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.4.2.1 1999/08/02 05:56:58 scrappy Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  15. #include "postgres.h"
  17. #include "access/genam.h"
  18. #include "access/heapam.h"
  19. #include "catalog/heap.h"
  20. #include "catalog/index.h"
  21. #include "catalog/pg_index.h"
  22. #include "catalog/pg_opclass.h"
  23. #include "catalog/pg_proc.h"
  24. #include "catalog/pg_type.h"
  25. #include "commands/defrem.h"
  26. #include "optimizer/clauses.h"
  27. #include "optimizer/prep.h"
  28. #include "parser/parsetree.h"
  29. #include "utils/builtins.h"
  30. #include "utils/syscache.h"
  32. #define IsFuncIndex(ATTR_LIST) (((IndexElem*)lfirst(ATTR_LIST))->args!=NULL)
  34. /* non-export function prototypes */
  35. static void CheckPredicate(List *predList, List *rangeTable, Oid baseRelOid);
  36. static void CheckPredExpr(Node *predicate, List *rangeTable,
  37.   Oid baseRelOid);
  38. static void
  39. CheckPredClause(Expr *predicate, List *rangeTable, Oid baseRelOid);
  40. static void FuncIndexArgs(IndexElem *funcIndex, AttrNumber *attNumP,
  41.   Oid *argTypes, Oid *opOidP, Oid relId);
  42. static void NormIndexAttrs(List *attList, AttrNumber *attNumP,
  43.    Oid *opOidP, Oid relId);
  44. static char *GetDefaultOpClass(Oid atttypid);
  46. /*
  47.  * DefineIndex
  48.  * Creates a new index.
  49.  *
  50.  * 'attributeList' is a list of IndexElem specifying either a functional
  51.  * index or a list of attributes to index on.
  52.  * 'parameterList' is a list of ParamString specified in the with clause.
  53.  * 'predicate' is the qual specified in the where clause.
  54.  * 'rangetable' is for the predicate
  55.  *
  56.  * Exceptions:
  57.  * XXX
  58.  */
  59. void
  60. DefineIndex(char *heapRelationName,
  61. char *indexRelationName,
  62. char *accessMethodName,
  63. List *attributeList,
  64. List *parameterList,
  65. bool unique,
  66. bool primary,
  67. Expr *predicate,
  68. List *rangetable)
  69. {
  70. Oid    *classObjectId;
  71. Oid accessMethodId;
  72. Oid relationId;
  73. int numberOfAttributes;
  74. AttrNumber *attributeNumberA;
  75. HeapTuple tuple;
  76. uint16 parameterCount = 0;
  77. Datum    *parameterA = NULL;
  78. FuncIndexInfo fInfo;
  79. List    *cnfPred = NULL;
  80. bool lossy = FALSE;
  81. List    *pl;
  83. /*
  84.  * Handle attributes
  85.  */
  86. numberOfAttributes = length(attributeList);
  87. if (numberOfAttributes <= 0)
  88. elog(ERROR, "DefineIndex: must specify at least one attribute");
  90. /*
  91.  * compute heap relation id
  92.  */
  93. if ((relationId = RelnameFindRelid(heapRelationName)) == InvalidOid)
  94. {
  95. elog(ERROR, "DefineIndex: %s relation not found",
  96.  heapRelationName);
  97. }
  99. if (unique && strcmp(accessMethodName, "btree") != 0)
  100. elog(ERROR, "DefineIndex: unique indices are only available with the btree access method");
  102. if (numberOfAttributes > 1 && strcmp(accessMethodName, "btree") != 0)
  103. elog(ERROR, "DefineIndex: multi-column indices are only available with the btree access method");
  105. /*
  106.  * compute access method id
  107.  */
  108. tuple = SearchSysCacheTuple(AMNAME,
  109. PointerGetDatum(accessMethodName),
  110. 0, 0, 0);
  111. if (!HeapTupleIsValid(tuple))
  112. {
  113. elog(ERROR, "DefineIndex: %s access method not found",
  114.  accessMethodName);
  115. }
  116. accessMethodId = tuple->t_data->t_oid;
  119. /*
  120.  * Handle parameters [param list is now different (NOT USED, really) -
  121.  * ay 10/94]
  122.  *
  123.  * WITH clause reinstated to handle lossy indices. -- JMH, 7/22/96
  124.  */
  125. foreach(pl, parameterList)
  126. {
  127. ParamString *param = (ParamString *) lfirst(pl);
  129. if (!strcasecmp(param->name, "islossy"))
  130. lossy = TRUE;
  131. }
  134. /*
  135.  * Convert the partial-index predicate from parsetree form to plan
  136.  * form, so it can be readily evaluated during index creation. Note:
  137.  * "predicate" comes in as a list containing (1) the predicate itself
  138.  * (a where_clause), and (2) a corresponding range table.
  139.  *
  140.  * [(1) is 'predicate' and (2) is 'rangetable' now. - ay 10/94]
  141.  */
  142. if (predicate != NULL && rangetable != NIL)
  143. {
  144. cnfPred = cnfify((Expr *) copyObject(predicate), true);
  145. fix_opids(cnfPred);
  146. CheckPredicate(cnfPred, rangetable, relationId);
  147. }
  149. if (IsFuncIndex(attributeList))
  150. {
  151. IndexElem  *funcIndex = lfirst(attributeList);
  152. int nargs;
  154. nargs = length(funcIndex->args);
  155. if (nargs > INDEX_MAX_KEYS)
  156. {
  157. elog(ERROR,
  158.    "Too many args to function, limit of %d", INDEX_MAX_KEYS);
  159. }
  161. FIsetnArgs(&fInfo, nargs);
  163. strcpy(FIgetname(&fInfo), funcIndex->name);
  165. attributeNumberA = (AttrNumber *) palloc(nargs * sizeof attributeNumberA[0]);
  167. classObjectId = (Oid *) palloc(sizeof classObjectId[0]);
  170. FuncIndexArgs(funcIndex, attributeNumberA,
  171.   &(FIgetArg(&fInfo, 0)),
  172.   classObjectId, relationId);
  174. index_create(heapRelationName,
  175.  indexRelationName,
  176.  &fInfo, NULL, accessMethodId,
  177.  numberOfAttributes, attributeNumberA,
  178.  classObjectId, parameterCount, parameterA, (Node *) cnfPred,
  179.  lossy, unique, primary);
  180. }
  181. else
  182. {
  183. attributeNumberA = (AttrNumber *) palloc(numberOfAttributes *
  184.  sizeof attributeNumberA[0]);
  186. classObjectId = (Oid *) palloc(numberOfAttributes * sizeof classObjectId[0]);
  188. NormIndexAttrs(attributeList, attributeNumberA,
  189.    classObjectId, relationId);
  191. index_create(heapRelationName, indexRelationName, NULL,
  192.  attributeList,
  193.  accessMethodId, numberOfAttributes, attributeNumberA,
  194.  classObjectId, parameterCount, parameterA, (Node *) cnfPred,
  195.  lossy, unique, primary);
  196. }
  197. }
  200. /*
  201.  * ExtendIndex
  202.  * Extends a partial index.
  203.  *
  204.  * Exceptions:
  205.  * XXX
  206.  */
  207. void
  208. ExtendIndex(char *indexRelationName, Expr *predicate, List *rangetable)
  209. {
  210. Oid    *classObjectId;
  211. Oid accessMethodId;
  212. Oid indexId,
  213. relationId;
  214. Oid indproc;
  215. int numberOfAttributes;
  216. AttrNumber *attributeNumberA;
  217. HeapTuple tuple;
  218. FuncIndexInfo fInfo;
  219. FuncIndexInfo *funcInfo = NULL;
  220. Form_pg_index index;
  221. Node    *oldPred = NULL;
  222. List    *cnfPred = NULL;
  223. PredInfo   *predInfo;
  224. Relation heapRelation;
  225. Relation indexRelation;
  226. int i;
  228. /*
  229.  * compute index relation id and access method id
  230.  */
  231. tuple = SearchSysCacheTuple(RELNAME,
  232. PointerGetDatum(indexRelationName),
  233. 0, 0, 0);
  234. if (!HeapTupleIsValid(tuple))
  235. {
  236. elog(ERROR, "ExtendIndex: %s index not found",
  237.  indexRelationName);
  238. }
  239. indexId = tuple->t_data->t_oid;
  240. accessMethodId = ((Form_pg_class) GETSTRUCT(tuple))->relam;
  242. /*
  243.  * find pg_index tuple
  244.  */
  245. tuple = SearchSysCacheTuple(INDEXRELID,
  246. ObjectIdGetDatum(indexId),
  247. 0, 0, 0);
  248. if (!HeapTupleIsValid(tuple))
  249. {
  250. elog(ERROR, "ExtendIndex: %s is not an index",
  251.  indexRelationName);
  252. }
  254. /*
  255.  * Extract info from the pg_index tuple
  256.  */
  257. index = (Form_pg_index) GETSTRUCT(tuple);
  258. Assert(index->indexrelid == indexId);
  259. relationId = index->indrelid;
  260. indproc = index->indproc;
  262. for (i = 0; i < INDEX_MAX_KEYS; i++)
  263. if (index->indkey[i] == InvalidAttrNumber)
  264. break;
  265. numberOfAttributes = i;
  267. if (VARSIZE(&index->indpred) != 0)
  268. {
  269. char    *predString;
  271. predString = fmgr(F_TEXTOUT, &index->indpred);
  272. oldPred = stringToNode(predString);
  273. pfree(predString);
  274. }
  275. if (oldPred == NULL)
  276. elog(ERROR, "ExtendIndex: %s is not a partial index",
  277.  indexRelationName);
  279. /*
  280.  * Convert the extension predicate from parsetree form to plan form,
  281.  * so it can be readily evaluated during index creation. Note:
  282.  * "predicate" comes in as a list containing (1) the predicate itself
  283.  * (a where_clause), and (2) a corresponding range table.
  284.  */
  285. if (rangetable != NIL)
  286. {
  287. cnfPred = cnfify((Expr *) copyObject(predicate), true);
  288. fix_opids(cnfPred);
  289. CheckPredicate(cnfPred, rangetable, relationId);
  290. }
  292. /* make predInfo list to pass to index_build */
  293. predInfo = (PredInfo *) palloc(sizeof(PredInfo));
  294. predInfo->pred = (Node *) cnfPred;
  295. predInfo->oldPred = oldPred;
  297. attributeNumberA = (AttrNumber *) palloc(numberOfAttributes *
  298.  sizeof attributeNumberA[0]);
  299. classObjectId = (Oid *) palloc(numberOfAttributes * sizeof classObjectId[0]);
  302. for (i = 0; i < numberOfAttributes; i++)
  303. {
  304. attributeNumberA[i] = index->indkey[i];
  305. classObjectId[i] = index->indclass[i];
  306. }
  308. if (indproc != InvalidOid)
  309. {
  310. funcInfo = &fInfo;
  311. /* FIgetnArgs(funcInfo) = numberOfAttributes; */
  312. FIsetnArgs(funcInfo, numberOfAttributes);
  314. tuple = SearchSysCacheTuple(PROOID,
  315. ObjectIdGetDatum(indproc),
  316. 0, 0, 0);
  317. if (!HeapTupleIsValid(tuple))
  318. elog(ERROR, "ExtendIndex: index procedure not found");
  320. namecpy(&(funcInfo->funcName),
  321. &(((Form_pg_proc) GETSTRUCT(tuple))->proname));
  323. FIsetProcOid(funcInfo, tuple->t_data->t_oid);
  324. }
  326. heapRelation = heap_open(relationId);
  327. indexRelation = index_open(indexId);
  329. LockRelation(heapRelation, ShareLock);
  331. InitIndexStrategy(numberOfAttributes, indexRelation, accessMethodId);
  333. index_build(heapRelation, indexRelation, numberOfAttributes,
  334. attributeNumberA, 0, NULL, funcInfo, predInfo);
  335. }
  338. /*
  339.  * CheckPredicate
  340.  * Checks that the given list of partial-index predicates refer
  341.  * (via the given range table) only to the given base relation oid,
  342.  * and that they're in a form the planner can handle, i.e.,
  343.  * boolean combinations of "ATTR OP CONST" (yes, for now, the ATTR
  344.  * has to be on the left).
  345.  */
  347. static void
  348. CheckPredicate(List *predList, List *rangeTable, Oid baseRelOid)
  349. {
  350. List    *item;
  352. foreach(item, predList)
  353. CheckPredExpr(lfirst(item), rangeTable, baseRelOid);
  354. }
  356. static void
  357. CheckPredExpr(Node *predicate, List *rangeTable, Oid baseRelOid)
  358. {
  359. List    *clauses = NIL,
  360.    *clause;
  362. if (is_opclause(predicate))
  363. {
  364. CheckPredClause((Expr *) predicate, rangeTable, baseRelOid);
  365. return;
  366. }
  367. else if (or_clause(predicate) || and_clause(predicate))
  368. clauses = ((Expr *) predicate)->args;
  369. else
  370. elog(ERROR, "Unsupported partial-index predicate expression type");
  372. foreach(clause, clauses)
  373. CheckPredExpr(lfirst(clause), rangeTable, baseRelOid);
  374. }
  376. static void
  377. CheckPredClause(Expr *predicate, List *rangeTable, Oid baseRelOid)
  378. {
  379. Var    *pred_var;
  380. Const    *pred_const;
  382. pred_var = (Var *) get_leftop(predicate);
  383. pred_const = (Const *) get_rightop(predicate);
  385. if (!IsA(predicate->oper, Oper) ||
  386. !IsA(pred_var, Var) ||
  387. !IsA(pred_const, Const))
  388. elog(ERROR, "Unsupported partial-index predicate clause type");
  390. if (getrelid(pred_var->varno, rangeTable) != baseRelOid)
  391. elog(ERROR,
  392.  "Partial-index predicates may refer only to the base relation");
  393. }
  396. static void
  397. FuncIndexArgs(IndexElem *funcIndex,
  398.   AttrNumber *attNumP,
  399.   Oid *argTypes,
  400.   Oid *opOidP,
  401.   Oid relId)
  402. {
  403. List    *rest;
  404. HeapTuple tuple;
  405. Form_pg_attribute att;
  407. tuple = SearchSysCacheTuple(CLANAME,
  408. PointerGetDatum(funcIndex->class),
  409. 0, 0, 0);
  411. if (!HeapTupleIsValid(tuple))
  412. {
  413. elog(ERROR, "DefineIndex: %s class not found",
  414.  funcIndex->class);
  415. }
  416. *opOidP = tuple->t_data->t_oid;
  418. MemSet(argTypes, 0, 8 * sizeof(Oid));
  420. /*
  421.  * process the function arguments
  422.  */
  423. for (rest = funcIndex->args; rest != NIL; rest = lnext(rest))
  424. {
  425. char    *arg;
  427. arg = strVal(lfirst(rest));
  429. tuple = SearchSysCacheTuple(ATTNAME,
  430. ObjectIdGetDatum(relId),
  431. PointerGetDatum(arg), 0, 0);
  433. if (!HeapTupleIsValid(tuple))
  434. {
  435. elog(ERROR,
  436.  "DefineIndex: attribute "%s" not found",
  437.  arg);
  438. }
  439. att = (Form_pg_attribute) GETSTRUCT(tuple);
  440. *attNumP++ = att->attnum;
  441. *argTypes++ = att->atttypid;
  442. }
  443. }
  445. static void
  446. NormIndexAttrs(List *attList, /* list of IndexElem's */
  447.    AttrNumber *attNumP,
  448.    Oid *classOidP,
  449.    Oid relId)
  450. {
  451. List    *rest;
  452. HeapTuple atttuple,
  453. tuple;
  455. /*
  456.  * process attributeList
  457.  */
  459. for (rest = attList; rest != NIL; rest = lnext(rest))
  460. {
  461. IndexElem  *attribute;
  462. Form_pg_attribute attform;
  464. attribute = lfirst(rest);
  466. if (attribute->name == NULL)
  467. elog(ERROR, "missing attribute for define index");
  469. atttuple = SearchSysCacheTupleCopy(ATTNAME,
  470.    ObjectIdGetDatum(relId),
  471. PointerGetDatum(attribute->name),
  472.    0, 0);
  473. if (!HeapTupleIsValid(atttuple))
  474. {
  475. elog(ERROR,
  476.  "DefineIndex: attribute "%s" not found",
  477.  attribute->name);
  478. }
  480. attform = (Form_pg_attribute) GETSTRUCT(atttuple);
  481. *attNumP++ = attform->attnum;
  483. /* we want the type so we can set the proper alignment, etc. */
  484. if (attribute->typename == NULL)
  485. {
  486. tuple = SearchSysCacheTuple(TYPOID,
  487.  ObjectIdGetDatum(attform->atttypid),
  488. 0, 0, 0);
  489. if (!HeapTupleIsValid(tuple))
  490. elog(ERROR, "create index: type for attribute '%s' undefined",
  491.  attribute->name);
  492. /* we just set the type name because that is all we need */
  493. attribute->typename = makeNode(TypeName);
  494. attribute->typename->name = nameout(&((Form_pg_type) GETSTRUCT(tuple))->typname);
  496. /* we all need the typmod for the char and varchar types. */
  497. attribute->typename->typmod = attform->atttypmod;
  498. }
  500. if (attribute->class == NULL)
  501. {
  502. /* no operator class specified, so find the default */
  503. attribute->class = GetDefaultOpClass(attform->atttypid);
  504. if (attribute->class == NULL)
  505. {
  506. elog(ERROR,
  507.  "Can't find a default operator class for type %u.",
  508.  attform->atttypid);
  509. }
  510. }
  512. tuple = SearchSysCacheTuple(CLANAME,
  513. PointerGetDatum(attribute->class),
  514. 0, 0, 0);
  516. if (!HeapTupleIsValid(tuple))
  517. {
  518. elog(ERROR, "DefineIndex: %s class not found",
  519.  attribute->class);
  520. }
  521. *classOidP++ = tuple->t_data->t_oid;
  522. pfree(atttuple);
  523. }
  524. }
  526. static char *
  527. GetDefaultOpClass(Oid atttypid)
  528. {
  529. HeapTuple tuple;
  531. tuple = SearchSysCacheTuple(CLADEFTYPE,
  532. ObjectIdGetDatum(atttypid),
  533. 0, 0, 0);
  534. if (!HeapTupleIsValid(tuple))
  535. return 0;
  537. return nameout(&(((Form_pg_opclass) GETSTRUCT(tuple))->opcname));
  538. }
  540. /*
  541.  * RemoveIndex
  542.  * Deletes an index.
  543.  *
  544.  * Exceptions:
  545.  * BadArg if name is invalid.
  546.  * "WARN" if index nonexistent.
  547.  * ...
  548.  */
  549. void
  550. RemoveIndex(char *name)
  551. {
  552. HeapTuple tuple;
  554. tuple = SearchSysCacheTuple(RELNAME,
  555. PointerGetDatum(name),
  556. 0, 0, 0);
  558. if (!HeapTupleIsValid(tuple))
  559. elog(ERROR, "index "%s" nonexistent", name);
  561. if (((Form_pg_class) GETSTRUCT(tuple))->relkind != RELKIND_INDEX)
  562. {
  563. elog(ERROR, "relation "%s" is of type "%c"",
  564.  name,
  565.  ((Form_pg_class) GETSTRUCT(tuple))->relkind);
  566. }
  568. index_destroy(tuple->t_data->t_oid);
  569. }