# The example used in the documentation for tableRangedDeletionIter. An iterator # over the following table: # # # |---------| |---------| |-------| RANGEKEYDELs # |-----------|-------------| |-----| RANGEDELs # __________________________________________________________ # a b c d e f g h i j k l m n o p q r s t u v w x y z # # yields the following spans: # # 1 3 1 3 2 1 3 2 # |-----|---------|-----|---|-----| |---|-|-----| # __________________________________________________________ # a b c d e f g h i j k l m n o p q r s t u v w x y z # # where: # - 1: homogenous span with range dels only # - 2: homogenous span with range key dels only # - 3: heterogeneous span with range dels and range key dels build a-g:{(#0,RANGEDEL)} g-n:{(#0,RANGEDEL)} t-w:{(#0,RANGEDEL)} d-i:{(#0,RANGEKEYDEL)} l-q:{(#0,RANGEKEYDEL)} v-z:{(#0,RANGEKEYDEL)} ---- 000000:[a#0,RANGEDEL-z#inf,RANGEKEYDEL] spans ---- a-d:{(#0,RANGEDEL)} d-i:{(#0,RANGEKEYDEL) (#0,RANGEDEL)} i-l:{(#0,RANGEDEL)} l-n:{(#0,RANGEKEYDEL) (#0,RANGEDEL)} n-q:{(#0,RANGEKEYDEL)} t-v:{(#0,RANGEDEL)} v-w:{(#0,RANGEKEYDEL) (#0,RANGEDEL)} w-z:{(#0,RANGEKEYDEL)} # The iterator elides anything other than range deletes and range key deletes. # |---------------RANGEKEYUNSET----------------------| # |---------------RANGEKEYSET------------------------| # |---------------RANGEKEYDEL------------------------| # __________________________________________________________ # a b c d e f g h i j k l m n o p q r s t u v w x y z # # Becomes: # |---------------RANGEKEYDEL------------------------| # __________________________________________________________ # a b c d e f g h i j k l m n o p q r s t u v w x y z build a-z:{(#0,RANGEKEYDEL) (#0,RANGEKEYSET,@1,foo) (#0,RANGEKEYUNSET,@2)} ---- 000000:[a#0,RANGEKEYSET-z#inf,RANGEKEYDEL] spans ---- a-z:{(#0,RANGEKEYDEL)} # The same as the above, except that the RANGEKEYDEL is at a lower sequence # number than the SET and UNSET. The three keys exist at different sequence # numbers, with the DEL at the bottom to avoid the perceived affects of # shadowing. build a-z:{(#3,RANGEKEYSET,@1,foo) (#2,RANGEKEYUNSET,@2) (#1,RANGEKEYDEL)} ---- 000000:[a#3,RANGEKEYSET-z#inf,RANGEKEYDEL] spans ---- a-z:{(#1,RANGEKEYDEL)} # |-RANGEKEYSET-|-RANGEKEYUNSET-|-RANGEKEYDEL--------| # __________________________________________________________ # a b c d e f g h i j k l m n o p q r s t u v w x y z # # Becomes: # |-RANGEKEYDEL-------| # __________________________________________________________ # a b c d e f g h i j k l m n o p q r s t u v w x y z build a-h:{(#0,RANGEKEYSET,@1,foo)} h-p:{(#0,RANGEKEYUNSET,@1)} p-z:{(#0,RANGEKEYDEL)} ---- 000000:[a#0,RANGEKEYSET-z#inf,RANGEKEYDEL] spans ---- p-z:{(#0,RANGEKEYDEL)} # |-RANGEKEYSET-|-RANGEKEYUNSET-|-RANGEKEYDEL--------| # |--RANGEDEL-----------------------------| # __________________________________________________________ # a b c d e f g h i j k l m n o p q r s t u v w x y z # # Becomes: # # |---------------1-------------|----3----|----2----| # __________________________________________________________ # a b c d e f g h i j k l m n o p q r s t u v w x y z build a-u:{(#0,RANGEDEL)} a-h:{(#0,RANGEKEYSET,@1,foo)} h-p:{(#0,RANGEKEYUNSET,@1)} p-z:{(#0,RANGEKEYDEL)} ---- 000000:[a#0,RANGEKEYSET-z#inf,RANGEKEYDEL] spans ---- a-p:{(#0,RANGEDEL)} p-u:{(#0,RANGEKEYDEL) (#0,RANGEDEL)} u-z:{(#0,RANGEKEYDEL)} # An iterator over a table with neither range dels or range key dels present # yields no spans. build a-m:{(#0,RANGEKEYSET,@1,foo)} m-z:{(#0,RANGEKEYUNSET,@1)} ---- 000000:[a#0,RANGEKEYSET-z#inf,RANGEKEYUNSET] spans ---- (none) # Abutting spans that are merged emit only the largest and smallest key. build a-c:{(#4,RANGEDEL) (#3,RANGEDEL) (#1,RANGEDEL)} c-d:{(#9,RANGEDEL) (#7,RANGEDEL) (#6,RANGEDEL) (#2,RANGEDEL)} ---- 000000:[a#4,RANGEDEL-d#inf,RANGEDEL] spans ---- a-d:{(#9,RANGEDEL) (#1,RANGEDEL)} # The same as above, but for range key dels. build a-c:{(#4,RANGEKEYDEL) (#3,RANGEKEYDEL) (#1,RANGEKEYDEL)} c-d:{(#9,RANGEKEYDEL) (#7,RANGEKEYDEL) (#6,RANGEKEYDEL) (#2,RANGEKEYDEL)} ---- 000000:[a#4,RANGEKEYDEL-d#inf,RANGEKEYDEL] spans ---- a-d:{(#9,RANGEKEYDEL) (#1,RANGEKEYDEL)} # The same as above, but for mixed key kinds. The resulting span has four keys, # given the respective largest / smallest keys from the range del and range key # del spans are interleaved. build a-c:{(#4,RANGEDEL) (#2,RANGEDEL)} a-c:{(#3,RANGEKEYDEL) (#1,RANGEKEYDEL)} ---- 000000:[a#4,RANGEDEL-c#inf,RANGEDEL] spans ---- a-c:{(#4,RANGEDEL) (#3,RANGEKEYDEL) (#2,RANGEDEL) (#1,RANGEKEYDEL)} # "Hetrogenous spans" (i.e. spans containing both range dels and range key dels) # are preserved when abutting spans are merged. This tests that the reducing # function does not "lose information" of the merged spans, effectively # resulting in the span switching types from a heterogeneous span to a # homogenous span. # 10 |-------|---|---| RANGEDELs # 5 |-------|---| RANGEKEYDELs # 3 |-------|---|---| RANGEDELs # _____________________ # a b c d e build a-c:{(#10,RANGEDEL) (#3,RANGEDEL)} c-d:{(#10,RANGEDEL) (#3,RANGEDEL)} d-e:{(#10,RANGEDEL) (#3,RANGEDEL)} a-c:{(#5,RANGEKEYDEL)} c-d:{(#5,RANGEKEYDEL)} ---- 000000:[a#10,RANGEDEL-e#inf,RANGEDEL] spans ---- a-d:{(#10,RANGEDEL) (#5,RANGEKEYDEL) (#3,RANGEDEL)} d-e:{(#10,RANGEDEL) (#3,RANGEDEL)}