-
Notifications
You must be signed in to change notification settings - Fork 2.3k
/
TransactionIdStore.java
140 lines (126 loc) · 6.15 KB
/
TransactionIdStore.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
/*
* Copyright (c) 2002-2015 "Neo Technology,"
* Network Engine for Objects in Lund AB [http://neotechnology.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.neo4j.kernel.impl.transaction.log;
import org.neo4j.kernel.impl.store.TransactionId;
import static org.neo4j.kernel.impl.transaction.log.entry.LogHeader.LOG_HEADER_SIZE;
/**
* Keeps a latest transaction id. There's one counter for {@code committed transaction id} and one for
* {@code closed transaction id}. The committed transaction id is for writing into a log before making
* the changes to be made. After that the application of those transactions might be asynchronous and
* completion of those are marked using {@link #transactionClosed(long, long, long)}.
*
* A transaction ID passes through a {@link TransactionIdStore} like this:
* <ol>
* <li>{@link #nextCommittingTransactionId()} is called and an id is returned to a committer.
* At this point that id isn't visible from any getter.</li>
* <li>{@link #transactionCommitted(long, long)} is called with this id after the fact that the transaction
* has been committed, i.e. written forcefully to a log. After this call the id may be visible from
* {@link #getLastCommittedTransactionId()} if all ids before it have also been committed.</li>
* <li>{@link #transactionClosed(long, long, long)} is called with this id again, this time after all changes the
* transaction imposes have been applied to the store. At this point this id is regarded in
* {@link #closedTransactionIdIsOnParWithOpenedTransactionId()} as well.
* </ol>
*/
public interface TransactionIdStore
{
// Tx id counting starting from this value (this value means no transaction ever committed)
long BASE_TX_ID = 1;
long BASE_TX_CHECKSUM = 0;
long BASE_TX_LOG_VERSION = 0;
long BASE_TX_LOG_BYTE_OFFSET = LOG_HEADER_SIZE;
/**
* @return the next transaction id for a committing transaction. The transaction id is incremented
* with each call. Ids returned from this method will not be visible from {@link #getLastCommittedTransactionId()}
* until handed to {@link #transactionCommitted(long, long)}.
*/
long nextCommittingTransactionId();
/**
* Signals that a transaction with the given transaction id has been committed (i.e. appended to a log).
* Calls to this method may come in out-of-transaction-id order. The highest transaction id
* seen given to this method will be visible in {@link #getLastCommittedTransactionId()}.
* @param transactionId the applied transaction id.
* @param checksum checksum of the transaction.
*/
void transactionCommitted( long transactionId, long checksum );
/**
* @return highest seen {@link #transactionCommitted(long, long) committed transaction id}.
*/
long getLastCommittedTransactionId();
/**
* Returns transaction information about the highest committed transaction, i.e.
* transaction id as well as checksum.
*
* @return {@link TransactionId} describing the last (i.e. highest) committed transaction.
*/
TransactionId getLastCommittedTransaction();
/**
* Returns transaction information about transaction where the last upgrade was performed, i.e.
* transaction id as well as checksum.
*
* @return {@link TransactionId} describing the most recent upgrade transaction.
*/
TransactionId getUpgradeTransaction();
/**
* @return highest seen gap-free {@link #transactionClosed(long, long, long) closed transaction id}.
*/
long getLastClosedTransactionId();
/**
* Returns transaction information about the last committed transaction, i.e.
* transaction id as well as the log position following the commit entry in the transaction log.
*
* @return transaction information about the last closed (highest gap-free) transaction.
* <pre>
* [0]: transaction id
* [1]: log version
* [2]: byte offset into that log version
* </pre>
*/
long[] getLastClosedTransaction();
/**
* Used by recovery, where last committed/closed transaction ids are set.
* Perhaps this shouldn't be exposed like this?
*
* @param transactionId transaction id that will be the last closed/committed id.
* @param checksum checksum of the transaction.
* @param logVersion version of log the committed entry has been written into.
* @param byteOffset offset in the log file where the committed entry has been written.
*/
void setLastCommittedAndClosedTransactionId( long transactionId, long checksum, long logVersion, long byteOffset );
/**
* Signals that a transaction with the given transaction id has been fully applied. Calls to this method
* may come in out-of-transaction-id order.
* @param transactionId the applied transaction id.
* @param logVersion version of log the committed entry has been written into.
* @param byteOffset offset in the log file where start writing the next log entry.
*/
void transactionClosed( long transactionId, long logVersion, long byteOffset );
/**
* Should be called in a place where no more committed transaction ids are returned, so that
* applied transactions can catch up.
*
* @return {@code true} if the latest applied transaction (without any lower transaction id gaps)
* is the same as the highest returned {@code committed transaction id}.
*/
boolean closedTransactionIdIsOnParWithOpenedTransactionId();
/**
* Forces the transaction id counters to persistent storage.
*/
void flush();
}