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

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

数据库系统

开发平台：

Unix_Linux

sequence.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * sequence.c
  4.  *   PostgreSQL sequences support code.
  5.  *
  6.  *-------------------------------------------------------------------------
  7.  */
  9. #include "postgres.h"
  11. #include "access/heapam.h"
  12. #include "commands/creatinh.h"
  13. #include "commands/sequence.h"
  14. #include "miscadmin.h"
  15. #include "utils/acl.h"
  16. #include "utils/builtins.h"
  18. #define SEQ_MAGIC   0x1717
  20. #define SEQ_MAXVALUE ((int4)0x7FFFFFFF)
  21. #define SEQ_MINVALUE -(SEQ_MAXVALUE)
  23. typedef struct FormData_pg_sequence
  24. {
  25. NameData sequence_name;
  26. int4 last_value;
  27. int4 increment_by;
  28. int4 max_value;
  29. int4 min_value;
  30. int4 cache_value;
  31. char is_cycled;
  32. char is_called;
  33. } FormData_pg_sequence;
  35. typedef FormData_pg_sequence *Form_pg_sequence;
  37. typedef struct sequence_magic
  38. {
  39. uint32 magic;
  40. } sequence_magic;
  42. typedef struct SeqTableData
  43. {
  44. char    *name;
  45. Oid relid;
  46. Relation rel;
  47. int4 cached;
  48. int4 last;
  49. int4 increment;
  50. struct SeqTableData *next;
  51. } SeqTableData;
  53. typedef SeqTableData *SeqTable;
  55. static SeqTable seqtab = NULL;
  57. static SeqTable init_sequence(char *caller, char *name);
  58. static Form_pg_sequence read_info(char *caller, SeqTable elm, Buffer *buf);
  59. static void init_params(CreateSeqStmt *seq, Form_pg_sequence new);
  60. static int get_param(DefElem *def);
  62. /*
  63.  * DefineSequence
  64.  * Creates a new sequence relation
  65.  */
  66. void
  67. DefineSequence(CreateSeqStmt *seq)
  68. {
  69. FormData_pg_sequence new;
  70. CreateStmt *stmt = makeNode(CreateStmt);
  71. ColumnDef  *coldef;
  72. TypeName   *typnam;
  73. Relation rel;
  74. Buffer buf;
  75. PageHeader page;
  76. sequence_magic *sm;
  77. HeapTuple tuple;
  78. TupleDesc tupDesc;
  79. Datum value[SEQ_COL_LASTCOL];
  80. char null[SEQ_COL_LASTCOL];
  81. int i;
  82. NameData name;
  84. /* Check and set values */
  85. init_params(seq, &new);
  87. /*
  88.  * Create relation (and fill *null & *value)
  89.  */
  90. stmt->tableElts = NIL;
  91. for (i = SEQ_COL_FIRSTCOL; i <= SEQ_COL_LASTCOL; i++)
  92. {
  93. typnam = makeNode(TypeName);
  94. typnam->setof = FALSE;
  95. typnam->arrayBounds = NULL;
  96. typnam->typmod = -1;
  97. coldef = makeNode(ColumnDef);
  98. coldef->typename = typnam;
  99. coldef->defval = NULL;
  100. coldef->is_not_null = false;
  101. null[i - 1] = ' ';
  103. switch (i)
  104. {
  105. case SEQ_COL_NAME:
  106. typnam->name = "name";
  107. coldef->colname = "sequence_name";
  108. namestrcpy(&name, seq->seqname);
  109. value[i - 1] = NameGetDatum(&name);
  110. break;
  111. case SEQ_COL_LASTVAL:
  112. typnam->name = "int4";
  113. coldef->colname = "last_value";
  114. value[i - 1] = Int32GetDatum(new.last_value);
  115. break;
  116. case SEQ_COL_INCBY:
  117. typnam->name = "int4";
  118. coldef->colname = "increment_by";
  119. value[i - 1] = Int32GetDatum(new.increment_by);
  120. break;
  121. case SEQ_COL_MAXVALUE:
  122. typnam->name = "int4";
  123. coldef->colname = "max_value";
  124. value[i - 1] = Int32GetDatum(new.max_value);
  125. break;
  126. case SEQ_COL_MINVALUE:
  127. typnam->name = "int4";
  128. coldef->colname = "min_value";
  129. value[i - 1] = Int32GetDatum(new.min_value);
  130. break;
  131. case SEQ_COL_CACHE:
  132. typnam->name = "int4";
  133. coldef->colname = "cache_value";
  134. value[i - 1] = Int32GetDatum(new.cache_value);
  135. break;
  136. case SEQ_COL_CYCLE:
  137. typnam->name = "char";
  138. coldef->colname = "is_cycled";
  139. value[i - 1] = CharGetDatum(new.is_cycled);
  140. break;
  141. case SEQ_COL_CALLED:
  142. typnam->name = "char";
  143. coldef->colname = "is_called";
  144. value[i - 1] = CharGetDatum('f');
  145. break;
  146. }
  147. stmt->tableElts = lappend(stmt->tableElts, coldef);
  148. }
  150. stmt->relname = seq->seqname;
  151. stmt->inhRelnames = NIL;
  152. stmt->constraints = NIL;
  154. DefineRelation(stmt, RELKIND_SEQUENCE);
  156. rel = heap_openr(seq->seqname);
  157. Assert(RelationIsValid(rel));
  159. LockRelation(rel, AccessExclusiveLock);
  161. tupDesc = RelationGetDescr(rel);
  163. Assert(RelationGetNumberOfBlocks(rel) == 0);
  164. buf = ReadBuffer(rel, P_NEW);
  166. if (!BufferIsValid(buf))
  167. elog(ERROR, "DefineSequence: ReadBuffer failed");
  169. page = (PageHeader) BufferGetPage(buf);
  171. PageInit((Page) page, BufferGetPageSize(buf), sizeof(sequence_magic));
  172. sm = (sequence_magic *) PageGetSpecialPointer(page);
  173. sm->magic = SEQ_MAGIC;
  175. /* Now - form & insert sequence tuple */
  176. tuple = heap_formtuple(tupDesc, value, null);
  177. heap_insert(rel, tuple);
  179. if (WriteBuffer(buf) == STATUS_ERROR)
  180. elog(ERROR, "DefineSequence: WriteBuffer failed");
  182. UnlockRelation(rel, AccessExclusiveLock);
  183. heap_close(rel);
  185. return;
  187. }
  190. int4
  191. nextval(struct varlena * seqin)
  192. {
  193. char    *seqname = textout(seqin);
  194. SeqTable elm;
  195. Buffer buf;
  196. Form_pg_sequence seq;
  197. int4 incby,
  198. maxv,
  199. minv,
  200. cache;
  201. int4 result,
  202. next,
  203. rescnt = 0;
  205. /* open and AccessShareLock sequence */
  206. elm = init_sequence("nextval", seqname);
  207. pfree(seqname);
  209. if (elm->last != elm->cached) /* some numbers were cached */
  210. {
  211. elm->last += elm->increment;
  212. return elm->last;
  213. }
  215. seq = read_info("nextval", elm, &buf); /* lock page' buffer and
  216.  * read tuple */
  218. next = result = seq->last_value;
  219. incby = seq->increment_by;
  220. maxv = seq->max_value;
  221. minv = seq->min_value;
  222. cache = seq->cache_value;
  224. if (seq->is_called != 't')
  225. rescnt++; /* last_value if not called */
  227. while (rescnt < cache) /* try to fetch cache numbers */
  228. {
  230. /*
  231.  * Check MAXVALUE for ascending sequences and MINVALUE for
  232.  * descending sequences
  233.  */
  234. if (incby > 0) /* ascending sequence */
  235. {
  236. if ((maxv >= 0 && next > maxv - incby) ||
  237. (maxv < 0 && next + incby > maxv))
  238. {
  239. if (rescnt > 0)
  240. break; /* stop caching */
  241. if (seq->is_cycled != 't')
  242. elog(ERROR, "%s.nextval: got MAXVALUE (%d)",
  243.  elm->name, maxv);
  244. next = minv;
  245. }
  246. else
  247. next += incby;
  248. }
  249. else
  250. /* descending sequence */
  251. {
  252. if ((minv < 0 && next < minv - incby) ||
  253. (minv >= 0 && next + incby < minv))
  254. {
  255. if (rescnt > 0)
  256. break; /* stop caching */
  257. if (seq->is_cycled != 't')
  258. elog(ERROR, "%s.nextval: got MINVALUE (%d)",
  259.  elm->name, minv);
  260. next = maxv;
  261. }
  262. else
  263. next += incby;
  264. }
  265. rescnt++; /* got result */
  266. if (rescnt == 1) /* if it's first one - */
  267. result = next; /* it's what to return */
  268. }
  270. /* save info in local cache */
  271. elm->last = result; /* last returned number */
  272. elm->cached = next; /* last cached number */
  274. /* save info in sequence relation */
  275. seq->last_value = next; /* last fetched number */
  276. seq->is_called = 't';
  278. LockBuffer(buf, BUFFER_LOCK_UNLOCK);
  280. if (WriteBuffer(buf) == STATUS_ERROR)
  281. elog(ERROR, "%s.nextval: WriteBuffer failed", elm->name);
  283. return result;
  285. }
  288. int4
  289. currval(struct varlena * seqin)
  290. {
  291. char    *seqname = textout(seqin);
  292. SeqTable elm;
  293. int4 result;
  295. /* open and AccessShareLock sequence */
  296. elm = init_sequence("currval", seqname);
  297. pfree(seqname);
  299. if (elm->increment == 0) /* nextval/read_info were not called */
  300. elog(ERROR, "%s.currval is not yet defined in this session", elm->name);
  302. result = elm->last;
  304. return result;
  306. }
  308. int4
  309. setval(struct varlena * seqin, int4 next)
  310. {
  311. char    *seqname = textout(seqin);
  312. SeqTable elm;
  313. Buffer buf;
  314. Form_pg_sequence seq;
  316. #ifndef NO_SECURITY
  317. if (pg_aclcheck(seqname, getpgusername(), ACL_WR) != ACLCHECK_OK)
  318. elog(ERROR, "%s.setval: you don't have permissions to set sequence %s",
  319.  seqname, seqname);
  320. #endif
  322. /* open and AccessShareLock sequence */
  323. elm = init_sequence("setval", seqname);
  324. seq = read_info("setval", elm, &buf); /* lock page' buffer and
  325.  * read tuple */
  327. if (seq->cache_value != 1)
  328. {
  329. elog(ERROR, "%s.setval: can't set value of sequence %s, cache != 1",
  330.  seqname, seqname);
  331. }
  333. if ((next < seq->min_value) || (next > seq->max_value))
  334. {
  335. elog(ERROR, "%s.setval: value %d is of of bounds (%d,%d)",
  336.  seqname, next, seq->min_value, seq->max_value);
  337. }
  339. /* save info in local cache */
  340. elm->last = next; /* last returned number */
  341. elm->cached = next; /* last cached number */
  343. /* save info in sequence relation */
  344. seq->last_value = next; /* last fetched number */
  345. seq->is_called = 't';
  347. LockBuffer(buf, BUFFER_LOCK_UNLOCK);
  349. if (WriteBuffer(buf) == STATUS_ERROR)
  350. elog(ERROR, "%s.settval: WriteBuffer failed", seqname);
  352. return next;
  353. }
  355. static Form_pg_sequence
  356. read_info(char *caller, SeqTable elm, Buffer *buf)
  357. {
  358. PageHeader page;
  359. ItemId lp;
  360. HeapTupleData tuple;
  361. sequence_magic *sm;
  362. Form_pg_sequence seq;
  364. if (RelationGetNumberOfBlocks(elm->rel) != 1)
  365. elog(ERROR, "%s.%s: invalid number of blocks in sequence",
  366.  elm->name, caller);
  368. *buf = ReadBuffer(elm->rel, 0);
  369. if (!BufferIsValid(*buf))
  370. elog(ERROR, "%s.%s: ReadBuffer failed", elm->name, caller);
  372. LockBuffer(*buf, BUFFER_LOCK_EXCLUSIVE);
  374. page = (PageHeader) BufferGetPage(*buf);
  375. sm = (sequence_magic *) PageGetSpecialPointer(page);
  377. if (sm->magic != SEQ_MAGIC)
  378. elog(ERROR, "%s.%s: bad magic (%08X)", elm->name, caller, sm->magic);
  380. lp = PageGetItemId(page, FirstOffsetNumber);
  381. Assert(ItemIdIsUsed(lp));
  382. tuple.t_data = (HeapTupleHeader) PageGetItem((Page) page, lp);
  384. seq = (Form_pg_sequence) GETSTRUCT(&tuple);
  386. elm->increment = seq->increment_by;
  388. return seq;
  390. }
  393. static SeqTable
  394. init_sequence(char *caller, char *name)
  395. {
  396. SeqTable elm,
  397. priv = (SeqTable) NULL;
  398. SeqTable temp;
  400. for (elm = seqtab; elm != (SeqTable) NULL;)
  401. {
  402. if (strcmp(elm->name, name) == 0)
  403. break;
  404. priv = elm;
  405. elm = elm->next;
  406. }
  408. if (elm == (SeqTable) NULL) /* not found */
  409. {
  410. temp = (SeqTable) malloc(sizeof(SeqTableData));
  411. temp->name = malloc(strlen(name) + 1);
  412. strcpy(temp->name, name);
  413. temp->rel = (Relation) NULL;
  414. temp->cached = temp->last = temp->increment = 0;
  415. temp->next = (SeqTable) NULL;
  416. }
  417. else
  418. /* found */
  419. {
  420. if (elm->rel != (Relation) NULL) /* already opened */
  421. return elm;
  422. temp = elm;
  423. }
  425. temp->rel = heap_openr(name);
  427. if (!RelationIsValid(temp->rel))
  428. elog(ERROR, "%s.%s: sequence does not exist", name, caller);
  430. LockRelation(temp->rel, AccessShareLock);
  432. if (temp->rel->rd_rel->relkind != RELKIND_SEQUENCE)
  433. elog(ERROR, "%s.%s: %s is not sequence !", name, caller, name);
  435. if (elm != (SeqTable) NULL) /* we opened sequence from our */
  436. { /* SeqTable - check relid ! */
  437. if (RelationGetRelid(elm->rel) != elm->relid)
  438. {
  439. elog(NOTICE, "%s.%s: sequence was re-created",
  440.  name, caller, name);
  441. elm->cached = elm->last = elm->increment = 0;
  442. elm->relid = RelationGetRelid(elm->rel);
  443. }
  444. }
  445. else
  446. {
  447. elm = temp;
  448. elm->relid = RelationGetRelid(elm->rel);
  449. if (seqtab == (SeqTable) NULL)
  450. seqtab = elm;
  451. else
  452. priv->next = elm;
  453. }
  455. return elm;
  457. }
  460. /*
  461.  * CloseSequences
  462.  * is calling by xact mgr at commit/abort.
  463.  */
  464. void
  465. CloseSequences(void)
  466. {
  467. SeqTable elm;
  468. Relation rel;
  470. for (elm = seqtab; elm != (SeqTable) NULL;)
  471. {
  472. if (elm->rel != (Relation) NULL) /* opened in current xact */
  473. {
  474. rel = elm->rel;
  475. elm->rel = (Relation) NULL;
  476. UnlockRelation(rel, AccessShareLock);
  477. heap_close(rel);
  478. }
  479. elm = elm->next;
  480. }
  482. return;
  484. }
  487. static void
  488. init_params(CreateSeqStmt *seq, Form_pg_sequence new)
  489. {
  490. DefElem    *last_value = NULL;
  491. DefElem    *increment_by = NULL;
  492. DefElem    *max_value = NULL;
  493. DefElem    *min_value = NULL;
  494. DefElem    *cache_value = NULL;
  495. List    *option;
  497. new->is_cycled = 'f';
  498. foreach(option, seq->options)
  499. {
  500. DefElem    *defel = (DefElem *) lfirst(option);
  502. if (!strcasecmp(defel->defname, "increment"))
  503. increment_by = defel;
  504. else if (!strcasecmp(defel->defname, "start"))
  505. last_value = defel;
  506. else if (!strcasecmp(defel->defname, "maxvalue"))
  507. max_value = defel;
  508. else if (!strcasecmp(defel->defname, "minvalue"))
  509. min_value = defel;
  510. else if (!strcasecmp(defel->defname, "cache"))
  511. cache_value = defel;
  512. else if (!strcasecmp(defel->defname, "cycle"))
  513. {
  514. if (defel->arg != (Node *) NULL)
  515. elog(ERROR, "DefineSequence: CYCLE ??");
  516. new->is_cycled = 't';
  517. }
  518. else
  519. elog(ERROR, "DefineSequence: option "%s" not recognized",
  520.  defel->defname);
  521. }
  523. if (increment_by == (DefElem *) NULL) /* INCREMENT BY */
  524. new->increment_by = 1;
  525. else if ((new->increment_by = get_param(increment_by)) == 0)
  526. elog(ERROR, "DefineSequence: can't INCREMENT by 0");
  528. if (max_value == (DefElem *) NULL) /* MAXVALUE */
  529. {
  530. if (new->increment_by > 0)
  531. new->max_value = SEQ_MAXVALUE; /* ascending seq */
  532. else
  533. new->max_value = -1;/* descending seq */
  534. }
  535. else
  536. new->max_value = get_param(max_value);
  538. if (min_value == (DefElem *) NULL) /* MINVALUE */
  539. {
  540. if (new->increment_by > 0)
  541. new->min_value = 1; /* ascending seq */
  542. else
  543. new->min_value = SEQ_MINVALUE; /* descending seq */
  544. }
  545. else
  546. new->min_value = get_param(min_value);
  548. if (new->min_value >= new->max_value)
  549. elog(ERROR, "DefineSequence: MINVALUE (%d) can't be >= MAXVALUE (%d)",
  550.  new->min_value, new->max_value);
  552. if (last_value == (DefElem *) NULL) /* START WITH */
  553. {
  554. if (new->increment_by > 0)
  555. new->last_value = new->min_value; /* ascending seq */
  556. else
  557. new->last_value = new->max_value; /* descending seq */
  558. }
  559. else
  560. new->last_value = get_param(last_value);
  562. if (new->last_value < new->min_value)
  563. elog(ERROR, "DefineSequence: START value (%d) can't be < MINVALUE (%d)",
  564.  new->last_value, new->min_value);
  565. if (new->last_value > new->max_value)
  566. elog(ERROR, "DefineSequence: START value (%d) can't be > MAXVALUE (%d)",
  567.  new->last_value, new->max_value);
  569. if (cache_value == (DefElem *) NULL) /* CACHE */
  570. new->cache_value = 1;
  571. else if ((new->cache_value = get_param(cache_value)) <= 0)
  572. elog(ERROR, "DefineSequence: CACHE (%d) can't be <= 0",
  573.  new->cache_value);
  575. }
  578. static int
  579. get_param(DefElem *def)
  580. {
  581. if (def->arg == (Node *) NULL)
  582. elog(ERROR, "DefineSequence: "%s" value unspecified", def->defname);
  584. if (nodeTag(def->arg) == T_Integer)
  585. return intVal(def->arg);
  587. elog(ERROR, "DefineSequence: "%s" is to be integer", def->defname);
  588. return -1;
  589. }