]>
Commit | Line | Data |
---|---|---|
7c673cae | 1 | // Copyright (c) 2011-present, Facebook, Inc. All rights reserved. |
11fdf7f2 TL |
2 | // This source code is licensed under both the GPLv2 (found in the |
3 | // COPYING file in the root directory) and Apache 2.0 License | |
4 | // (found in the LICENSE.Apache file in the root directory). | |
7c673cae FG |
5 | // |
6 | // Copyright (c) 2011 The LevelDB Authors. All rights reserved. | |
7 | // Use of this source code is governed by a BSD-style license that can be | |
8 | // found in the LICENSE file. See the AUTHORS file for names of contributors. | |
9 | package org.rocksdb; | |
10 | ||
11 | import org.junit.ClassRule; | |
12 | import org.junit.Rule; | |
13 | import org.junit.Test; | |
14 | import org.junit.rules.TemporaryFolder; | |
11fdf7f2 TL |
15 | import org.rocksdb.util.CapturingWriteBatchHandler; |
16 | import org.rocksdb.util.CapturingWriteBatchHandler.Event; | |
17 | import org.rocksdb.util.WriteBatchGetter; | |
7c673cae FG |
18 | |
19 | import static org.assertj.core.api.Assertions.assertThat; | |
11fdf7f2 TL |
20 | import static org.rocksdb.util.CapturingWriteBatchHandler.Action.*; |
21 | import static java.nio.charset.StandardCharsets.UTF_8; | |
7c673cae FG |
22 | |
23 | /** | |
24 | * This class mimics the db/write_batch_test.cc | |
25 | * in the c++ rocksdb library. | |
7c673cae FG |
26 | */ |
27 | public class WriteBatchTest { | |
28 | @ClassRule | |
29 | public static final RocksMemoryResource rocksMemoryResource = | |
30 | new RocksMemoryResource(); | |
31 | ||
32 | @Rule | |
33 | public TemporaryFolder dbFolder = new TemporaryFolder(); | |
34 | ||
35 | @Test | |
36 | public void emptyWriteBatch() { | |
37 | try (final WriteBatch batch = new WriteBatch()) { | |
38 | assertThat(batch.count()).isEqualTo(0); | |
39 | } | |
40 | } | |
41 | ||
42 | @Test | |
43 | public void multipleBatchOperations() | |
11fdf7f2 TL |
44 | throws RocksDBException { |
45 | ||
46 | final byte[] foo = "foo".getBytes(UTF_8); | |
47 | final byte[] bar = "bar".getBytes(UTF_8); | |
48 | final byte[] box = "box".getBytes(UTF_8); | |
49 | final byte[] baz = "baz".getBytes(UTF_8); | |
50 | final byte[] boo = "boo".getBytes(UTF_8); | |
51 | final byte[] hoo = "hoo".getBytes(UTF_8); | |
52 | final byte[] hello = "hello".getBytes(UTF_8); | |
53 | ||
54 | try (final WriteBatch batch = new WriteBatch()) { | |
55 | batch.put(foo, bar); | |
56 | batch.delete(box); | |
57 | batch.put(baz, boo); | |
58 | batch.merge(baz, hoo); | |
59 | batch.singleDelete(foo); | |
60 | batch.deleteRange(baz, foo); | |
61 | batch.putLogData(hello); | |
62 | ||
63 | try(final CapturingWriteBatchHandler handler = | |
64 | new CapturingWriteBatchHandler()) { | |
65 | batch.iterate(handler); | |
66 | ||
67 | assertThat(handler.getEvents().size()).isEqualTo(7); | |
68 | ||
69 | assertThat(handler.getEvents().get(0)).isEqualTo(new Event(PUT, foo, bar)); | |
70 | assertThat(handler.getEvents().get(1)).isEqualTo(new Event(DELETE, box, null)); | |
71 | assertThat(handler.getEvents().get(2)).isEqualTo(new Event(PUT, baz, boo)); | |
72 | assertThat(handler.getEvents().get(3)).isEqualTo(new Event(MERGE, baz, hoo)); | |
73 | assertThat(handler.getEvents().get(4)).isEqualTo(new Event(SINGLE_DELETE, foo, null)); | |
74 | assertThat(handler.getEvents().get(5)).isEqualTo(new Event(DELETE_RANGE, baz, foo)); | |
75 | assertThat(handler.getEvents().get(6)).isEqualTo(new Event(LOG, null, hello)); | |
76 | } | |
7c673cae FG |
77 | } |
78 | } | |
79 | ||
80 | @Test | |
81 | public void testAppendOperation() | |
11fdf7f2 | 82 | throws RocksDBException { |
7c673cae FG |
83 | try (final WriteBatch b1 = new WriteBatch(); |
84 | final WriteBatch b2 = new WriteBatch()) { | |
85 | WriteBatchTestInternalHelper.setSequence(b1, 200); | |
86 | WriteBatchTestInternalHelper.setSequence(b2, 300); | |
87 | WriteBatchTestInternalHelper.append(b1, b2); | |
88 | assertThat(getContents(b1).length).isEqualTo(0); | |
89 | assertThat(b1.count()).isEqualTo(0); | |
11fdf7f2 | 90 | b2.put("a".getBytes(UTF_8), "va".getBytes(UTF_8)); |
7c673cae FG |
91 | WriteBatchTestInternalHelper.append(b1, b2); |
92 | assertThat("Put(a, va)@200".equals(new String(getContents(b1), | |
11fdf7f2 | 93 | UTF_8))); |
7c673cae FG |
94 | assertThat(b1.count()).isEqualTo(1); |
95 | b2.clear(); | |
11fdf7f2 | 96 | b2.put("b".getBytes(UTF_8), "vb".getBytes(UTF_8)); |
7c673cae FG |
97 | WriteBatchTestInternalHelper.append(b1, b2); |
98 | assertThat(("Put(a, va)@200" + | |
99 | "Put(b, vb)@201") | |
11fdf7f2 | 100 | .equals(new String(getContents(b1), UTF_8))); |
7c673cae | 101 | assertThat(b1.count()).isEqualTo(2); |
11fdf7f2 | 102 | b2.delete("foo".getBytes(UTF_8)); |
7c673cae FG |
103 | WriteBatchTestInternalHelper.append(b1, b2); |
104 | assertThat(("Put(a, va)@200" + | |
105 | "Put(b, vb)@202" + | |
106 | "Put(b, vb)@201" + | |
107 | "Delete(foo)@203") | |
11fdf7f2 | 108 | .equals(new String(getContents(b1), UTF_8))); |
7c673cae FG |
109 | assertThat(b1.count()).isEqualTo(4); |
110 | } | |
111 | } | |
112 | ||
113 | @Test | |
114 | public void blobOperation() | |
11fdf7f2 | 115 | throws RocksDBException { |
7c673cae | 116 | try (final WriteBatch batch = new WriteBatch()) { |
11fdf7f2 TL |
117 | batch.put("k1".getBytes(UTF_8), "v1".getBytes(UTF_8)); |
118 | batch.put("k2".getBytes(UTF_8), "v2".getBytes(UTF_8)); | |
119 | batch.put("k3".getBytes(UTF_8), "v3".getBytes(UTF_8)); | |
120 | batch.putLogData("blob1".getBytes(UTF_8)); | |
121 | batch.delete("k2".getBytes(UTF_8)); | |
122 | batch.putLogData("blob2".getBytes(UTF_8)); | |
123 | batch.merge("foo".getBytes(UTF_8), "bar".getBytes(UTF_8)); | |
7c673cae FG |
124 | assertThat(batch.count()).isEqualTo(5); |
125 | assertThat(("Merge(foo, bar)@4" + | |
126 | "Put(k1, v1)@0" + | |
127 | "Delete(k2)@3" + | |
128 | "Put(k2, v2)@1" + | |
129 | "Put(k3, v3)@2") | |
11fdf7f2 | 130 | .equals(new String(getContents(batch), UTF_8))); |
7c673cae FG |
131 | } |
132 | } | |
133 | ||
134 | @Test | |
135 | public void savePoints() | |
11fdf7f2 | 136 | throws RocksDBException { |
7c673cae | 137 | try (final WriteBatch batch = new WriteBatch()) { |
11fdf7f2 TL |
138 | batch.put("k1".getBytes(UTF_8), "v1".getBytes(UTF_8)); |
139 | batch.put("k2".getBytes(UTF_8), "v2".getBytes(UTF_8)); | |
140 | batch.put("k3".getBytes(UTF_8), "v3".getBytes(UTF_8)); | |
7c673cae FG |
141 | |
142 | assertThat(getFromWriteBatch(batch, "k1")).isEqualTo("v1"); | |
143 | assertThat(getFromWriteBatch(batch, "k2")).isEqualTo("v2"); | |
144 | assertThat(getFromWriteBatch(batch, "k3")).isEqualTo("v3"); | |
145 | ||
7c673cae FG |
146 | batch.setSavePoint(); |
147 | ||
11fdf7f2 TL |
148 | batch.delete("k2".getBytes(UTF_8)); |
149 | batch.put("k3".getBytes(UTF_8), "v3-2".getBytes(UTF_8)); | |
7c673cae FG |
150 | |
151 | assertThat(getFromWriteBatch(batch, "k2")).isNull(); | |
152 | assertThat(getFromWriteBatch(batch, "k3")).isEqualTo("v3-2"); | |
153 | ||
154 | ||
155 | batch.setSavePoint(); | |
156 | ||
11fdf7f2 TL |
157 | batch.put("k3".getBytes(UTF_8), "v3-3".getBytes(UTF_8)); |
158 | batch.put("k4".getBytes(UTF_8), "v4".getBytes(UTF_8)); | |
7c673cae FG |
159 | |
160 | assertThat(getFromWriteBatch(batch, "k3")).isEqualTo("v3-3"); | |
161 | assertThat(getFromWriteBatch(batch, "k4")).isEqualTo("v4"); | |
162 | ||
163 | ||
164 | batch.rollbackToSavePoint(); | |
165 | ||
166 | assertThat(getFromWriteBatch(batch, "k2")).isNull(); | |
167 | assertThat(getFromWriteBatch(batch, "k3")).isEqualTo("v3-2"); | |
168 | assertThat(getFromWriteBatch(batch, "k4")).isNull(); | |
169 | ||
170 | ||
171 | batch.rollbackToSavePoint(); | |
172 | ||
173 | assertThat(getFromWriteBatch(batch, "k1")).isEqualTo("v1"); | |
174 | assertThat(getFromWriteBatch(batch, "k2")).isEqualTo("v2"); | |
175 | assertThat(getFromWriteBatch(batch, "k3")).isEqualTo("v3"); | |
176 | assertThat(getFromWriteBatch(batch, "k4")).isNull(); | |
177 | } | |
178 | } | |
179 | ||
180 | @Test | |
181 | public void deleteRange() throws RocksDBException { | |
182 | try (final RocksDB db = RocksDB.open(dbFolder.getRoot().getAbsolutePath()); | |
494da23a | 183 | final WriteBatch batch = new WriteBatch(); |
7c673cae FG |
184 | final WriteOptions wOpt = new WriteOptions()) { |
185 | db.put("key1".getBytes(), "value".getBytes()); | |
186 | db.put("key2".getBytes(), "12345678".getBytes()); | |
187 | db.put("key3".getBytes(), "abcdefg".getBytes()); | |
188 | db.put("key4".getBytes(), "xyz".getBytes()); | |
189 | assertThat(db.get("key1".getBytes())).isEqualTo("value".getBytes()); | |
190 | assertThat(db.get("key2".getBytes())).isEqualTo("12345678".getBytes()); | |
191 | assertThat(db.get("key3".getBytes())).isEqualTo("abcdefg".getBytes()); | |
192 | assertThat(db.get("key4".getBytes())).isEqualTo("xyz".getBytes()); | |
193 | ||
7c673cae | 194 | batch.deleteRange("key2".getBytes(), "key4".getBytes()); |
494da23a | 195 | db.write(wOpt, batch); |
7c673cae FG |
196 | |
197 | assertThat(db.get("key1".getBytes())).isEqualTo("value".getBytes()); | |
198 | assertThat(db.get("key2".getBytes())).isNull(); | |
199 | assertThat(db.get("key3".getBytes())).isNull(); | |
200 | assertThat(db.get("key4".getBytes())).isEqualTo("xyz".getBytes()); | |
201 | } | |
202 | } | |
203 | ||
11fdf7f2 TL |
204 | @Test |
205 | public void restorePoints() throws RocksDBException { | |
206 | try (final WriteBatch batch = new WriteBatch()) { | |
207 | ||
208 | batch.put("k1".getBytes(), "v1".getBytes()); | |
209 | batch.put("k2".getBytes(), "v2".getBytes()); | |
210 | ||
211 | batch.setSavePoint(); | |
212 | ||
213 | batch.put("k1".getBytes(), "123456789".getBytes()); | |
214 | batch.delete("k2".getBytes()); | |
215 | ||
216 | batch.rollbackToSavePoint(); | |
217 | ||
218 | try(final CapturingWriteBatchHandler handler = new CapturingWriteBatchHandler()) { | |
219 | batch.iterate(handler); | |
220 | ||
221 | assertThat(handler.getEvents().size()).isEqualTo(2); | |
222 | assertThat(handler.getEvents().get(0)).isEqualTo(new Event(PUT, "k1".getBytes(), "v1".getBytes())); | |
223 | assertThat(handler.getEvents().get(1)).isEqualTo(new Event(PUT, "k2".getBytes(), "v2".getBytes())); | |
224 | } | |
225 | } | |
226 | } | |
227 | ||
7c673cae FG |
228 | @Test(expected = RocksDBException.class) |
229 | public void restorePoints_withoutSavePoints() throws RocksDBException { | |
230 | try (final WriteBatch batch = new WriteBatch()) { | |
231 | batch.rollbackToSavePoint(); | |
232 | } | |
233 | } | |
234 | ||
235 | @Test(expected = RocksDBException.class) | |
236 | public void restorePoints_withoutSavePoints_nested() throws RocksDBException { | |
237 | try (final WriteBatch batch = new WriteBatch()) { | |
238 | ||
239 | batch.setSavePoint(); | |
240 | batch.rollbackToSavePoint(); | |
241 | ||
242 | // without previous corresponding setSavePoint | |
243 | batch.rollbackToSavePoint(); | |
244 | } | |
245 | } | |
246 | ||
11fdf7f2 TL |
247 | @Test |
248 | public void popSavePoint() throws RocksDBException { | |
249 | try (final WriteBatch batch = new WriteBatch()) { | |
250 | ||
251 | batch.put("k1".getBytes(), "v1".getBytes()); | |
252 | batch.put("k2".getBytes(), "v2".getBytes()); | |
253 | ||
254 | batch.setSavePoint(); | |
255 | ||
256 | batch.put("k1".getBytes(), "123456789".getBytes()); | |
257 | batch.delete("k2".getBytes()); | |
258 | ||
259 | batch.setSavePoint(); | |
260 | ||
261 | batch.popSavePoint(); | |
262 | ||
263 | batch.rollbackToSavePoint(); | |
264 | ||
265 | try(final CapturingWriteBatchHandler handler = new CapturingWriteBatchHandler()) { | |
266 | batch.iterate(handler); | |
267 | ||
268 | assertThat(handler.getEvents().size()).isEqualTo(2); | |
269 | assertThat(handler.getEvents().get(0)).isEqualTo(new Event(PUT, "k1".getBytes(), "v1".getBytes())); | |
270 | assertThat(handler.getEvents().get(1)).isEqualTo(new Event(PUT, "k2".getBytes(), "v2".getBytes())); | |
271 | } | |
272 | } | |
7c673cae FG |
273 | } |
274 | ||
11fdf7f2 TL |
275 | @Test(expected = RocksDBException.class) |
276 | public void popSavePoint_withoutSavePoints() throws RocksDBException { | |
277 | try (final WriteBatch batch = new WriteBatch()) { | |
278 | batch.popSavePoint(); | |
7c673cae FG |
279 | } |
280 | } | |
281 | ||
11fdf7f2 TL |
282 | @Test(expected = RocksDBException.class) |
283 | public void popSavePoint_withoutSavePoints_nested() throws RocksDBException { | |
284 | try (final WriteBatch batch = new WriteBatch()) { | |
7c673cae | 285 | |
11fdf7f2 TL |
286 | batch.setSavePoint(); |
287 | batch.popSavePoint(); | |
288 | ||
289 | // without previous corresponding setSavePoint | |
290 | batch.popSavePoint(); | |
291 | } | |
292 | } | |
7c673cae | 293 | |
11fdf7f2 TL |
294 | @Test |
295 | public void maxBytes() throws RocksDBException { | |
296 | try (final WriteBatch batch = new WriteBatch()) { | |
297 | batch.setMaxBytes(19); | |
7c673cae | 298 | |
11fdf7f2 | 299 | batch.put("k1".getBytes(), "v1".getBytes()); |
7c673cae | 300 | } |
11fdf7f2 | 301 | } |
7c673cae | 302 | |
11fdf7f2 TL |
303 | @Test(expected = RocksDBException.class) |
304 | public void maxBytes_over() throws RocksDBException { | |
305 | try (final WriteBatch batch = new WriteBatch()) { | |
306 | batch.setMaxBytes(1); | |
307 | ||
308 | batch.put("k1".getBytes(), "v1".getBytes()); | |
7c673cae | 309 | } |
11fdf7f2 | 310 | } |
7c673cae | 311 | |
11fdf7f2 TL |
312 | @Test |
313 | public void data() throws RocksDBException { | |
314 | try (final WriteBatch batch1 = new WriteBatch()) { | |
315 | batch1.delete("k0".getBytes()); | |
316 | batch1.put("k1".getBytes(), "v1".getBytes()); | |
317 | batch1.put("k2".getBytes(), "v2".getBytes()); | |
318 | batch1.put("k3".getBytes(), "v3".getBytes()); | |
319 | batch1.putLogData("log1".getBytes()); | |
320 | batch1.merge("k2".getBytes(), "v22".getBytes()); | |
321 | batch1.delete("k3".getBytes()); | |
322 | ||
323 | final byte[] serialized = batch1.data(); | |
324 | ||
325 | try(final WriteBatch batch2 = new WriteBatch(serialized)) { | |
326 | assertThat(batch2.count()).isEqualTo(batch1.count()); | |
327 | ||
328 | try(final CapturingWriteBatchHandler handler1 = new CapturingWriteBatchHandler()) { | |
329 | batch1.iterate(handler1); | |
330 | ||
331 | try (final CapturingWriteBatchHandler handler2 = new CapturingWriteBatchHandler()) { | |
332 | batch2.iterate(handler2); | |
333 | ||
334 | assertThat(handler1.getEvents().equals(handler2.getEvents())).isTrue(); | |
335 | } | |
336 | } | |
7c673cae FG |
337 | } |
338 | } | |
11fdf7f2 | 339 | } |
7c673cae | 340 | |
11fdf7f2 TL |
341 | @Test |
342 | public void dataSize() throws RocksDBException { | |
343 | try (final WriteBatch batch = new WriteBatch()) { | |
344 | batch.put("k1".getBytes(), "v1".getBytes()); | |
345 | ||
346 | assertThat(batch.getDataSize()).isEqualTo(19); | |
7c673cae | 347 | } |
11fdf7f2 | 348 | } |
7c673cae | 349 | |
11fdf7f2 TL |
350 | @Test |
351 | public void hasPut() throws RocksDBException { | |
352 | try (final WriteBatch batch = new WriteBatch()) { | |
353 | assertThat(batch.hasPut()).isFalse(); | |
354 | ||
355 | batch.put("k1".getBytes(), "v1".getBytes()); | |
356 | ||
357 | assertThat(batch.hasPut()).isTrue(); | |
358 | } | |
359 | } | |
360 | ||
361 | @Test | |
362 | public void hasDelete() throws RocksDBException { | |
363 | try (final WriteBatch batch = new WriteBatch()) { | |
364 | assertThat(batch.hasDelete()).isFalse(); | |
365 | ||
366 | batch.delete("k1".getBytes()); | |
367 | ||
368 | assertThat(batch.hasDelete()).isTrue(); | |
369 | } | |
370 | } | |
371 | ||
372 | @Test | |
373 | public void hasSingleDelete() throws RocksDBException { | |
374 | try (final WriteBatch batch = new WriteBatch()) { | |
375 | assertThat(batch.hasSingleDelete()).isFalse(); | |
376 | ||
377 | batch.singleDelete("k1".getBytes()); | |
378 | ||
379 | assertThat(batch.hasSingleDelete()).isTrue(); | |
380 | } | |
381 | } | |
382 | ||
383 | @Test | |
384 | public void hasDeleteRange() throws RocksDBException { | |
385 | try (final WriteBatch batch = new WriteBatch()) { | |
386 | assertThat(batch.hasDeleteRange()).isFalse(); | |
387 | ||
388 | batch.deleteRange("k1".getBytes(), "k2".getBytes()); | |
389 | ||
390 | assertThat(batch.hasDeleteRange()).isTrue(); | |
391 | } | |
392 | } | |
393 | ||
394 | @Test | |
395 | public void hasBeginPrepareRange() throws RocksDBException { | |
396 | try (final WriteBatch batch = new WriteBatch()) { | |
397 | assertThat(batch.hasBeginPrepare()).isFalse(); | |
398 | } | |
399 | } | |
400 | ||
401 | @Test | |
494da23a | 402 | public void hasEndPrepareRange() throws RocksDBException { |
11fdf7f2 TL |
403 | try (final WriteBatch batch = new WriteBatch()) { |
404 | assertThat(batch.hasEndPrepare()).isFalse(); | |
7c673cae | 405 | } |
11fdf7f2 TL |
406 | } |
407 | ||
408 | @Test | |
409 | public void hasCommit() throws RocksDBException { | |
410 | try (final WriteBatch batch = new WriteBatch()) { | |
411 | assertThat(batch.hasCommit()).isFalse(); | |
412 | } | |
413 | } | |
414 | ||
415 | @Test | |
416 | public void hasRollback() throws RocksDBException { | |
417 | try (final WriteBatch batch = new WriteBatch()) { | |
418 | assertThat(batch.hasRollback()).isFalse(); | |
419 | } | |
420 | } | |
421 | ||
422 | @Test | |
423 | public void walTerminationPoint() throws RocksDBException { | |
424 | try (final WriteBatch batch = new WriteBatch()) { | |
425 | WriteBatch.SavePoint walTerminationPoint = batch.getWalTerminationPoint(); | |
426 | assertThat(walTerminationPoint.isCleared()).isTrue(); | |
427 | ||
428 | batch.put("k1".getBytes(UTF_8), "v1".getBytes(UTF_8)); | |
429 | ||
430 | batch.markWalTerminationPoint(); | |
431 | ||
432 | walTerminationPoint = batch.getWalTerminationPoint(); | |
433 | assertThat(walTerminationPoint.getSize()).isEqualTo(19); | |
434 | assertThat(walTerminationPoint.getCount()).isEqualTo(1); | |
435 | assertThat(walTerminationPoint.getContentFlags()).isEqualTo(2); | |
436 | } | |
437 | } | |
7c673cae | 438 | |
11fdf7f2 TL |
439 | @Test |
440 | public void getWriteBatch() { | |
441 | try (final WriteBatch batch = new WriteBatch()) { | |
442 | assertThat(batch.getWriteBatch()).isEqualTo(batch); | |
7c673cae | 443 | } |
11fdf7f2 TL |
444 | } |
445 | ||
446 | static byte[] getContents(final WriteBatch wb) { | |
447 | return getContents(wb.nativeHandle_); | |
448 | } | |
7c673cae | 449 | |
11fdf7f2 TL |
450 | static String getFromWriteBatch(final WriteBatch wb, final String key) |
451 | throws RocksDBException { | |
452 | final WriteBatchGetter getter = | |
453 | new WriteBatchGetter(key.getBytes(UTF_8)); | |
454 | wb.iterate(getter); | |
455 | if(getter.getValue() != null) { | |
456 | return new String(getter.getValue(), UTF_8); | |
457 | } else { | |
458 | return null; | |
7c673cae FG |
459 | } |
460 | } | |
11fdf7f2 TL |
461 | |
462 | private static native byte[] getContents(final long writeBatchHandle); | |
7c673cae FG |
463 | } |
464 | ||
465 | /** | |
466 | * Package-private class which provides java api to access | |
467 | * c++ WriteBatchInternal. | |
468 | */ | |
469 | class WriteBatchTestInternalHelper { | |
470 | static void setSequence(final WriteBatch wb, final long sn) { | |
471 | setSequence(wb.nativeHandle_, sn); | |
472 | } | |
473 | ||
474 | static long sequence(final WriteBatch wb) { | |
475 | return sequence(wb.nativeHandle_); | |
476 | } | |
477 | ||
478 | static void append(final WriteBatch wb1, final WriteBatch wb2) { | |
479 | append(wb1.nativeHandle_, wb2.nativeHandle_); | |
480 | } | |
481 | ||
482 | private static native void setSequence(final long writeBatchHandle, | |
483 | final long sn); | |
484 | ||
485 | private static native long sequence(final long writeBatchHandle); | |
486 | ||
487 | private static native void append(final long writeBatchHandle1, | |
488 | final long writeBatchHandle2); | |
489 | } |