ets: rename internal lookup function

Signed-off-by: Jakub Gonet <jakub.gonet@swmansion.com>

Author: jgonet

src/libAtomVM/ets.c

@@ -247,22 +247,36 @@ static void ets_delete_all_tables(struct Ets *ets, GlobalContext *global)
     ets_delete_tables_internal(ets, true_pred, NULL, global);
 }
 
+static inline bool has_key_at(term tuple, size_t key_index)
+{
+    return key_index < (size_t) term_get_tuple_arity(tuple);
+}
+
 static EtsErrorCode insert(struct EtsTable *ets_table, term tuple, Context *ctx)
 {
     assert(term_is_tuple(tuple));
     size_t key_index = ets_table->key_index;
-    if ((size_t) term_get_tuple_arity(tuple) <= key_index) {
+    if (UNLIKELY(!has_key_at(tuple, key_index))) {
         return EtsBadEntry;
     }
 
-    struct HNode *new_node = ets_hashtable_new_node(tuple, key_index);
-    if (IS_NULL_PTR(new_node)) {
+    bool is_duplicate_bag = ets_table->table_type == EtsTableDuplicateBag;
+    struct HNode *node = NULL;
+    if (is_duplicate_bag) {
+        term key = term_get_tuple_element(tuple, key_index);
+        term old_tuples = ets_hashtable_lookup(ets_table->hashtable, key, key_index, ctx->global);
+        bool is_new = term_is_nil(old_tuples);
+        node = ets_hashtable_new_node_from_list(is_new ? term_nil() : old_tuples, tuple, key_index);
+    } else {
+        node = ets_hashtable_new_node(tuple, key_index);
+    }
+    if (IS_NULL_PTR(node)) {
         return EtsAllocationFailure;
     }
 
-    EtsHashtableStatus res = ets_hashtable_insert(ets_table->hashtable, new_node, EtsHashtableAllowOverwrite, ctx->global);
+    EtsHashtableStatus res = ets_hashtable_insert(ets_table->hashtable, node, EtsHashtableAllowOverwrite, ctx->global);
     if (UNLIKELY(res != EtsHashtableOk)) {
-        ets_hashtable_free_node(new_node, ctx->global);
+        ets_hashtable_free_node(node, ctx->global);
         return EtsAllocationFailure;
     }
 
@@ -336,7 +350,7 @@ EtsErrorCode ets_insert(term name_or_ref, term entry, Context *ctx)
     return result;
 }
 
-static EtsErrorCode ets_table_lookup_maybe_gc(struct EtsTable *ets_table, term key, term *ret, Context *ctx, int num_roots, term *roots)
+static EtsErrorCode lookup_maybe_gc(struct EtsTable *ets_table, term key, term *ret, Context *ctx, int num_roots, term *roots)
 {
     term res = ets_hashtable_lookup(ets_table->hashtable, key, ets_table->key_index, ctx->global);
 
@@ -363,7 +377,7 @@ EtsErrorCode ets_lookup_maybe_gc(term name_or_ref, term key, term *ret, Context
         return EtsBadAccess;
     }
 
-    EtsErrorCode result = ets_table_lookup_maybe_gc(ets_table, key, ret, ctx, 0, NULL);
+    EtsErrorCode result = lookup_maybe_gc(ets_table, key, ret, ctx, 0, NULL);
     SMP_UNLOCK(ets_table);
 
     return result;
@@ -490,7 +504,7 @@ EtsErrorCode ets_update_counter_maybe_gc(term ref, term key, term operation, ter
     term roots[] = { key, operation, safe_default_value };
 
     term list;
-    EtsErrorCode result = ets_table_lookup_maybe_gc(ets_table, key, &list, ctx, 3, roots);
+    EtsErrorCode result = lookup_maybe_gc(ets_table, key, &list, ctx, 3, roots);
     if (UNLIKELY(result != EtsOk)) {
         SMP_UNLOCK(ets_table);
         return result;

src/libAtomVM/ets_hashtable.c

@@ -20,6 +20,7 @@
 
 #include "ets_hashtable.h"
 
+#include "memory.h"
 #include "smp.h"
 #include "term.h"
 #include "utils.h"
@@ -89,6 +90,8 @@ static void print_info(struct EtsHashTable *hash_table)
 
 struct HNode *ets_hashtable_new_node(term tuple, int key_index)
 {
+    assert(term_is_tuple(tuple));
+    assert(term_get_tuple_arity(tuple) >= key_index);
     struct HNode *new_node = malloc(sizeof(struct HNode));
     if (IS_NULL_PTR(new_node)) {
         goto cleanup;
@@ -100,8 +103,6 @@ struct HNode *ets_hashtable_new_node(term tuple, int key_index)
     }
 
     term new_entry = memory_copy_term_tree(&new_node->heap, tuple);
-    assert(term_is_tuple(new_entry));
-    assert(term_get_tuple_arity(new_entry) >= key_index);
     term key = term_get_tuple_element(new_entry, key_index);
 
     new_node->next = NULL;
@@ -115,6 +116,39 @@ struct HNode *ets_hashtable_new_node(term tuple, int key_index)
     return NULL;
 }
 
+// TODO: create list elsewhere, by copying terms from orig heap, appending new copied tuple and using ets_hashtable_new_node
+struct HNode *ets_hashtable_new_node_from_list(term old_tuples, term tuple, size_t key_index)
+{
+    assert(term_is_tuple(tuple));
+    assert((size_t) term_get_tuple_arity(tuple) >= key_index);
+    assert(term_is_list(old_tuples));
+
+    struct HNode *new_node = malloc(sizeof(struct HNode));
+    if (IS_NULL_PTR(new_node)) {
+        goto oom;
+    }
+
+    size_t old_list_size = memory_estimate_usage(old_tuples);
+    size_t new_tuple_size = memory_estimate_usage(tuple);
+    if (UNLIKELY(memory_init_heap(&new_node->heap, old_list_size + new_tuple_size + CONS_SIZE) != MEMORY_GC_OK)) {
+        goto oom;
+    }
+    term ets_list = memory_copy_term_tree(&new_node->heap, old_tuples);
+    term ets_tuple = memory_copy_term_tree(&new_node->heap, tuple);
+
+    term new_key = term_get_tuple_element(ets_tuple, key_index);
+    ets_list = term_list_prepend(ets_tuple, ets_list, &new_node->heap);
+
+    new_node->next = NULL;
+    new_node->key = new_key;
+    new_node->entry = ets_list;
+    return new_node;
+
+oom:
+    free(new_node);
+    return NULL;
+}
+
 EtsHashtableStatus ets_hashtable_insert(struct EtsHashTable *hash_table, struct HNode *new_node, EtsHashtableOptions opts, GlobalContext *global)
 {
     term key = new_node->key;

src/libAtomVM/ets_hashtable.h

@@ -53,6 +53,7 @@ struct EtsHashTable *ets_hashtable_new();
 void ets_hashtable_destroy(struct EtsHashTable *hash_table, GlobalContext *global);
 
 struct HNode *ets_hashtable_new_node(term entry, int key_index);
+struct HNode *ets_hashtable_new_node_from_list(term old_tuples_or_tuple, term new_tuple, size_t key_index);
 void ets_hashtable_free_node(struct HNode *node, GlobalContext *global);
 
 EtsHashtableStatus ets_hashtable_insert(struct EtsHashTable *hash_table, struct HNode *new_node, EtsHashtableOptions opts, GlobalContext *global);

tests/erlang_tests/test_ets.erl

@@ -31,6 +31,7 @@ start() ->
     ok = isolated(fun test_delete/0),
     ok = isolated(fun test_lookup_element/0),
     ok = isolated(fun test_update_counter/0),
+    ok = isolated(fun test_duplicate_bag/0),
     0.
 
 test_ets_new() ->
@@ -260,6 +261,49 @@ test_update_counter() ->
     assert_badarg(fun() -> ets:update_counter(TErr, key, {2, 10, 100, not_number}) end),
     ok.
 
+test_duplicate_bag() ->
+    Tid = ets:new(test_duplicate_bag, [duplicate_bag, {keypos, 2}]),
+    T = {ok, foo, 100, extra},
+    T2 = {error, foo, 200},
+    T3 = {error, foo, 300},
+
+    % true = ets:insert_new(Tid, T),
+    % false = ets:insert_new(Tid, T),
+    true = ets:insert(Tid, T),
+    true = ets:insert(Tid, [T, T]),
+    true = ets:insert(Tid, [T2]),
+    % true = [T, T, T, T2] == ets:lookup(Tid, foo),
+    % true = [T, T, T, T, T2] == ets:lookup(Tid, foo),
+    % true = ets:member(Tid, foo),
+
+    % % nothing inserted, T exists in table
+    % false = ets:insert_new(Tid, [T, {ok, bar, batat}]),
+    % false = ets:member(Tid, bar),
+
+    % [ok, ok, ok, ok, error] = ets:lookup_element(Tid, foo, 1),
+    % [foo, foo, foo, foo, foo] = ets:lookup_element(Tid, foo, 2),
+    % [100, 100, 100, 100, 200] = ets:lookup_element(Tid, foo, 3),
+    % % some tuples don't have 4 arity
+    % ok = expect_failure(fun() -> ets:lookup_element(Tid, foo, 4) end),
+
+    % % unsupported for duplicate bag
+    % ok = expect_failure(fun() -> ets:update_counter(Tid, foo, 10) end),
+    % ok = expect_failure(fun() -> ets:update_element(Tid, foo, {1, error}) end),
+
+    % true = ets:delete_object(Tid, {bad, bad}),
+    % true = [T, T, T, T, T2] == ets:lookup(Tid, foo),
+    % true = ets:delete_object(Tid, T),
+    % true = [T2] == ets:lookup(Tid, foo),
+
+    % true = ets:insert(Tid, T3),
+    % % keeps insertion order
+    % true = [T2, T3] == ets:take(Tid, foo),
+
+    % true = ets:delete(Tid),
+    % ok = expect_failure(fun() -> ets:insert(Tid, T) end),
+
+    ok.
+
 %%-----------------------------------------------------------------------------
 %% @doc Performs specified operation on ETS table implicitly asserting that no exception is raised.
 %%      [badarg] can be passed as an option to assert that exception was raised.