assert val == b"uncommitted-aa3" # uncommitted data from current txn
t0.commit()
t1.abort()
kvdb.sync()
# Get from CN. Keys were previously in LC.
with kvdb.transaction() as t5:
# Committed. Should be visible
val = kvs.get(b"aa1", txn=t5)
assert val == b"uncommitted-aa1"
# Aborted. Should not see this key.
val = kvs.get(b"aa3", txn=t5)
assert val == None
pass
hse.init()
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext().rparams("dur_enable=0")
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(
kvdb, "basic_lc").rparams("transactions_enable=1")
kvs = stack.enter_context(kvs_ctx)
run_test(kvdb, kvs)
finally:
hse.fini()
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.HOME)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "cache")
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"a", b"1")
kvs.put(b"b", b"2")
kvs.put(b"c", b"3")
cursor = kvs.cursor()
revcursor = kvs.cursor(flags=hse.CursorFlag.REVERSE)
kv = cursor.read()
assert kv == (b"a", b"1")
kv = revcursor.read()
assert kv == (b"c", b"3")
kvs.put(b"d", b"4")
def check_keys(cursor: hse.KvsCursor, expected: List[bytes]):
actual = [k for k, _ in cursor.items()]
assert len(actual) == len(expected)
for x, y in zip(expected, actual):
assert x == y
hse.init(cli.HOME)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "update_seek")
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"a", b"1")
kvs.put(b"b", b"2")
kvs.put(b"c", b"3")
kvs.put(b"d", b"4")
cursor = kvs.cursor()
cursor.seek(b"c")
check_keys(cursor, [b"c", b"d"])
cursor.seek(b"c")
cursor.update_view()
check_keys(cursor, [b"c", b"d"])
cursor.destroy()
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.HOME)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "c0cn_dup_keys")
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"0x0001", b"0x0001")
kvs.put(b"0x0010", b"0x0010")
kvs.put(b"0x0002", b"0x0002")
kvs.put(b"0xff00", b"0xff00")
kvs.put(b"0x000f", b"0x000f")
kvs.put(b"0x0006", b"0x0006")
kvs.put(b"0x0003", b"0x0003")
kvs.put(b"0x0004", b"0x0004")
cur = kvs.cursor()
count = sum(1 for _ in cur.items())
assert count == 8
cur.destroy()
cur = kvs.cursor(b"0x00")
from hse2 import hse
from utility import lifecycle
hse.init()
KVS_CPARAMS: Tuple[str, ...] = ("pfx_len=2", "sfx_len=1")
try:
with lifecycle.KvdbContext() as kvdb:
#
# Part 1: Non-Txn KVS
#
with lifecycle.KvsContext(
kvdb,
"kvs37-non_txn").rparams("transactions_enable=0").cparams(
*KVS_CPARAMS) as kvs:
"""
+--------------------+---------------+-------------+
| | Txn kvs | Non-Txn kvs |
+--------------------+---------------+-------------+
| txn read | Yes | No |
+--------------------+---------------+-------------+
| txn write | Yes | No |
+--------------------+---------------+-------------+
| non-txn read | Yes | Yes |
+--------------------+---------------+-------------+
| non-txn write | No | Yes |
+--------------------+---------------+-------------+
"""
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.HOME)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "bind_committed").rparams("transactions_enable=1")
kvs = stack.enter_context(kvs_ctx)
txn = kvdb.transaction()
txn.begin()
txcursor = kvs.cursor(txn=txn)
kvs.put(b"a", b"1", txn=txn)
kvs.put(b"b", b"2", txn=txn)
kvs.put(b"c", b"3", txn=txn)
kv = txcursor.read()
assert kv == (b"a", b"1")
txn.commit()
txn.begin()
kvs.put(b"a", b"12", txn=txn)
# Copyright (C) 2021 Micron Technology, Inc. All rights reserved.
from hse2 import hse
from utility import lifecycle, cli
# Verify a case where full scan and pfx scan return equivalent results
keycount = 10 * 1024 * 1024
hse.init(cli.CONFIG)
try:
with lifecycle.KvdbContext() as kvdb:
for pfxlen in range(4):
with lifecycle.KvsContext(kvdb,
f"compare_full_and_pfx{pfxlen}") as kvs:
for i in range(keycount):
if i % 2 == 0:
key = f"XXXX{i}".encode()
else:
key = f"CCCC{i}".encode()
kvs.put(key, None)
with kvs.cursor() as c1:
s1 = sum(1 for _ in c1.items())
with kvs.cursor(b"CCCC") as c2:
s2 = sum(1 for _ in c2.items())
assert s1 == keycount
assert s2 == keycount / 2
finally:
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.HOME)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "seek_tomb")
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"a", b"1")
kvs.put(b"b", b"2")
kvs.delete(b"a")
with kvs.cursor() as cur:
cur.seek(b"a")
kv = cur.read()
assert kv == (b"b", b"2")
cur.read()
assert cur.eof
kvdb.sync()
cur.update_view()
cur.seek(b"a")
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.HOME)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext().rparams("dur_enable=0")
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "sfx_test_tomb").cparams(
"pfx_len=1", "sfx_len=2"
)
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"AbcXX", b"1")
kvs.put(b"AbdXX", b"1")
kvs.put(b"AbdXY", b"2")
kvdb.sync(flags=hse.SyncFlag.ASYNC)
cnt, *_ = kvs.prefix_probe(b"Abd")
assert cnt == hse.KvsPfxProbeCnt.MUL
kvs.delete(b"AbdXY")
cnt, *kv = kvs.prefix_probe(b"Abd")
assert cnt == hse.KvsPfxProbeCnt.ONE
assert kv == [b"AbdXX", b"1"]
def run_test(kvdb, kvs1, kvs2, func):
with kvs1 as k1:
with kvs2 as k2:
func(kvdb, k1, k2)
pass
hse.init(cli.CONFIG)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext().rparams("durability.enabled=false",
"c0_debug=16")
kvdb = stack.enter_context(kvdb_ctx)
kvs1 = (lifecycle.KvsContext(kvdb, "kvs1").cparams(
"prefix.length=2",
"suffix.length=1").rparams("transactions.enabled=true"))
kvs2 = (lifecycle.KvsContext(kvdb, "kvs2").cparams(
"prefix.length=2",
"suffix.length=1").rparams("transactions.enabled=true"))
run_test(kvdb, kvs1, kvs2, test_case_01)
run_test(kvdb, kvs1, kvs2, test_case_02)
run_test(kvdb, kvs1, kvs2, test_case_03)
finally:
hse.fini()
with kvs.cursor(filt=pfx.encode()) as cur:
k_id = start
for (k, _) in cur.items():
expected = f"{pfx}-{k_id:0>10}".encode()
assert k == expected
assert k_id < end
k_id = k_id + 1
hse.init()
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext().rparams("dur_enable=0")
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "pdel").cparams("pfx_len=2")
kvs = stack.enter_context(kvs_ctx)
num_keys = 50 * 1000
kvs.prefix_delete(b"AA")
add_keys(kvs=kvs, pfx="AA", start=0, end=num_keys)
add_keys(kvs=kvs, pfx="AB", start=0, end=num_keys)
add_keys(kvs=kvs, pfx="AC", start=0, end=num_keys)
add_keys(kvs=kvs, pfx="AD", start=0, end=num_keys)
kvdb.sync()
kvs.prefix_delete(b"AB")
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.HOME)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "delfail")
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"a", b"1")
kvs.put(b"b", b"2")
kvs.put(b"c", b"3")
kvdb.sync()
kvs.delete(b"c")
with kvs.cursor() as cur:
kv = cur.read()
assert kv == (b"a", b"1")
kv = cur.read()
assert kv == (b"b", b"2")
cur.read()
# SPDX-License-Identifier: Apache-2.0
#
# Copyright (C) 2021 Micron Technology, Inc. All rights reserved.
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.CONFIG)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "multicur_multiview")
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"0x0001", b"0x0001")
ca = kvs.cursor()
kvs.put(b"0x0010", b"0x0010")
cb = kvs.cursor()
kvs.put(b"0x0002", b"0x0002")
cc = kvs.cursor()
kvs.put(b"0xff00", b"0xff00")
cd = kvs.cursor()
kvs.put(b"0x000f", b"0x000f")
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle
hse.init()
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext().rparams("dur_enable=0")
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = (lifecycle.KvsContext(kvdb, "sfx_test_txn").cparams(
"pfx_len=1", "sfx_len=2").rparams("transactions_enable=1"))
kvs = stack.enter_context(kvs_ctx)
with kvdb.transaction() as txn:
kvs.put(b"AbcXX", b"1", txn=txn)
kvs.put(b"AbdXX", b"1", txn=txn)
kvs.put(b"AbdXX", b"2", txn=txn)
txn = kvdb.transaction()
txn.begin()
kvdb.sync(flags=hse.SyncFlag.ASYNC)
with kvdb.transaction() as t:
kvs.put(b"AbcXY", b"2", txn=t)
cnt, *kv = kvs.prefix_probe(b"Abc", txn=txn)
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.CONFIG)
KVS_CPARAMS: Tuple[str, ...] = ("prefix.length=2", "suffix.length=1")
try:
with lifecycle.KvdbContext() as kvdb:
#
# Part 1: Non-Txn KVS
#
with lifecycle.KvsContext(
kvdb,
"kvs37-non_txn").rparams("transactions.enabled=false").cparams(
*KVS_CPARAMS) as kvs:
"""
+--------------------+---------------+-------------+
| | Txn kvs | Non-Txn kvs |
+--------------------+---------------+-------------+
| txn read | Yes | No |
+--------------------+---------------+-------------+
| txn write | Yes | No |
+--------------------+---------------+-------------+
| non-txn read | Yes | Yes |
+--------------------+---------------+-------------+
| non-txn write | No | Yes |
+--------------------+---------------+-------------+
"""
# SPDX-License-Identifier: Apache-2.0
#
# Copyright (C) 2021 Micron Technology, Inc. All rights reserved.
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.CONFIG)
try:
with lifecycle.KvdbContext().rparams("durability.enabled=false") as kvdb:
# Test 1: Update after seek. Seek can be to an existing key or non-existent key
with lifecycle.KvsContext(kvdb, "pos_stab-1") as kvs:
kvs.put(b"a", b"1")
kvs.put(b"b", b"2")
kvs.put(b"d", b"4")
kvs.put(b"e", b"5")
cursor = kvs.cursor()
# seek to an existing key and update_view.
cursor.seek(b"b")
cursor.update_view()
kv = cursor.read()
assert kv == (b"b", b"2")
# seek to a non-existent key and update_view.
cursor.seek(b"c")
"""
This script tests the following (forward cursors only):
1. Updated cursor reads newly inserted key right after its last read key.
2. Updated cursor reads new key inserted past eof when cursor had reached eof
3. A bound cursor passes case 1 and 2 without needing an update_view
"""
hse.init(cli.CONFIG)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "update_no_seek").rparams("transactions.enabled=true")
kvs = stack.enter_context(kvs_ctx)
txn1 = kvdb.transaction()
txn1.begin()
kvs.put(b"a", b"1", txn=txn1)
kvs.put(b"b", b"2", txn=txn1)
kvs.put(b"c", b"3", txn=txn1)
# Read 2 keys using a cursor. Leave cursor pointing to 'c'
cursor = kvs.cursor(txn=txn1)
kv = cursor.read()
assert kv == (b"a", b"1")
kv = cursor.read()
assert kv == (b"b", b"2")
def check_keys(cursor: hse.KvsCursor, expected: List[bytes]):
actual = [k for k, _ in cursor.items()]
assert len(actual) == len(expected)
for x, y in zip(expected, actual):
assert x == y
hse.init(cli.CONFIG)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(
kvdb, "nostale").rparams("transactions.enabled=true")
kvs = stack.enter_context(kvs_ctx)
# Insert some keys
with kvdb.transaction() as txn:
kvs.put(b"a", b"1", txn=txn)
kvs.put(b"b", b"2", txn=txn)
kvs.put(b"c", b"3", txn=txn)
kvs.put(b"d", b"4", txn=txn)
# Begin three transactions
txn1 = kvdb.transaction()
txn1.begin()
txn2 = kvdb.transaction()
txn2.begin()
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.HOME)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "cache_delay")
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"a", b"1")
kvs.put(b"b", b"2")
kvs.put(b"c", b"3")
cursor = kvs.cursor()
kv = cursor.read()
assert kv == (b"a", b"1")
kvs.put(b"d", b"4")
kv = cursor.read()
assert kv == (b"b", b"2")
kv = cursor.read()
assert kv == (b"c", b"3")
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.HOME)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "bug_update_add_key")
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"a", b"1")
kvs.put(b"b", b"2")
cursor = kvs.cursor()
kv = cursor.read()
assert kv == (b"a", b"1")
kv = cursor.read()
assert kv == (b"b", b"2")
cursor.read()
assert cursor.eof
kvs.put(b"c", b"3")
cursor.update_view()
cursor.seek(b"0x00")
c.update_view()
assert c.read() == (b"ab02", b"val-c0")
c.seek(b"ab02")
c.update_view()
assert c.read() == (b"ab02", b"val-c0")
hse.init(cli.HOME)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext().rparams("dur_enable=0")
kvdb = stack.enter_context(kvdb_ctx)
with lifecycle.KvsContext(kvdb, "test_kvs").cparams(
"pfx_len=2",
"sfx_len=1").rparams("transactions_enable=1") as kvs:
separate_keys(kvdb, kvs)
# Duplicate keys
with lifecycle.KvsContext(kvdb, "test_kvs").cparams(
"pfx_len=2",
"sfx_len=1").rparams("transactions_enable=1") as kvs:
duplicate_c0_lc(kvdb, kvs, cursor_sync=False)
with lifecycle.KvsContext(kvdb, "test_kvs").cparams(
"pfx_len=2",
"sfx_len=1").rparams("transactions_enable=1") as kvs:
duplicate_lc_cn(kvdb, kvs, cursor_sync=False)
with lifecycle.KvsContext(kvdb, "test_kvs").cparams(
"pfx_len=2",
"sfx_len=1").rparams("transactions_enable=1") as kvs:
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle
hse.init()
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs1_ctx = lifecycle.KvsContext(
kvdb, "bind-1").rparams("transactions_enable=1")
kvs2_ctx = lifecycle.KvsContext(
kvdb, "bind-2").rparams("transactions_enable=1")
kvs1 = stack.enter_context(kvs1_ctx)
kvs2 = stack.enter_context(kvs2_ctx)
with kvdb.transaction() as txn:
kvs1.put(b"a", b"1", txn=txn)
kvs1.put(b"b", b"1", txn=txn)
kvs1.put(b"c", b"1", txn=txn)
with kvdb.transaction() as txn:
kvs2.put(b"a", b"2", txn=txn)
kvs2.put(b"b", b"2", txn=txn)
kvs2.put(b"c", b"2", txn=txn)
with kvdb.transaction() as txn:
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle
# Scan a billion keys
keycount = 1000 * 1000 * 1000
kvsname = "scan_a_billion"
hse.init()
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, kvsname)
kvs = stack.enter_context(kvs_ctx)
for i in range(keycount):
key = f"key{i}".encode()
kvs.put(key, None)
with kvs.cursor() as cur:
s = sum(1 for _ in cur.items())
assert s == keycount
finally:
hse.fini()
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle
hse.init()
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(
kvdb, "bug_skidx_not_init").rparams("transactions_enable=1")
kvs = stack.enter_context(kvs_ctx)
with kvdb.transaction() as txn:
kvs.put(b"0x000000012b0204", b"key1", txn=txn)
kvs.put(b"0x000000012b0404", b"key2", txn=txn)
kvs.put(b"0x000000012b0604", b"key3", txn=txn)
with kvs.cursor(b"0x00000001", flags=0, txn=txn) as cur:
cur.read()
cur.read()
cur.read()
cur.read()
assert cur.eof
finally:
hse.fini()
#!/usr/bin/env python3
from hse2 import hse
from contextlib import ExitStack
from utility import lifecycle
hse.init()
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(
kvdb, "abort_destroy").rparams("transactions_enable=1")
kvs = stack.enter_context(kvs_ctx)
txn = kvdb.transaction()
txn.begin()
cursor = kvs.cursor(txn=txn, flags=0)
txn.abort()
cursor.destroy()
finally:
hse.fini()
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.HOME)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "basic")
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"a", b"1")
kvs.put(b"b", b"2")
assert kvs.get(b"a") == b"1"
assert kvs.get(b"b") == b"2"
with kvs.cursor() as cur:
kv = cur.read()
assert kv == (b"a", b"1")
kv = cur.read()
assert kv == (b"b", b"2")
cur.read()
assert cur.eof
cur.seek(b"a")
kv = cur.read()
assert kv == (b"a", b"1")
finally:
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.HOME)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext().rparams("dur_enable=0")
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(
kvdb, "cn_seqno").rparams("transactions_enable=1")
kvs = stack.enter_context(kvs_ctx)
txn = kvdb.transaction()
txn.begin()
with kvdb.transaction() as t:
kvs.put(b"a", b"1", txn=t)
kvdb.sync()
txcursor = kvs.cursor(txn=txn)
txcursor.read()
assert txcursor.eof
txn.abort()
txcursor.seek(b"0")
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle
hse.init()
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext().rparams("dur_enable=0")
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "ingested_key")
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"a", b"1")
cursor = kvs.cursor()
kvdb.sync()
kv = cursor.read()
assert kv == (b"a", b"1")
cursor.read()
assert cursor.eof
cursor.destroy()
finally:
hse.fini()
#!/usr/bin/env python3
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle
hse.init()
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "bug_wrong_view_value")
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"a", b"1")
kvs.put(b"b", b"2")
with kvs.cursor() as cur:
# replace a, outside of view of cursor
kvs.put(b"a", b"3")
kv = cur.read()
assert kv == (b"a", b"1")
cur.read()
cur.read()
cur.update_view()
cur.seek(b"a")
# SPDX-License-Identifier: Apache-2.0
#
# Copyright (C) 2021 Micron Technology, Inc. All rights reserved.
from contextlib import ExitStack
from hse2 import hse
from utility import lifecycle, cli
hse.init(cli.CONFIG)
try:
with ExitStack() as stack:
kvdb_ctx = lifecycle.KvdbContext()
kvdb = stack.enter_context(kvdb_ctx)
kvs_ctx = lifecycle.KvsContext(kvdb, "bug_update_new_kvms")
kvs = stack.enter_context(kvs_ctx)
kvs.put(b"a", b"1")
kvs.put(b"b", b"2")
cursor = kvs.cursor()
kv = cursor.read()
assert kv == (b"a", b"1")
kv = cursor.read()
assert kv == (b"b", b"2")
cursor.read()
assert cursor.eof
kvdb.sync(flags=hse.KvdbSyncFlag.ASYNC)
