/test/merge.erl

https://gitlab.com/barrel-db/erlang-rocksdb · Erlang · 346 lines · 248 code · 81 blank · 17 comment · 0 complexity · 3dd95eddad1ee875bc4d1964f1479250 MD5 · raw file 

    

  1. %% Copyright (c) 2018-2020 Benoit Chesneau
    2. 

  2. %%
    3. 

  3. %% This file is provided to you under the Apache License,
    4. 

  4. %% Version 2.0 (the "License"); you may not use this file
    5. 

  5. %% except in compliance with the License.  You may obtain
    6. 

  6. %% a copy of the License at
    7. 

  7. %%
    8. 

  8. %%   http://www.apache.org/licenses/LICENSE-2.0
    9. 

  9. %%
    10. 

  10. %% Unless required by applicable law or agreed to in writing,
    11. 

  11. %% software distributed under the License is distributed on an
    12. 

  12. %% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    13. 

  13. %% KIND, either express or implied.  See the License for the
    14. 

  14. %% specific language governing permissions and limitations
    15. 

  15. %% under the License.
    16. 

  16. %%
    17. 

  17. %% -------------------------------------------------------------------
    18. 

  18. 

  19. -module(merge).
    20. 

  20. 

  21. -include_lib("eunit/include/eunit.hrl").
    22. 

  22. 

  23. 

  24. merge_int_test() ->
    25. 

  25.   rocksdb_test_util:rm_rf("rocksdb_merge_db.test"),
    26. 

  26.   {ok, Db} = rocksdb:open("rocksdb_merge_db.test",
    27. 

  27.                            [{create_if_missing, true},
    28. 

  28.                             {merge_operator, erlang_merge_operator}]),
    29. 

  29. 

  30.   ok = rocksdb:put(Db, <<"i">>, term_to_binary(0), []),
    31. 

  31.   {ok, IBin0} = rocksdb:get(Db, <<"i">>, []),
    32. 

  32.   0 = binary_to_term(IBin0),
    33. 

  33. 

  34.   ok = rocksdb:merge(Db, <<"i">>, term_to_binary({int_add, 1}), []),
    35. 

  35.   {ok, IBin1} = rocksdb:get(Db, <<"i">>, []),
    36. 

  36.   1 = binary_to_term(IBin1),
    37. 

  37. 

  38.   ok = rocksdb:merge(Db, <<"i">>, term_to_binary({int_add, 2}), []),
    39. 

  39.   {ok, IBin2} = rocksdb:get(Db, <<"i">>, []),
    40. 

  40.   3 = binary_to_term(IBin2),
    41. 

  41. 

  42.   ok = rocksdb:merge(Db, <<"i">>, term_to_binary({int_add, -1}), []),
    43. 

  43.   {ok, IBin3} = rocksdb:get(Db, <<"i">>, []),
    44. 

  44.   2 = binary_to_term(IBin3),
    45. 

  45. 

  46.   ok = rocksdb:put(Db, <<"i">>, term_to_binary(0), []),
    47. 

  47.   {ok, IBin4} = rocksdb:get(Db, <<"i">>, []),
    48. 

  48.   0 = binary_to_term(IBin4),
    49. 

  49. 

  50. 

  51.   ok = rocksdb:close(Db),
    52. 

  52.   ok = destroy_and_rm("rocksdb_merge_db.test", []).
    53. 

  53. 

  54. merge_list_append_test() ->
    55. 

  55.   rocksdb_test_util:rm_rf("rocksdb_merge_db.test"),
    56. 

  56.   {ok, Db} = rocksdb:open("rocksdb_merge_db.test",
    57. 

  57.                            [{create_if_missing, true},
    58. 

  58.                             {merge_operator, erlang_merge_operator}]),
    59. 

  59. 

  60.   ok = rocksdb:put(Db, <<"list">>, term_to_binary([a, b]), []),
    61. 

  61.   {ok, Bin0} = rocksdb:get(Db, <<"list">>, []),
    62. 

  62.   [a, b] = binary_to_term(Bin0),
    63. 

  63. 

  64.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_append, [c, d]}), []),
    65. 

  65.   {ok, Bin1} = rocksdb:get(Db, <<"list">>, []),
    66. 

  66.   [a, b, c, d] = binary_to_term(Bin1),
    67. 

  67. 

  68.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_append, [d, e]}), []),
    69. 

  69.   {ok, Bin2} = rocksdb:get(Db, <<"list">>, []),
    70. 

  70.   [a, b, c, d, d, e] = binary_to_term(Bin2),
    71. 

  71. 

  72.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_append, []}), []),
    73. 

  73.   {ok, Bin2} = rocksdb:get(Db, <<"list">>, []),
    74. 

  74. 

  75.   ok = rocksdb:close(Db),
    76. 

  76.   ok = destroy_and_rm("rocksdb_merge_db.test", []).
    77. 

  77. 

  78. merge_list_substract_test() ->
    79. 

  79.   rocksdb_test_util:rm_rf("rocksdb_merge_db.test"),
    80. 

  80.   {ok, Db} = rocksdb:open("rocksdb_merge_db.test",
    81. 

  81.                            [{create_if_missing, true},
    82. 

  82.                             {merge_operator, erlang_merge_operator}]),
    83. 

  83. 

  84.   ok = rocksdb:put(Db, <<"list">>, term_to_binary([a, b, c, d, e, a, b, c]), []),
    85. 

  85.   {ok, Bin0} = rocksdb:get(Db, <<"list">>, []),
    86. 

  86.   [a, b, c, d, e, a, b, c] = binary_to_term(Bin0),
    87. 

  87. 

  88.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_substract, [c, a]}), []),
    89. 

  89.   {ok, Bin1} = rocksdb:get(Db, <<"list">>, []),
    90. 

  90.   [b, d, e, a, b, c] = binary_to_term(Bin1),
    91. 

  91. 

  92.   ok = rocksdb:close(Db),
    93. 

  93.   ok = destroy_and_rm("rocksdb_merge_db.test", []).
    94. 

  94. 

  95. merge_list_set_test() ->
    96. 

  96.   rocksdb_test_util:rm_rf("rocksdb_merge_db.test"),
    97. 

  97.   {ok, Db} = rocksdb:open("rocksdb_merge_db.test",
    98. 

  98.                            [{create_if_missing, true},
    99. 

  99.                             {merge_operator, erlang_merge_operator}]),
    100. 

  100. 

  101.   ok = rocksdb:put(Db, <<"list">>, term_to_binary([a, b, c, d, e]), []),
    102. 

  102.   {ok, Bin0} = rocksdb:get(Db, <<"list">>, []),
    103. 

  103.   [a, b, c, d, e] = binary_to_term(Bin0),
    104. 

  104. 

  105.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_set, 2, 'c1'}), []),
    106. 

  106.   {ok, Bin1} = rocksdb:get(Db, <<"list">>, []),
    107. 

  107.   [a, b, 'c1', d, e] = binary_to_term(Bin1),
    108. 

  108. 

  109.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_set, 4, 'e1'}), []),
    110. 

  110.   {ok, Bin2} = rocksdb:get(Db, <<"list">>, []),
    111. 

  111.   [a, b, 'c1', d, 'e1'] = binary_to_term(Bin2),
    112. 

  112. 

  113.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_set, 5, error}), []),
    114. 

  114.   {ok, Bin2}  = rocksdb:get(Db, <<"list">>, []),
    115. 

  115. 

  116.   ok = rocksdb:close(Db),
    117. 

  117.   ok = destroy_and_rm("rocksdb_merge_db.test", []).
    118. 

  118. 

  119. merge_list_delete_test() ->
    120. 

  120.   rocksdb_test_util:rm_rf("rocksdb_merge_db.test"),
    121. 

  121.   {ok, Db} = rocksdb:open("rocksdb_merge_db.test",
    122. 

  122.                            [{create_if_missing, true},
    123. 

  123.                             {merge_operator, erlang_merge_operator}]),
    124. 

  124. 

  125.   ok = rocksdb:put(Db, <<"list">>, term_to_binary([a, b, c, d, e, f, g]), []),
    126. 

  126.   {ok, Bin0} = rocksdb:get(Db, <<"list">>, []),
    127. 

  127.   [a, b, c, d, e, f, g] = binary_to_term(Bin0),
    128. 

  128. 

  129.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_delete, 2}), []),
    130. 

  130.   {ok, Bin1} = rocksdb:get(Db, <<"list">>, []),
    131. 

  131.   [a, b, d, e, f, g] = binary_to_term(Bin1),
    132. 

  132. 

  133.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_delete, 2, 4}), []),
    134. 

  134.   {ok, Bin2} = rocksdb:get(Db, <<"list">>, []),
    135. 

  135.   [a, b, g] = binary_to_term(Bin2),
    136. 

  136. 

  137.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_delete, 3}), []),
    138. 

  138.   {ok, Bin2}  = rocksdb:get(Db, <<"list">>, []),
    139. 

  139. 

  140.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_delete, 6}), []),
    141. 

  141.   {ok, Bin2}  = rocksdb:get(Db, <<"list">>, []),
    142. 

  142. 

  143.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_delete, 2}), []),
    144. 

  144.   {ok, Bin3} = rocksdb:get(Db, <<"list">>, []),
    145. 

  145.   [a, b] = binary_to_term(Bin3),
    146. 

  146.   ok = rocksdb:close(Db),
    147. 

  147.   ok = destroy_and_rm("rocksdb_merge_db.test", []).
    148. 

  148. 

  149. merge_list_insert_test() ->
    150. 

  150.   rocksdb_test_util:rm_rf("rocksdb_merge_db.test"),
    151. 

  151.   {ok, Db} = rocksdb:open("rocksdb_merge_db.test",
    152. 

  152.                            [{create_if_missing, true},
    153. 

  153.                             {merge_operator, erlang_merge_operator}]),
    154. 

  154. 

  155.   ok = rocksdb:put(Db, <<"list">>, term_to_binary([a, b, c, d, e, f, g]), []),
    156. 

  156.   {ok, Bin0} = rocksdb:get(Db, <<"list">>, []),
    157. 

  157.   [a, b, c, d, e, f, g] = binary_to_term(Bin0),
    158. 

  158. 

  159.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_insert, 2, [h, i]}), []),
    160. 

  160.   {ok, Bin1} = rocksdb:get(Db, <<"list">>, []),
    161. 

  161.   [a, b, h, i, c, d, e, f, g] = binary_to_term(Bin1),
    162. 

  162. 

  163.   ok = rocksdb:merge(Db, <<"list">>, term_to_binary({list_insert, 9, [j]}), []),
    164. 

  164.   {ok, Bin1} = rocksdb:get(Db, <<"list">>, []),
    165. 

  165. 

  166.   ok = rocksdb:close(Db),
    167. 

  167.   ok = destroy_and_rm("rocksdb_merge_db.test", []).
    168. 

  168. 

  169. merge_binary_append_test() ->
    170. 

  170.   rocksdb_test_util:rm_rf("rocksdb_merge_db.test"),
    171. 

  171.   {ok, Db} = rocksdb:open("rocksdb_merge_db.test",
    172. 

  172.                            [{create_if_missing, true},
    173. 

  173.                             {merge_operator, erlang_merge_operator}]),
    174. 

  174. 

  175.     ok = rocksdb:put(Db, <<"encbin">>, term_to_binary(<<"test">>), []),
    176. 

  176.   {ok, Bin} = rocksdb:get(Db, <<"encbin">>, []),
    177. 

  177.   <<"test">> = binary_to_term(Bin),
    178. 

  178. 

  179.   ok = rocksdb:merge(Db, <<"encbin">>, term_to_binary({binary_append, <<"abc">>}), []),
    180. 

  180.   {ok, Bin1} = rocksdb:get(Db, <<"encbin">>, []),
    181. 

  181.   <<"testabc">> = binary_to_term(Bin1),
    182. 

  182. 

  183.   ok = rocksdb:merge(Db, <<"encbin">>, term_to_binary({binary_append, <<"de">>}), []),
    184. 

  184.   {ok, Bin2} = rocksdb:get(Db, <<"encbin">>, []),
    185. 

  185.   <<"testabcde">> = binary_to_term(Bin2),
    186. 

  186. 

  187.   ok = rocksdb:merge(Db, <<"empty">>, term_to_binary({binary_append, <<"abc">>}), []),
    188. 

  188.   {ok, Bin3} = rocksdb:get(Db, <<"empty">>, []),
    189. 

  189.   <<"abc">> = binary_to_term(Bin3),
    190. 

  190. 

  191.   ok = rocksdb:close(Db),
    192. 

  192.   ok = destroy_and_rm("rocksdb_merge_db.test", []).
    193. 

  193. 

  194. merge_binary_replace_test() ->
    195. 

  195.   rocksdb_test_util:rm_rf("rocksdb_merge_db.test"),
    196. 

  196.   {ok, Db} = rocksdb:open("rocksdb_merge_db.test",
    197. 

  197.                            [{create_if_missing, true},
    198. 

  198.                             {merge_operator, erlang_merge_operator}]),
    199. 

  199. 

  200.   ok = rocksdb:put(Db, <<"encbin">>, term_to_binary(<<"The quick brown fox jumps over the lazy dog.">>), []),
    201. 

  201.   {ok, Bin} = rocksdb:get(Db, <<"encbin">>, []),
    202. 

  202.   <<"The quick brown fox jumps over the lazy dog.">> = binary_to_term(Bin),
    203. 

  203. 

  204.   ok = rocksdb:merge(Db, <<"encbin">>, term_to_binary({binary_replace, 10, 5, <<"red">>}), []),
    205. 

  205.   ok = rocksdb:merge(Db, <<"encbin">>, term_to_binary({binary_replace, 0, 3, <<"A">>}), []),
    206. 

  206.   {ok, Bin1} = rocksdb:get(Db, <<"encbin">>, []),
    207. 

  207.   <<"A quick red fox jumps over the lazy dog.">> = binary_to_term(Bin1),
    208. 

  208. 

  209.   ok = rocksdb:put(Db, <<"bitmap">>, term_to_binary(<<1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1>>), []),
    210. 

  210.   ok = rocksdb:merge(Db, <<"bitmap">>, term_to_binary({binary_replace, 2, 1, <<0>>}), []),
    211. 

  211.   {ok, Bin2} = rocksdb:get(Db, <<"bitmap">>, []),
    212. 

  212.   <<1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1>> = binary_to_term(Bin2),
    213. 

  213. 

  214.   ok = rocksdb:merge(Db, <<"bitmap">>, term_to_binary({binary_replace, 6, 1, <<0>>}), []),
    215. 

  215.   {ok, Bin3} = rocksdb:get(Db, <<"bitmap">>, []),
    216. 

  216.   <<1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1>> = binary_to_term(Bin3),
    217. 

  217. 

  218.   ok = rocksdb:put(Db, <<"encbin1">>, term_to_binary(<<"abcdef">>), []),
    219. 

  219.   ok = rocksdb:merge(Db, <<"encbin1">>, term_to_binary({binary_replace, 6, 1, <<"A">>}), []),
    220. 

  220.   {ok, Bin4} = rocksdb:get(Db, <<"encbin1">>, []),
    221. 

  221.   <<"abcdef">> = binary_to_term(Bin4),
    222. 

  222. 

  223.   ok = rocksdb:close(Db),
    224. 

  224.   ok = destroy_and_rm("rocksdb_merge_db.test", []).
    225. 

  225. 

  226. merge_binary_erase_test() ->
    227. 

  227.   rocksdb_test_util:rm_rf("rocksdb_merge_db.test"),
    228. 

  228.   {ok, Db} = rocksdb:open("rocksdb_merge_db.test",
    229. 

  229.                            [{create_if_missing, true},
    230. 

  230.                             {merge_operator, erlang_merge_operator}]),
    231. 

  231. 

  232. 

  233.   ok = rocksdb:put(Db, <<"eraseterm">>, term_to_binary(<<"abcdefghij">>), []),
    234. 

  234.   ok = rocksdb:merge(Db, <<"eraseterm">>, term_to_binary({binary_erase, 2, 4}), []),
    235. 

  235.   {ok, Bin} = rocksdb:get(Db, <<"eraseterm">>, []),
    236. 

  236.   <<"abghij">> = binary_to_term(Bin),
    237. 

  237. 

  238.   ok = rocksdb:put(Db, <<"erase_end">>, term_to_binary(<<"abcdefghij">>), []),
    239. 

  239.   ok = rocksdb:merge(Db, <<"erase_end">>, term_to_binary({binary_erase, 9, 2}), []),
    240. 

  240.   {ok, Bin1} = rocksdb:get(Db, <<"erase_end">>, []),
    241. 

  241.   <<"abcdefghi">> = binary_to_term(Bin1),
    242. 

  242. 

  243.   ok = rocksdb:put(Db, <<"erase_to_end1">>, term_to_binary(<<"abcdefghij">>), []),
    244. 

  244.   ok = rocksdb:merge(Db, <<"erase_to_end1">>, term_to_binary({binary_erase, 2, 9}), []),
    245. 

  245.   {ok, Bin2} = rocksdb:get(Db, <<"erase_to_end1">>, []),
    246. 

  246.   <<"ab">> = binary_to_term(Bin2),
    247. 

  247. 

  248.   ok = rocksdb:put(Db, <<"erase_to_end2">>, term_to_binary(<<"abcdefghij">>), []),
    249. 

  249.   ok = rocksdb:merge(Db, <<"erase_to_end2">>, term_to_binary({binary_erase, 2, 8}), []),
    250. 

  250.   {ok, Bin3} = rocksdb:get(Db, <<"erase_to_end2">>, []),
    251. 

  251.   <<"ab">> = binary_to_term(Bin3),
    252. 

  252. 

  253.   ok = rocksdb:close(Db),
    254. 

  254.   ok = destroy_and_rm("rocksdb_merge_db.test", []).
    255. 

  255. 

  256. merge_binary_insert_test() ->
    257. 

  257.   rocksdb_test_util:rm_rf("rocksdb_merge_db.test"),
    258. 

  258.   {ok, Db} = rocksdb:open("rocksdb_merge_db.test",
    259. 

  259.                            [{create_if_missing, true},
    260. 

  260.                             {merge_operator, erlang_merge_operator}]),
    261. 

  261. 

  262.   ok = rocksdb:put(Db, <<"insertterm">>, term_to_binary(<<"abcdefghij">>), []),
    263. 

  263.   ok = rocksdb:merge(Db, <<"insertterm">>, term_to_binary({binary_insert, 2, <<"1234">>}), []),
    264. 

  264.   {ok, Bin} = rocksdb:get(Db, <<"insertterm">>, []),
    265. 

  265.   <<"ab1234cdefghij">> = binary_to_term(Bin),
    266. 

  266. 

  267.   ok = rocksdb:put(Db, <<"insert">>, term_to_binary(<<"abcdefghij">>), []),
    268. 

  268.   ok = rocksdb:merge(Db, <<"insert">>, term_to_binary({binary_insert, 9, <<"1234">>}), []),
    269. 

  269.   {ok, Bin1} = rocksdb:get(Db, <<"insert">>, []),
    270. 

  270.   <<"abcdefghi1234j">> = binary_to_term(Bin1),
    271. 

  271. 

  272.   ok = rocksdb:put(Db, <<"insert">>, term_to_binary(<<"abcdefghij">>), []),
    273. 

  273.   ok = rocksdb:merge(Db, <<"insert">>, term_to_binary({binary_insert, 10, <<"1234">>}), []),
    274. 

  274.   {ok, Bin2} = rocksdb:get(Db, <<"insert">>, []),
    275. 

  275.   <<"abcdefghij1234">> = binary_to_term(Bin2),
    276. 

  276. 

  277.   ok = rocksdb:put(Db, <<"insert">>, term_to_binary(<<"abcdefghij">>), []),
    278. 

  278.   ok = rocksdb:merge(Db, <<"insert">>, term_to_binary({binary_insert, 11, <<"1234">>}), []),
    279. 

  279.   {ok, Bin3} = rocksdb:get(Db, <<"insert">>, []),
    280. 

  280.   <<"abcdefghij">> = binary_to_term(Bin3),
    281. 

  281. 

  282. 

  283.   ok = rocksdb:close(Db),
    284. 

  284.   ok = destroy_and_rm("rocksdb_merge_db.test", []).
    285. 

  285. 

  286. 

  287. merge_bitset_test() ->
    288. 

  288.  rocksdb_test_util:rm_rf("rocksdb_merge_db.test"),
    289. 

  289.   {ok, Db} = rocksdb:open("rocksdb_merge_db.test",
    290. 

  290.                            [{create_if_missing, true},
    291. 

  291.                             {merge_operator, {bitset_merge_operator, 1024}}]),
    292. 

  292. 

  293.   Bitmap = << 0:1024/unsigned >>,
    294. 

  294.   ok = rocksdb:put(Db, <<"bitmap">>, Bitmap, []),
    295. 

  295.   ok = rocksdb:merge(Db, <<"bitmap">>, <<"+2">>, []),
    296. 

  296.   {ok, << 32, _/binary>> = Bin1 } = rocksdb:get(Db, <<"bitmap">>, []),
    297. 

  297.   1024 = bit_size(Bin1),
    298. 

  298.   ok = rocksdb:merge(Db, <<"bitmap">>, <<"-2">>, []),
    299. 

  299.   {ok, << 0, _/binary>> } = rocksdb:get(Db, <<"bitmap">>, []),
    300. 

  300.   ok = rocksdb:merge(Db, <<"bitmap">>, <<"+11">>, []),
    301. 

  301.   {ok, << 0, 16, _/binary>> } = rocksdb:get(Db, <<"bitmap">>, []),
    302. 

  302.   ok = rocksdb:merge(Db, <<"bitmap">>, <<"+10">>, []),
    303. 

  303.   {ok, << 0, 48, _/binary>> } = rocksdb:get(Db, <<"bitmap">>, []),
    304. 

  304.   ok = rocksdb:merge(Db, <<"bitmap">>, <<"">>, []),
    305. 

  305.   {ok, << 0, 0, _/binary>> = Bin2 } = rocksdb:get(Db, <<"bitmap">>, []),
    306. 

  306.   1024 = bit_size(Bin2),
    307. 

  307. 

  308.   ok = rocksdb:merge(Db, <<"unsetbitmap">>, <<"+2">>, []),
    309. 

  309.   {ok, << 32, _/binary>> } = rocksdb:get(Db, <<"unsetbitmap">>, []),
    310. 

  310.   ok = rocksdb:merge(Db, <<"unsetbitmap">>, <<"-2">>, []),
    311. 

  311.   {ok, << 0, _/binary>> } = rocksdb:get(Db, <<"unsetbitmap">>, []),
    312. 

  312.   ok = rocksdb:merge(Db, <<"unsetbitmap">>, <<"+11">>, []),
    313. 

  313.   {ok, << 0, 16, _/binary>> } = rocksdb:get(Db, <<"unsetbitmap">>, []),
    314. 

  314.   ok = rocksdb:merge(Db, <<"unsetbitmap">>, <<"+10">>, []),
    315. 

  315.   {ok, << 0, 48, _/binary>> } = rocksdb:get(Db, <<"unsetbitmap">>, []),
    316. 

  316. 

  317.   ok = rocksdb:close(Db),
    318. 

  318.   ok = destroy_and_rm("rocksdb_merge_db.test", []).
    319. 

  319. 

  320. 

  321. merge_counter_test() ->
    322. 

  322.   rocksdb_test_util:rm_rf("rocksdb_counter_merge_db.test"),
    323. 

  323.   {ok, Db} = rocksdb:open("rocksdb_counter_merge_db.test",
    324. 

  324.                            [{create_if_missing, true},
    325. 

  325.                             {merge_operator, counter_merge_operator}]),
    326. 

  326. 

  327. 

  328.   ok = rocksdb:merge(Db, <<"c">>, << "1" >>, []),
    329. 

  329.   {ok, << "1" >>} = rocksdb:get(Db, <<"c">>, []),
    330. 

  330. 

  331.   ok = rocksdb:merge(Db, <<"c">>, << "2" >>, []),
    332. 

  332.   {ok, << "3" >>} = rocksdb:get(Db, <<"c">>, []),
    333. 

  333. 

  334.   ok = rocksdb:merge(Db, <<"c">>, <<"-1">> , []),
    335. 

  335.   {ok, <<"2">>} = rocksdb:get(Db, <<"c">>, []),
    336. 

  336. 

  337.   ok = rocksdb:put(Db, <<"c">>, <<"0">>, []),
    338. 

  338.   {ok, <<"0">>} = rocksdb:get(Db, <<"c">>, []),
    339. 

  339. 

  340.   ok = rocksdb:close(Db),
    341. 

  341.   ok = destroy_and_rm("rocksdb_counter_merge_db.test", []).
    342. 

  342. 

  343. 

  344. destroy_and_rm(Dir, Options) ->
    345. 

  345.   rocksdb:destroy(Dir, Options),
    346. 

  346.   rocksdb_test_util:rm_rf(Dir).
    347.