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)