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

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

数据库系统

开发平台：

Unix_Linux

pg_type.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * pg_type.c
  4.  *   routines to support manipulation of the pg_type relation
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.37.2.1 1999/08/02 05:56:55 scrappy Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. #include "postgres.h"
  16. #include "access/heapam.h"
  17. #include "catalog/catname.h"
  18. #include "catalog/indexing.h"
  19. #include "catalog/pg_type.h"
  20. #include "miscadmin.h"
  21. #include "parser/parse_func.h"
  22. #include "utils/builtins.h"
  23. #include "utils/syscache.h"
  26. static Oid TypeShellMakeWithOpenRelation(Relation pg_type_desc,
  27.   char *typeName);
  29. /* ----------------------------------------------------------------
  30.  * TypeGetWithOpenRelation
  31.  *
  32.  * preforms a scan on pg_type for a type tuple with the
  33.  * given type name.
  34.  * ----------------------------------------------------------------
  35.  * pg_type_desc  -- reldesc for pg_type
  36.  * typeName  -- name of type to be fetched
  37.  * defined  -- has the type been defined?
  38.  */
  39. static Oid
  40. TypeGetWithOpenRelation(Relation pg_type_desc,
  41. char *typeName,
  42. bool *defined)
  43. {
  44. HeapScanDesc scan;
  45. HeapTuple tup;
  46. Oid typoid;
  48. static ScanKeyData typeKey[1] = {
  49. {0, Anum_pg_type_typname, F_NAMEEQ}
  50. };
  52. /* ----------------
  53.  * initialize the scan key and begin a scan of pg_type
  54.  * ----------------
  55.  */
  56. fmgr_info(F_NAMEEQ, &typeKey[0].sk_func);
  57. typeKey[0].sk_nargs = typeKey[0].sk_func.fn_nargs;
  58. typeKey[0].sk_argument = PointerGetDatum(typeName);
  60. scan = heap_beginscan(pg_type_desc,
  61.   0,
  62.   SnapshotSelf, /* cache? */
  63.   1,
  64.   typeKey);
  66. /* ----------------
  67.  * get the type tuple, if it exists.
  68.  * ----------------
  69.  */
  70. tup = heap_getnext(scan, 0);
  72. /* ----------------
  73.  * if no type tuple exists for the given type name, then
  74.  * end the scan and return appropriate information.
  75.  * ----------------
  76.  */
  77. if (!HeapTupleIsValid(tup))
  78. {
  79. heap_endscan(scan);
  80. *defined = false;
  81. return InvalidOid;
  82. }
  84. /* ----------------
  85.  * here, the type tuple does exist so we pull information from
  86.  * the typisdefined field of the tuple and return the tuple's
  87.  * oid, which is the oid of the type.
  88.  * ----------------
  89.  */
  90. *defined = (bool) ((Form_pg_type) GETSTRUCT(tup))->typisdefined;
  91. typoid = tup->t_data->t_oid;
  93. heap_endscan(scan);
  95. return typoid;
  96. }
  98. /* ----------------------------------------------------------------
  99.  * TypeGet
  100.  *
  101.  * Finds the ObjectId of a type, even if uncommitted; "defined"
  102.  * is only set if the type has actually been defined, i.e., if
  103.  * the type tuple is not a shell.
  104.  *
  105.  * Note: the meat of this function is now in the function
  106.  *   TypeGetWithOpenRelation().  -cim 6/15/90
  107.  *
  108.  * Also called from util/remove.c
  109.  * ----------------------------------------------------------------
  110.  */
  111. Oid
  112. TypeGet(char *typeName, /* name of type to be fetched */
  113. bool *defined) /* has the type been defined? */
  114. {
  115. Relation pg_type_desc;
  116. Oid typeoid;
  118. /* ----------------
  119.  * open the pg_type relation
  120.  * ----------------
  121.  */
  122. pg_type_desc = heap_openr(TypeRelationName);
  124. /* ----------------
  125.  * scan the type relation for the information we want
  126.  * ----------------
  127.  */
  128. typeoid = TypeGetWithOpenRelation(pg_type_desc,
  129.   typeName,
  130.   defined);
  132. /* ----------------
  133.  * close the type relation and return the type oid.
  134.  * ----------------
  135.  */
  136. heap_close(pg_type_desc);
  138. return typeoid;
  139. }
  141. /* ----------------------------------------------------------------
  142.  * TypeShellMakeWithOpenRelation
  143.  *
  144.  * ----------------------------------------------------------------
  145.  */
  146. static Oid
  147. TypeShellMakeWithOpenRelation(Relation pg_type_desc, char *typeName)
  148. {
  149. int i;
  150. HeapTuple tup;
  151. Datum values[Natts_pg_type];
  152. char nulls[Natts_pg_type];
  153. Oid typoid;
  154. NameData name;
  155. TupleDesc tupDesc;
  157. /* ----------------
  158.  * initialize our *nulls and *values arrays
  159.  * ----------------
  160.  */
  161. for (i = 0; i < Natts_pg_type; ++i)
  162. {
  163. nulls[i] = ' ';
  164. values[i] = (Datum) NULL; /* redundant, but safe */
  165. }
  167. /* ----------------
  168.  * initialize *values with the type name and
  169.  * ----------------
  170.  */
  171. i = 0;
  172. namestrcpy(&name, typeName);
  173. values[i++] = NameGetDatum(&name); /* 1 */
  174. values[i++] = (Datum) InvalidOid; /* 2 */
  175. values[i++] = (Datum) (int16) 0; /* 3 */
  176. values[i++] = (Datum) (int16) 0; /* 4 */
  177. values[i++] = (Datum) (bool) 0; /* 5 */
  178. values[i++] = (Datum) (bool) 0; /* 6 */
  179. values[i++] = (Datum) (bool) 0; /* 7 */
  180. values[i++] = (Datum) (bool) 0; /* 8 */
  181. values[i++] = (Datum) InvalidOid; /* 9 */
  182. values[i++] = (Datum) InvalidOid; /* 10 */
  183. values[i++] = (Datum) InvalidOid; /* 11 */
  184. values[i++] = (Datum) InvalidOid; /* 12 */
  185. values[i++] = (Datum) InvalidOid; /* 13 */
  186. values[i++] = (Datum) InvalidOid; /* 14 */
  187. values[i++] = (Datum) 'i'; /* 15 */
  189. /*
  190.  * ... and fill typdefault with a bogus value
  191.  */
  192. values[i++] = (Datum) fmgr(F_TEXTIN, typeName); /* 15 */
  194. /* ----------------
  195.  * create a new type tuple with FormHeapTuple
  196.  * ----------------
  197.  */
  198. tupDesc = pg_type_desc->rd_att;
  200. tup = heap_formtuple(tupDesc, values, nulls);
  202. /* ----------------
  203.  * insert the tuple in the relation and get the tuple's oid.
  204.  * ----------------
  205.  */
  206. heap_insert(pg_type_desc, tup);
  207. typoid = tup->t_data->t_oid;
  209. if (RelationGetForm(pg_type_desc)->relhasindex)
  210. {
  211. Relation idescs[Num_pg_type_indices];
  213. CatalogOpenIndices(Num_pg_type_indices, Name_pg_type_indices, idescs);
  214. CatalogIndexInsert(idescs, Num_pg_type_indices, pg_type_desc, tup);
  215. CatalogCloseIndices(Num_pg_type_indices, idescs);
  216. }
  217. /* ----------------
  218.  * free the tuple and return the type-oid
  219.  * ----------------
  220.  */
  221. pfree(tup);
  223. return typoid;
  224. }
  226. /* ----------------------------------------------------------------
  227.  * TypeShellMake
  228.  *
  229.  * This procedure inserts a "shell" tuple into the type
  230.  * relation.  The type tuple inserted has invalid values
  231.  * and in particular, the "typisdefined" field is false.
  232.  *
  233.  * This is used so that a tuple exists in the catalogs.
  234.  * The invalid fields should be fixed up sometime after
  235.  * this routine is called, and then the "typeisdefined"
  236.  * field is set to true. -cim 6/15/90
  237.  * ----------------------------------------------------------------
  238.  */
  239. Oid
  240. TypeShellMake(char *typeName)
  241. {
  242. Relation pg_type_desc;
  243. Oid typoid;
  245. Assert(PointerIsValid(typeName));
  247. /* ----------------
  248.  * open pg_type
  249.  * ----------------
  250.  */
  251. pg_type_desc = heap_openr(TypeRelationName);
  253. /* ----------------
  254.  * insert the shell tuple
  255.  * ----------------
  256.  */
  257. typoid = TypeShellMakeWithOpenRelation(pg_type_desc, typeName);
  259. /* ----------------
  260.  * close pg_type and return the tuple's oid.
  261.  * ----------------
  262.  */
  263. heap_close(pg_type_desc);
  265. return typoid;
  266. }
  268. /* ----------------------------------------------------------------
  269.  * TypeCreate
  270.  *
  271.  * This does all the necessary work needed to define a new type.
  272.  * ----------------------------------------------------------------
  273.  */
  274. Oid
  275. TypeCreate(char *typeName,
  276.    Oid relationOid, /* only for 'c'atalog typeTypes */
  277.    int16 internalSize,
  278.    int16 externalSize,
  279.    char typeType,
  280.    char typDelim,
  281.    char *inputProcedure,
  282.    char *outputProcedure,
  283.    char *receiveProcedure,
  284.    char *sendProcedure,
  285.    char *elementTypeName,
  286.    char *defaultTypeValue, /* internal rep */
  287.    bool passedByValue,
  288.    char alignment)
  289. {
  290. int i,
  291. j;
  292. Relation pg_type_desc;
  293. HeapScanDesc pg_type_scan;
  295. Oid typeObjectId;
  296. Oid elementObjectId = InvalidOid;
  298. HeapTuple tup;
  299. char nulls[Natts_pg_type];
  300. char replaces[Natts_pg_type];
  301. Datum values[Natts_pg_type];
  303. char    *procname;
  304. char    *procs[4];
  305. bool defined;
  306. NameData name;
  307. TupleDesc tupDesc;
  308. Oid argList[8];
  310. static ScanKeyData typeKey[1] = {
  311. {0, Anum_pg_type_typname, F_NAMEEQ}
  312. };
  314. fmgr_info(F_NAMEEQ, &typeKey[0].sk_func);
  315. typeKey[0].sk_nargs = typeKey[0].sk_func.fn_nargs;
  317. /* ----------------
  318.  * check that the type is not already defined.
  319.  * ----------------
  320.  */
  321. typeObjectId = TypeGet(typeName, &defined);
  322. if (OidIsValid(typeObjectId) && defined)
  323. elog(ERROR, "TypeCreate: type %s already defined", typeName);
  325. /* ----------------
  326.  * if this type has an associated elementType, then we check that
  327.  * it is defined.
  328.  * ----------------
  329.  */
  330. if (elementTypeName)
  331. {
  332. elementObjectId = TypeGet(elementTypeName, &defined);
  333. if (!defined)
  334. elog(ERROR, "TypeCreate: type %s is not defined", elementTypeName);
  335. }
  337. /* ----------------
  338.  * XXX comment me
  339.  * ----------------
  340.  */
  341. if (externalSize == 0)
  342. externalSize = -1; /* variable length */
  344. /* ----------------
  345.  * initialize arrays needed by FormHeapTuple
  346.  * ----------------
  347.  */
  348. for (i = 0; i < Natts_pg_type; ++i)
  349. {
  350. nulls[i] = ' ';
  351. replaces[i] = 'r';
  352. values[i] = (Datum) NULL; /* redundant, but nice */
  353. }
  355. /*
  356.  * XXX
  357.  *
  358.  * Do this so that user-defined types have size -1 instead of zero if
  359.  * they are variable-length - this is so that everything else in the
  360.  * backend works.
  361.  */
  363. if (internalSize == 0)
  364. internalSize = -1;
  366. /* ----------------
  367.  * initialize the *values information
  368.  * ----------------
  369.  */
  370. i = 0;
  371. namestrcpy(&name, typeName);
  372. values[i++] = NameGetDatum(&name); /* 1 */
  373. values[i++] = (Datum) GetUserId(); /* 2 */
  374. values[i++] = (Datum) internalSize; /* 3 */
  375. values[i++] = (Datum) externalSize; /* 4 */
  376. values[i++] = (Datum) passedByValue; /* 5 */
  377. values[i++] = (Datum) typeType; /* 6 */
  378. values[i++] = (Datum) (bool) 1; /* 7 */
  379. values[i++] = (Datum) typDelim; /* 8 */
  380. values[i++] = (Datum) (typeType == 'c' ? relationOid : InvalidOid); /* 9 */
  381. values[i++] = (Datum) elementObjectId; /* 10 */
  383. procs[0] = inputProcedure;
  384. procs[1] = outputProcedure;
  385. procs[2] = (receiveProcedure) ? receiveProcedure : inputProcedure;
  386. procs[3] = (sendProcedure) ? sendProcedure : outputProcedure;
  388. for (j = 0; j < 4; ++j)
  389. {
  390. procname = procs[j];
  392. /*
  393.  * First look for a 1-argument func with all argtypes 0. This is
  394.  * valid for all four kinds of procedure.
  395.  */
  396. MemSet(argList, 0, 8 * sizeof(Oid));
  398. tup = SearchSysCacheTuple(PRONAME,
  399.   PointerGetDatum(procname),
  400.   Int32GetDatum(1),
  401.   PointerGetDatum(argList),
  402.   0);
  404. if (!HeapTupleIsValid(tup))
  405. {
  407. /*
  408.  * For array types, the input procedures may take 3 args (data
  409.  * value, element OID, atttypmod); the pg_proc argtype
  410.  * signature is 0,0,INT4OID.  The output procedures may take 2
  411.  * args (data value, element OID).
  412.  */
  413. if (OidIsValid(elementObjectId))
  414. {
  415. int nargs;
  417. if (j % 2)
  418. {
  419. /* output proc */
  420. nargs = 2;
  421. }
  422. else
  423. {
  424. /* input proc */
  425. nargs = 3;
  426. argList[2] = INT4OID;
  427. }
  428. tup = SearchSysCacheTuple(PRONAME,
  429.   PointerGetDatum(procname),
  430.   Int32GetDatum(nargs),
  431.   PointerGetDatum(argList),
  432.   0);
  433. }
  434. if (!HeapTupleIsValid(tup))
  435. func_error("TypeCreate", procname, 1, argList, NULL);
  436. }
  438. values[i++] = (Datum) tup->t_data->t_oid; /* 11 - 14 */
  439. }
  441. /* ----------------
  442.  * set default alignment
  443.  * ----------------
  444.  */
  445. values[i++] = (Datum) alignment; /* 15 */
  447. /* ----------------
  448.  * initialize the default value for this type.
  449.  * ----------------
  450.  */
  451. values[i] = (Datum) fmgr(F_TEXTIN, /* 16 */
  452.  PointerIsValid(defaultTypeValue)
  453.  ? defaultTypeValue : "-"); /* XXX default
  454.  * typdefault */
  456. /* ----------------
  457.  * open pg_type and begin a scan for the type name.
  458.  * ----------------
  459.  */
  460. pg_type_desc = heap_openr(TypeRelationName);
  462. /* -----------------
  463.  * Set a write lock initially so as not upgrade a read to a write
  464.  * when the heap_insert() or heap_replace() is called.
  465.  * -----------------
  466.  */
  467. LockRelation(pg_type_desc, AccessExclusiveLock);
  469. typeKey[0].sk_argument = PointerGetDatum(typeName);
  470. pg_type_scan = heap_beginscan(pg_type_desc,
  471.   0,
  472.   SnapshotSelf, /* cache? */
  473.   1,
  474.   typeKey);
  476. /* ----------------
  477.  * define the type either by adding a tuple to the type
  478.  * relation, or by updating the fields of the "shell" tuple
  479.  * already there.
  480.  * ----------------
  481.  */
  482. tup = heap_getnext(pg_type_scan, 0);
  483. if (HeapTupleIsValid(tup))
  484. {
  485. tup = heap_modifytuple(tup,
  486.    pg_type_desc,
  487.    values,
  488.    nulls,
  489.    replaces);
  491. setheapoverride(true);
  492. heap_replace(pg_type_desc, &tup->t_self, tup, NULL);
  493. setheapoverride(false);
  495. typeObjectId = tup->t_data->t_oid;
  496. }
  497. else
  498. {
  499. tupDesc = pg_type_desc->rd_att;
  501. tup = heap_formtuple(tupDesc,
  502.  values,
  503.  nulls);
  505. heap_insert(pg_type_desc, tup);
  507. typeObjectId = tup->t_data->t_oid;
  508. }
  510. /* ----------------
  511.  * finish up
  512.  * ----------------
  513.  */
  514. heap_endscan(pg_type_scan);
  516. if (RelationGetForm(pg_type_desc)->relhasindex)
  517. {
  518. Relation idescs[Num_pg_type_indices];
  520. CatalogOpenIndices(Num_pg_type_indices, Name_pg_type_indices, idescs);
  521. CatalogIndexInsert(idescs, Num_pg_type_indices, pg_type_desc, tup);
  522. CatalogCloseIndices(Num_pg_type_indices, idescs);
  523. }
  524. UnlockRelation(pg_type_desc, AccessExclusiveLock);
  525. heap_close(pg_type_desc);
  527. return typeObjectId;
  528. }
  530. /* ----------------------------------------------------------------
  531.  * TypeRename
  532.  *
  533.  * This renames a type
  534.  * ----------------------------------------------------------------
  535.  */
  536. void
  537. TypeRename(char *oldTypeName, char *newTypeName)
  538. {
  539. Relation pg_type_desc;
  540. Relation idescs[Num_pg_type_indices];
  541. HeapTuple oldtup,
  542. newtup;
  544. pg_type_desc = heap_openr(TypeRelationName);
  546. oldtup = SearchSysCacheTupleCopy(TYPNAME,
  547.  PointerGetDatum(oldTypeName),
  548.  0, 0, 0);
  550. if (!HeapTupleIsValid(oldtup))
  551. {
  552. heap_close(pg_type_desc);
  553. elog(ERROR, "TypeRename: type %s not defined", oldTypeName);
  554. }
  556. newtup = SearchSysCacheTuple(TYPNAME,
  557.  PointerGetDatum(newTypeName),
  558.  0, 0, 0);
  559. if (HeapTupleIsValid(newtup))
  560. {
  561. pfree(oldtup);
  562. heap_close(pg_type_desc);
  563. elog(ERROR, "TypeRename: type %s already defined", newTypeName);
  564. }
  566. namestrcpy(&(((Form_pg_type) GETSTRUCT(oldtup))->typname), newTypeName);
  568. setheapoverride(true);
  569. heap_replace(pg_type_desc, &oldtup->t_self, oldtup, NULL);
  570. setheapoverride(false);
  572. /* update the system catalog indices */
  573. CatalogOpenIndices(Num_pg_type_indices, Name_pg_type_indices, idescs);
  574. CatalogIndexInsert(idescs, Num_pg_type_indices, pg_type_desc, oldtup);
  575. CatalogCloseIndices(Num_pg_type_indices, idescs);
  577. pfree(oldtup);
  578. heap_close(pg_type_desc);
  579. }
  581. /*
  582.  * makeArrayTypeName(typeName);
  583.  *   - given a base type name, make an array of type name out of it
  584.  *
  585.  * the CALLER is responsible for pfreeing the
  586.  */
  588. char *
  589. makeArrayTypeName(char *typeName)
  590. {
  591. char    *arr;
  593. if (!typeName)
  594. return NULL;
  595. arr = palloc(strlen(typeName) + 2);
  596. arr[0] = '_';
  597. strcpy(arr + 1, typeName);
  599. return arr;
  601. }