# Writing keys out of order fails.
run error
sst_put k=b ts=1 v=b1
sst_put k=a ts=1 v=a1
----
>> at end:
<no data>
error: (*withstack.withStack:) pebble: keys must be added in strictly increasing order: "b"/1.000000000,0#0,SET, "a"/1.000000000,0#0,SET

run error
sst_put k=a ts=1 v=a1
sst_put k=a ts=2 v=a2
----
>> at end:
<no data>
error: (*withstack.withStack:) pebble: keys must be added in strictly increasing order: "a"/1.000000000,0#0,SET, "a"/2.000000000,0#0,SET

run error
sst_put_rangekey k=d end=f ts=1
sst_put_rangekey k=a end=c ts=1
----
>> at end:
<no data>
error: (*withstack.withStack:) pebble: spans must be added in order: "d"/0,0 > "a"/0,0

# TODO(jackson): This test doesn't pass yet. The SST writer does not enforce the
# ordering among range key timestamps.
#run ok
#sst_put_rangekey k=a end=c ts=1
#sst_put_rangekey k=a end=c ts=2
#----
#>> at end:
#<no data>
#error: (*withstack.withStack:) pebble: suffixes must be added in order: /1.000000000,0 > /2.000000000,0

# Writing invalid range keys fails.
run error
sst_reset
sst_put_rangekey k=f end=c ts=1
----
>> at end:
<no data>
error: (*withstack.withStack:) invalid range key {f-c}/1.000000000,0: start key "f" is at or after end key "c"

# Writing the same key multiple times (in different SSTs). Iteration sees the
# first written key.
run ok
sst_put k=a ts=1 v=a1
sst_put_rangekey k=a end=c ts=3 localTs=2
sst_finish
sst_put k=a ts=1 v=again
sst_put_rangekey k=a end=c ts=3 localTs=1
----
>> at end:
<no data>
>> sst-0:
set: "a"/1.000000000,0 -> /BYTES/a1
rangekeyset: {a-c}/3.000000000,0 -> {localTs=2.000000000,0}/<empty>
>> sst-1:
set: "a"/1.000000000,0 -> /BYTES/again
rangekeyset: {a-c}/3.000000000,0 -> {localTs=1.000000000,0}/<empty>

run ok
sst_iter_new
iter_seek_ge k=a
iter_scan
----
iter_seek_ge: {a-c}/[3.000000000,0={localTs=1.000000000,0}/<empty>] !
iter_scan: {a-c}/[3.000000000,0={localTs=1.000000000,0}/<empty>] !
iter_scan: "a"/1.000000000,0=/BYTES/again {a-c}/[3.000000000,0={localTs=1.000000000,0}/<empty>]
iter_scan: .

# Writing abutting range keys. Iteration defragments them, unless the value
# is different.
run ok
sst_reset
sst_put_rangekey k=f end=g ts=3
sst_put_rangekey k=g end=h ts=3
sst_put_rangekey k=h end=j ts=3 localTs=2
sst_finish
sst_iter_new
iter_seek_ge k=a
iter_scan
----
iter_seek_ge: {f-h}/[3.000000000,0=/<empty>] !
iter_scan: {f-h}/[3.000000000,0=/<empty>] !
iter_scan: {h-j}/[3.000000000,0={localTs=2.000000000,0}/<empty>] !
iter_scan: .
>> at end:
<no data>
>> sst-0:
rangekeyset: {f-g}/3.000000000,0 -> /<empty>
rangekeyset: {g-h}/3.000000000,0 -> /<empty>
rangekeyset: {h-j}/3.000000000,0 -> {localTs=2.000000000,0}/<empty>

# Clearing a span. Iteration still sees cleared keys when clear is in the same
# SST, because the clear needs to be at a higher seqnum than the keys that it
# clears, and the SST is built at a single seqnum. A later clear in a different
# SST properly clears them.
run ok
sst_reset
sst_put k=b ts=1 v=b1
sst_put k=c ts=2 v=c2
sst_put k=d ts=1 v=d1
sst_put k=e ts=1 v=e1
sst_put_rangekey k=a end=f ts=3
sst_clear_range k=c end=e
----
>> at end:
<no data>
>> sst-0:
set: "b"/1.000000000,0 -> /BYTES/b1
set: "c"/2.000000000,0 -> /BYTES/c2
set: "d"/1.000000000,0 -> /BYTES/d1
set: "e"/1.000000000,0 -> /BYTES/e1
rangedel: {c-e}
rangekeyset: {a-c}/3.000000000,0 -> /<empty>
rangekeyset: {c-e}/3.000000000,0 -> /<empty>
rangekeydel: {c-e}
rangekeyset: {e-f}/3.000000000,0 -> /<empty>

run ok
sst_iter_new
iter_seek_ge k=a
iter_scan
----
iter_seek_ge: {a-f}/[3.000000000,0=/<empty>] !
iter_scan: {a-f}/[3.000000000,0=/<empty>] !
iter_scan: "b"/1.000000000,0=/BYTES/b1 {a-f}/[3.000000000,0=/<empty>]
iter_scan: "c"/2.000000000,0=/BYTES/c2 {a-f}/[3.000000000,0=/<empty>]
iter_scan: "d"/1.000000000,0=/BYTES/d1 {a-f}/[3.000000000,0=/<empty>]
iter_scan: "e"/1.000000000,0=/BYTES/e1 {a-f}/[3.000000000,0=/<empty>]
iter_scan: .

run ok
sst_clear_range k=c end=e
----
>> at end:
<no data>
>> sst-0:
set: "b"/1.000000000,0 -> /BYTES/b1
set: "c"/2.000000000,0 -> /BYTES/c2
set: "d"/1.000000000,0 -> /BYTES/d1
set: "e"/1.000000000,0 -> /BYTES/e1
rangedel: {c-e}
rangekeyset: {a-c}/3.000000000,0 -> /<empty>
rangekeyset: {c-e}/3.000000000,0 -> /<empty>
rangekeydel: {c-e}
rangekeyset: {e-f}/3.000000000,0 -> /<empty>
>> sst-1:
rangedel: {c-e}
rangekeydel: {c-e}

run ok
sst_iter_new
iter_seek_ge k=a
iter_scan
----
iter_seek_ge: {a-c}/[3.000000000,0=/<empty>] !
iter_scan: {a-c}/[3.000000000,0=/<empty>] !
iter_scan: "b"/1.000000000,0=/BYTES/b1 {a-c}/[3.000000000,0=/<empty>]
iter_scan: {e-f}/[3.000000000,0=/<empty>] !
iter_scan: "e"/1.000000000,0=/BYTES/e1 {e-f}/[3.000000000,0=/<empty>]
iter_scan: .
