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

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

数据库系统

开发平台：

Unix_Linux

tqual.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * tqual.c
  4.  *   POSTGRES "time" qualification code.
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.29.2.1 1999/08/02 05:25:19 scrappy Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  15. /* #define TQUALDEBUG 1 */
  17. #include "postgres.h"
  19. #include "utils/tqual.h"
  21. extern bool PostgresIsInitialized;
  23. SnapshotData SnapshotDirtyData;
  24. Snapshot SnapshotDirty = &SnapshotDirtyData;
  26. Snapshot QuerySnapshot = NULL;
  27. Snapshot SerializableSnapshot = NULL;
  29. /*
  30.  * XXX Transaction system override hacks start here
  31.  */
  32. #ifndef GOODAMI
  34. TransactionId HeapSpecialTransactionId = InvalidTransactionId;
  35. CommandId HeapSpecialCommandId = FirstCommandId;
  37. void
  38. setheapoverride(bool on)
  39. {
  40. if (on)
  41. {
  42. TransactionIdStore(GetCurrentTransactionId(),
  43.    &HeapSpecialTransactionId);
  44. HeapSpecialCommandId = GetCurrentCommandId();
  45. }
  46. else
  47. HeapSpecialTransactionId = InvalidTransactionId;
  48. }
  50. #endif  /* !defined(GOODAMI) */
  51. /*
  52.  * XXX Transaction system override hacks end here
  53.  */
  55. /*
  56.  * HeapTupleSatisfiesItself
  57.  * True iff heap tuple is valid for "itself."
  58.  * "{it}self" means valid as of everything that's happened
  59.  * in the current transaction, _including_ the current command.
  60.  *
  61.  * Note:
  62.  * Assumes heap tuple is valid.
  63.  */
  64. /*
  65.  * The satisfaction of "itself" requires the following:
  66.  *
  67.  * ((Xmin == my-transaction && the row was updated by the current transaction, and
  68.  * (Xmax is null it was not deleted
  69.  *  [|| Xmax != my-transaction)]) [or it was deleted by another transaction]
  70.  * ||
  71.  *
  72.  * (Xmin is committed && the row was modified by a committed transaction, and
  73.  * (Xmax is null || the row has not been deleted, or
  74.  * (Xmax != my-transaction && the row was deleted by another transaction
  75.  *  Xmax is not committed))) that has not been committed
  76.  */
  77. bool
  78. HeapTupleSatisfiesItself(HeapTupleHeader tuple)
  79. {
  81. if (!(tuple->t_infomask & HEAP_XMIN_COMMITTED))
  82. {
  83. if (tuple->t_infomask & HEAP_XMIN_INVALID)
  84. return false;
  86. if (tuple->t_infomask & HEAP_MOVED_OFF)
  87. {
  88. if (TransactionIdDidCommit((TransactionId) tuple->t_cmin))
  89. {
  90. tuple->t_infomask |= HEAP_XMIN_INVALID;
  91. return false;
  92. }
  93. }
  94. else if (tuple->t_infomask & HEAP_MOVED_IN)
  95. {
  96. if (!TransactionIdDidCommit((TransactionId) tuple->t_cmin))
  97. {
  98. tuple->t_infomask |= HEAP_XMIN_INVALID;
  99. return false;
  100. }
  101. }
  102. else if (TransactionIdIsCurrentTransactionId(tuple->t_xmin))
  103. {
  104. if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
  105. return true;
  106. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  107. return true;
  108. return false;
  109. }
  110. else if (!TransactionIdDidCommit(tuple->t_xmin))
  111. {
  112. if (TransactionIdDidAbort(tuple->t_xmin))
  113. tuple->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
  114. return false;
  115. }
  116. tuple->t_infomask |= HEAP_XMIN_COMMITTED;
  117. }
  118. /* the tuple was inserted validly */
  120. if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid or aborted */
  121. return true;
  123. if (tuple->t_infomask & HEAP_XMAX_COMMITTED)
  124. {
  125. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  126. return true;
  127. return false; /* updated by other */
  128. }
  130. if (TransactionIdIsCurrentTransactionId(tuple->t_xmax))
  131. {
  132. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  133. return true;
  134. return false;
  135. }
  137. if (!TransactionIdDidCommit(tuple->t_xmax))
  138. {
  139. if (TransactionIdDidAbort(tuple->t_xmax))
  140. tuple->t_infomask |= HEAP_XMAX_INVALID; /* aborted */
  141. return true;
  142. }
  144. /* by here, deleting transaction has committed */
  145. tuple->t_infomask |= HEAP_XMAX_COMMITTED;
  147. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  148. return true;
  150. return false;
  151. }
  153. /*
  154.  * HeapTupleSatisfiesNow
  155.  * True iff heap tuple is valid "now."
  156.  * "now" means valid including everything that's happened
  157.  *  in the current transaction _up to, but not including,_
  158.  *  the current command.
  159.  *
  160.  * Note:
  161.  * Assumes heap tuple is valid.
  162.  */
  163. /*
  164.  * The satisfaction of "now" requires the following:
  165.  *
  166.  * ((Xmin == my-transaction && changed by the current transaction
  167.  *  Cmin != my-command && but not by this command, and
  168.  * (Xmax is null || the row has not been deleted, or
  169.  * (Xmax == my-transaction && it was deleted by the current transaction
  170.  *  Cmax != my-command))) but not by this command,
  171.  * || or
  172.  *
  173.  * (Xmin is committed && the row was modified by a committed transaction, and
  174.  * (Xmax is null || the row has not been deleted, or
  175.  * (Xmax == my-transaction && the row is being deleted by this command, or
  176.  *  Cmax == my-command) ||
  177.  * (Xmax is not committed && the row was deleted by another transaction
  178.  *  Xmax != my-transaction)))) that has not been committed
  179.  *
  180.  * mao says 17 march 1993:  the tests in this routine are correct;
  181.  * if you think they're not, you're wrong, and you should think
  182.  * about it again.  i know, it happened to me.  we don't need to
  183.  * check commit time against the start time of this transaction
  184.  * because 2ph locking protects us from doing the wrong thing.
  185.  * if you mess around here, you'll break serializability.  the only
  186.  * problem with this code is that it does the wrong thing for system
  187.  * catalog updates, because the catalogs aren't subject to 2ph, so
  188.  * the serializability guarantees we provide don't extend to xacts
  189.  * that do catalog accesses.  this is unfortunate, but not critical.
  190.  */
  191. bool
  192. HeapTupleSatisfiesNow(HeapTupleHeader tuple)
  193. {
  194. if (AMI_OVERRIDE)
  195. return true;
  197. /*
  198.  * If the transaction system isn't yet initialized, then we assume
  199.  * that transactions committed.  We only look at system catalogs
  200.  * during startup, so this is less awful than it seems, but it's still
  201.  * pretty awful.
  202.  */
  204. if (!PostgresIsInitialized)
  205. return ((bool) (TransactionIdIsValid(tuple->t_xmin) &&
  206. !TransactionIdIsValid(tuple->t_xmax)));
  208. if (!(tuple->t_infomask & HEAP_XMIN_COMMITTED))
  209. {
  210. if (tuple->t_infomask & HEAP_XMIN_INVALID)
  211. return false;
  213. if (tuple->t_infomask & HEAP_MOVED_OFF)
  214. {
  215. if (TransactionIdDidCommit((TransactionId) tuple->t_cmin))
  216. {
  217. tuple->t_infomask |= HEAP_XMIN_INVALID;
  218. return false;
  219. }
  220. }
  221. else if (tuple->t_infomask & HEAP_MOVED_IN)
  222. {
  223. if (!TransactionIdDidCommit((TransactionId) tuple->t_cmin))
  224. {
  225. tuple->t_infomask |= HEAP_XMIN_INVALID;
  226. return false;
  227. }
  228. }
  229. else if (TransactionIdIsCurrentTransactionId(tuple->t_xmin))
  230. {
  231. if (CommandIdGEScanCommandId(tuple->t_cmin))
  232. return false; /* inserted after scan started */
  234. if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
  235. return true;
  237. Assert(TransactionIdIsCurrentTransactionId(tuple->t_xmax));
  239. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  240. return true;
  242. if (CommandIdGEScanCommandId(tuple->t_cmax))
  243. return true; /* deleted after scan started */
  244. else
  245. return false; /* deleted before scan started */
  246. }
  247. else if (!TransactionIdDidCommit(tuple->t_xmin))
  248. {
  249. if (TransactionIdDidAbort(tuple->t_xmin))
  250. tuple->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
  251. return false;
  252. }
  253. tuple->t_infomask |= HEAP_XMIN_COMMITTED;
  254. }
  256. /* by here, the inserting transaction has committed */
  258. if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid or aborted */
  259. return true;
  261. if (tuple->t_infomask & HEAP_XMAX_COMMITTED)
  262. {
  263. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  264. return true;
  265. return false;
  266. }
  268. if (TransactionIdIsCurrentTransactionId(tuple->t_xmax))
  269. {
  270. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  271. return true;
  272. if (CommandIdGEScanCommandId(tuple->t_cmax))
  273. return true; /* deleted after scan started */
  274. else
  275. return false; /* deleted before scan started */
  276. }
  278. if (!TransactionIdDidCommit(tuple->t_xmax))
  279. {
  280. if (TransactionIdDidAbort(tuple->t_xmax))
  281. tuple->t_infomask |= HEAP_XMAX_INVALID; /* aborted */
  282. return true;
  283. }
  285. /* xmax transaction committed */
  286. tuple->t_infomask |= HEAP_XMAX_COMMITTED;
  288. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  289. return true;
  291. return false;
  292. }
  294. int
  295. HeapTupleSatisfiesUpdate(HeapTuple tuple)
  296. {
  297. HeapTupleHeader th = tuple->t_data;
  299. if (AMI_OVERRIDE)
  300. return HeapTupleMayBeUpdated;
  302. if (!(th->t_infomask & HEAP_XMIN_COMMITTED))
  303. {
  304. if (th->t_infomask & HEAP_XMIN_INVALID) /* xid invalid or aborted */
  305. return HeapTupleInvisible;
  307. if (th->t_infomask & HEAP_MOVED_OFF)
  308. {
  309. if (TransactionIdDidCommit((TransactionId) th->t_cmin))
  310. {
  311. th->t_infomask |= HEAP_XMIN_INVALID;
  312. return HeapTupleInvisible;
  313. }
  314. }
  315. else if (th->t_infomask & HEAP_MOVED_IN)
  316. {
  317. if (!TransactionIdDidCommit((TransactionId) th->t_cmin))
  318. {
  319. th->t_infomask |= HEAP_XMIN_INVALID;
  320. return HeapTupleInvisible;
  321. }
  322. }
  323. else if (TransactionIdIsCurrentTransactionId(th->t_xmin))
  324. {
  325. if (CommandIdGEScanCommandId(th->t_cmin) && !heapisoverride())
  326. return HeapTupleInvisible; /* inserted after scan
  327.  * started */
  329. if (th->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
  330. return HeapTupleMayBeUpdated;
  332. Assert(TransactionIdIsCurrentTransactionId(th->t_xmax));
  334. if (th->t_infomask & HEAP_MARKED_FOR_UPDATE)
  335. return HeapTupleMayBeUpdated;
  337. if (CommandIdGEScanCommandId(th->t_cmax))
  338. return HeapTupleSelfUpdated; /* updated after scan
  339.  * started */
  340. else
  341. return HeapTupleInvisible; /* updated before scan
  342.  * started */
  343. }
  344. else if (!TransactionIdDidCommit(th->t_xmin))
  345. {
  346. if (TransactionIdDidAbort(th->t_xmin))
  347. th->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
  348. return HeapTupleInvisible;
  349. }
  350. th->t_infomask |= HEAP_XMIN_COMMITTED;
  351. }
  353. /* by here, the inserting transaction has committed */
  355. if (th->t_infomask & HEAP_XMAX_INVALID) /* xid invalid or aborted */
  356. return HeapTupleMayBeUpdated;
  358. if (th->t_infomask & HEAP_XMAX_COMMITTED)
  359. {
  360. if (th->t_infomask & HEAP_MARKED_FOR_UPDATE)
  361. return HeapTupleMayBeUpdated;
  362. return HeapTupleUpdated;/* updated by other */
  363. }
  365. if (TransactionIdIsCurrentTransactionId(th->t_xmax))
  366. {
  367. if (th->t_infomask & HEAP_MARKED_FOR_UPDATE)
  368. return HeapTupleMayBeUpdated;
  369. if (CommandIdGEScanCommandId(th->t_cmax))
  370. return HeapTupleSelfUpdated; /* updated after scan
  371.  * started */
  372. else
  373. return HeapTupleInvisible; /* updated before scan started */
  374. }
  376. if (!TransactionIdDidCommit(th->t_xmax))
  377. {
  378. if (TransactionIdDidAbort(th->t_xmax))
  379. {
  380. th->t_infomask |= HEAP_XMAX_INVALID; /* aborted */
  381. return HeapTupleMayBeUpdated;
  382. }
  383. /* running xact */
  384. return HeapTupleBeingUpdated; /* in updation by other */
  385. }
  387. /* xmax transaction committed */
  388. th->t_infomask |= HEAP_XMAX_COMMITTED;
  390. if (th->t_infomask & HEAP_MARKED_FOR_UPDATE)
  391. return HeapTupleMayBeUpdated;
  393. return HeapTupleUpdated; /* updated by other */
  394. }
  396. bool
  397. HeapTupleSatisfiesDirty(HeapTupleHeader tuple)
  398. {
  399. SnapshotDirty->xmin = SnapshotDirty->xmax = InvalidTransactionId;
  400. ItemPointerSetInvalid(&(SnapshotDirty->tid));
  402. if (AMI_OVERRIDE)
  403. return true;
  405. if (!(tuple->t_infomask & HEAP_XMIN_COMMITTED))
  406. {
  407. if (tuple->t_infomask & HEAP_XMIN_INVALID)
  408. return false;
  410. if (tuple->t_infomask & HEAP_MOVED_OFF)
  411. {
  413. /*
  414.  * HeapTupleSatisfiesDirty is used by unique btree-s and so
  415.  * may be used while vacuuming.
  416.  */
  417. if (TransactionIdIsCurrentTransactionId((TransactionId) tuple->t_cmin))
  418. return false;
  419. if (TransactionIdDidCommit((TransactionId) tuple->t_cmin))
  420. {
  421. tuple->t_infomask |= HEAP_XMIN_INVALID;
  422. return false;
  423. }
  424. tuple->t_infomask |= HEAP_XMIN_COMMITTED;
  425. }
  426. else if (tuple->t_infomask & HEAP_MOVED_IN)
  427. {
  428. if (!TransactionIdIsCurrentTransactionId((TransactionId) tuple->t_cmin))
  429. {
  430. if (TransactionIdDidCommit((TransactionId) tuple->t_cmin))
  431. tuple->t_infomask |= HEAP_XMIN_COMMITTED;
  432. else
  433. {
  434. tuple->t_infomask |= HEAP_XMIN_INVALID;
  435. return false;
  436. }
  437. }
  438. }
  439. else if (TransactionIdIsCurrentTransactionId(tuple->t_xmin))
  440. {
  441. if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
  442. return true;
  444. Assert(TransactionIdIsCurrentTransactionId(tuple->t_xmax));
  446. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  447. return true;
  449. return false;
  450. }
  451. else if (!TransactionIdDidCommit(tuple->t_xmin))
  452. {
  453. if (TransactionIdDidAbort(tuple->t_xmin))
  454. {
  455. tuple->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
  456. return false;
  457. }
  458. SnapshotDirty->xmin = tuple->t_xmin;
  459. return true; /* in insertion by other */
  460. }
  461. else
  462. tuple->t_infomask |= HEAP_XMIN_COMMITTED;
  463. }
  465. /* by here, the inserting transaction has committed */
  467. if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid or aborted */
  468. return true;
  470. if (tuple->t_infomask & HEAP_XMAX_COMMITTED)
  471. {
  472. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  473. return true;
  474. SnapshotDirty->tid = tuple->t_ctid;
  475. return false; /* updated by other */
  476. }
  478. if (TransactionIdIsCurrentTransactionId(tuple->t_xmax))
  479. return false;
  481. if (!TransactionIdDidCommit(tuple->t_xmax))
  482. {
  483. if (TransactionIdDidAbort(tuple->t_xmax))
  484. {
  485. tuple->t_infomask |= HEAP_XMAX_INVALID; /* aborted */
  486. return true;
  487. }
  488. /* running xact */
  489. SnapshotDirty->xmax = tuple->t_xmax;
  490. return true; /* in updation by other */
  491. }
  493. /* xmax transaction committed */
  494. tuple->t_infomask |= HEAP_XMAX_COMMITTED;
  496. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  497. return true;
  499. SnapshotDirty->tid = tuple->t_ctid;
  500. return false; /* updated by other */
  501. }
  503. bool
  504. HeapTupleSatisfiesSnapshot(HeapTupleHeader tuple, Snapshot snapshot)
  505. {
  506. if (AMI_OVERRIDE)
  507. return true;
  509. if (!(tuple->t_infomask & HEAP_XMIN_COMMITTED))
  510. {
  511. if (tuple->t_infomask & HEAP_XMIN_INVALID)
  512. return false;
  514. if (tuple->t_infomask & HEAP_MOVED_OFF)
  515. {
  516. if (TransactionIdDidCommit((TransactionId) tuple->t_cmin))
  517. {
  518. tuple->t_infomask |= HEAP_XMIN_INVALID;
  519. return false;
  520. }
  521. }
  522. else if (tuple->t_infomask & HEAP_MOVED_IN)
  523. {
  524. if (!TransactionIdDidCommit((TransactionId) tuple->t_cmin))
  525. {
  526. tuple->t_infomask |= HEAP_XMIN_INVALID;
  527. return false;
  528. }
  529. }
  530. else if (TransactionIdIsCurrentTransactionId(tuple->t_xmin))
  531. {
  532. if (CommandIdGEScanCommandId(tuple->t_cmin))
  533. return false; /* inserted after scan started */
  535. if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
  536. return true;
  538. Assert(TransactionIdIsCurrentTransactionId(tuple->t_xmax));
  540. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  541. return true;
  543. if (CommandIdGEScanCommandId(tuple->t_cmax))
  544. return true; /* deleted after scan started */
  545. else
  546. return false; /* deleted before scan started */
  547. }
  548. else if (!TransactionIdDidCommit(tuple->t_xmin))
  549. {
  550. if (TransactionIdDidAbort(tuple->t_xmin))
  551. tuple->t_infomask |= HEAP_XMIN_INVALID; /* aborted */
  552. return false;
  553. }
  554. tuple->t_infomask |= HEAP_XMIN_COMMITTED;
  555. }
  557. /*
  558.  * By here, the inserting transaction has committed - have to check
  559.  * when...
  560.  */
  562. if (tuple->t_xmin >= snapshot->xmax)
  563. return false;
  564. if (tuple->t_xmin >= snapshot->xmin)
  565. {
  566. uint32 i;
  568. for (i = 0; i < snapshot->xcnt; i++)
  569. {
  570. if (tuple->t_xmin == snapshot->xip[i])
  571. return false;
  572. }
  573. }
  575. if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid or aborted */
  576. return true;
  578. if (tuple->t_infomask & HEAP_MARKED_FOR_UPDATE)
  579. return true;
  581. if (!(tuple->t_infomask & HEAP_XMAX_COMMITTED))
  582. {
  583. if (TransactionIdIsCurrentTransactionId(tuple->t_xmax))
  584. {
  585. if (CommandIdGEScanCommandId(tuple->t_cmax))
  586. return true; /* deleted after scan started */
  587. else
  588. return false; /* deleted before scan started */
  589. }
  591. if (!TransactionIdDidCommit(tuple->t_xmax))
  592. {
  593. if (TransactionIdDidAbort(tuple->t_xmax))
  594. tuple->t_infomask |= HEAP_XMAX_INVALID; /* aborted */
  595. return true;
  596. }
  598. /* xmax transaction committed */
  599. tuple->t_infomask |= HEAP_XMAX_COMMITTED;
  600. }
  602. if (tuple->t_xmax >= snapshot->xmax)
  603. return true;
  604. if (tuple->t_xmax >= snapshot->xmin)
  605. {
  606. uint32 i;
  608. for (i = 0; i < snapshot->xcnt; i++)
  609. {
  610. if (tuple->t_xmax == snapshot->xip[i])
  611. return true;
  612. }
  613. }
  615. return false;
  616. }
  618. void
  619. SetQuerySnapshot(void)
  620. {
  622. /* 1st call in xaction */
  623. if (SerializableSnapshot == NULL)
  624. {
  625. SerializableSnapshot = GetSnapshotData(true);
  626. QuerySnapshot = SerializableSnapshot;
  627. Assert(QuerySnapshot != NULL);
  628. return;
  629. }
  631. if (QuerySnapshot != SerializableSnapshot)
  632. {
  633. free(QuerySnapshot->xip);
  634. free(QuerySnapshot);
  635. }
  637. if (XactIsoLevel == XACT_SERIALIZABLE)
  638. QuerySnapshot = SerializableSnapshot;
  639. else
  640. QuerySnapshot = GetSnapshotData(false);
  642. Assert(QuerySnapshot != NULL);
  644. }
  646. void
  647. FreeXactSnapshot(void)
  648. {
  650. if (QuerySnapshot != NULL && QuerySnapshot != SerializableSnapshot)
  651. {
  652. free(QuerySnapshot->xip);
  653. free(QuerySnapshot);
  654. }
  656. QuerySnapshot = NULL;
  658. if (SerializableSnapshot != NULL)
  659. {
  660. free(SerializableSnapshot->xip);
  661. free(SerializableSnapshot);
  662. }
  664. SerializableSnapshot = NULL;
  666. }