bpp_tree_handler.c File Reference

#include "bpp_tree_handler.h"

Description

The handler for a disk-backed B+ Tree.

Author

Graeme Douglas

Copyright

Copyright 2017 The University of British Columbia, IonDB Project Contributors (see AUTHORS.md)

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

1.Redistributions of source code must retain the above copyright notice,

this list of conditions and the following disclaimer.

2.Redistributions in binary form must reproduce the above copyright notice,

this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

3.Neither the name of the copyright holder nor the names of its contributors

may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Definition in file bpp_tree_handler.c.

Include dependency graph for bpp_tree_handler.c:

Functions
void	bpptree_get_filename (ion_dictionary_id_t id, char *str)
ion_err_t	bpptree_create_dictionary (ion_dictionary_id_t id, ion_key_type_t key_type, ion_key_size_t key_size, ion_value_size_t value_size, ion_dictionary_size_t dictionary_size, ion_dictionary_compare_t compare, ion_dictionary_handler_t *handler, ion_dictionary_t *dictionary)
	Creates an instance of a dictionary. More...
ion_status_t	bpptree_insert (ion_dictionary_t *dictionary, ion_key_t key, ion_value_t value)
	Inserts a key and value into the dictionary. More...
ion_status_t	bpptree_get (ion_dictionary_t *dictionary, ion_key_t key, ion_value_t value)
	Queries a dictionary instance for the given key and returns the associated value. More...
ion_status_t	bpptree_delete (ion_dictionary_t *dictionary, ion_key_t key)
	Deletes the key and associated value from the dictionary instance. More...
ion_err_t	bpptree_close_dictionary (ion_dictionary_t *dictionary)
	Closes a BppTree instance of a dictionary. More...
ion_err_t	bpptree_delete_dictionary (ion_dictionary_t *dictionary)
	Deletes an instance of the dictionary and associated data. More...
ion_err_t	bpptree_destroy_dictionary (ion_dictionary_id_t id)
	Deletes a closed instance of the dictionary and associated data. More...
ion_status_t	bpptree_update (ion_dictionary_t *dictionary, ion_key_t key, ion_value_t value)
	Updates the value for a given key. More...
ion_cursor_status_t	bpptree_next (ion_dict_cursor_t *cursor, ion_record_t *record)
	Next function to query and retrieve the next <K,V> that stratifies the predicate of the cursor. More...
void	bpptree_destroy_cursor (ion_dict_cursor_t **cursor)
	Destroys the cursor. More...
ion_err_t	bpptree_find (ion_dictionary_t *dictionary, ion_predicate_t *predicate, ion_dict_cursor_t **cursor)
	Finds multiple instances of a keys that satisfy the provided predicate in the dictionary. More...
ion_err_t	bpptree_open_dictionary (ion_dictionary_handler_t *handler, ion_dictionary_t *dictionary, ion_dictionary_config_info_t *config, ion_dictionary_compare_t compare)
	Opens a specific BppTree instance of a dictionary. More...
void	bpptree_init (ion_dictionary_handler_t *handler)
	Registers a specific handler for a dictionary instance. More...

Function Documentation

ion_err_t bpptree_close_dictionary

(

ion_dictionary_t *

dictionary

)

Closes a BppTree instance of a dictionary.

Parameters

dictionary

A pointer to the specific dictionary instance to be closed.

Returns

The status of closing the dictionary.

Definition at line 290 of file bpp_tree_handler.c.

  {
    ion_bpptree_t   *bpptree;
    ion_bpp_err_t   bErr;

    bpptree                 = (ion_bpptree_t *) dictionary->instance;
    bErr                    = b_close(bpptree->tree);
    ion_fclose(bpptree->values.file_handle);
    free(dictionary->instance);
    dictionary->instance    = NULL;

    if (bErrOk != bErr) {
        return err_dictionary_destruction_error;
    }

    return err_ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ion_err_t bpptree_create_dictionary	(	ion_dictionary_id_t	id,
		ion_key_type_t	key_type,
		ion_key_size_t	key_size,
		ion_value_size_t	value_size,
		ion_dictionary_size_t	dictionary_size,
		ion_dictionary_compare_t	compare,
		ion_dictionary_handler_t *	handler,
		ion_dictionary_t *	dictionary
	)

Creates an instance of a dictionary.

Creates as instance of a dictionary given a key_size and value_size, in bytes. The dictionary_size parameter is not used for this implementation, as there is no size bound.

Parameters

id	ID of a dictionary that's given to us.
key_type	The key category given to us.
key_size	The size of the key in bytes.
value_size	The size of the value in bytes.
dictionary_size	The size of the hashmap in discrete units
compare	Function pointer for the comparison function for the dictionary.
handler	THe handler for the specific dictionary being created.
dictionary	The pointer declared by the caller that will reference the instance of the dictionary created.

Returns

The status of the creation of the dictionary.

Definition at line 73 of file bpp_tree_handler.c.

  {
    UNUSED(dictionary_size);

/*  if (key_size != sizeof(int)) {
        return err_invalid_initial_size;
    }*/

    ion_bpptree_t   *bpptree;
    ion_bpp_open_t  info;

    bpptree = malloc(sizeof(ion_bpptree_t));

    if (NULL == bpptree) {
        return err_out_of_memory;
    }

    char value_filename[20];

    bpptree_get_filename(id, value_filename);
    bpptree->values.file_handle = ion_fopen(value_filename);

    bpptree->values.next_empty  = ION_FILE_NULL;

    char addr_filename[ION_MAX_FILENAME_LENGTH];

    int actual_filename_length = dictionary_get_filename(id, "bpt", addr_filename);

    if (actual_filename_length >= ION_MAX_FILENAME_LENGTH) {
        return err_uninitialized;
    }

    info.iName      = addr_filename;
    info.keySize    = key_size;
    info.dupKeys    = boolean_false;
    info.sectorSize = 256;
    info.comp       = compare;

    ion_bpp_err_t bErr = b_open(info, &(bpptree->tree));

    if (bErrOk != bErr) {
        return err_uninitialized;
    }

    if (NULL == handler) {
        return err_uninitialized;
    }

    dictionary->instance                    = (ion_dictionary_parent_t *) bpptree;
    dictionary->instance->compare           = compare;
    dictionary->instance->key_type          = key_type;
    dictionary->instance->record.key_size   = key_size;
    dictionary->instance->record.value_size = value_size;
    dictionary->instance->type              = dictionary_type_bpp_tree_t;
    dictionary->handler                     = handler;

    return err_ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ion_status_t bpptree_delete	(	ion_dictionary_t *	dictionary,
		ion_key_t	key
	)

Deletes the key and associated value from the dictionary instance.

Parameters

dictionary	The instance of the dictionary to delete from.
key	The key that is to be deleted.

Returns

The status of the deletion

Definition at line 256 of file bpp_tree_handler.c.

  {
    ion_bpptree_t       *bpptree;
    ion_bpp_err_t       bErr;
    ion_file_offset_t   offset;
    ion_status_t        status;

    status  = ION_STATUS_INITIALIZE;

    bpptree = (ion_bpptree_t *) dictionary->instance;

    bErr    = b_delete(bpptree->tree, key, &offset);

    if (bErrKeyNotFound != bErr) {
        status.error = lfb_delete_all(&(bpptree->values), offset, &(status.count));
    }
    else {
        status.error = err_item_not_found;
    }

    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ion_err_t bpptree_delete_dictionary

(

ion_dictionary_t *

dictionary

)

Deletes an instance of the dictionary and associated data.

Parameters

dictionary

The instance of the dictionary to delete.

Returns

The status of the dictionary deletion.

Definition at line 317 of file bpp_tree_handler.c.

  {
    ion_err_t error;

    char    addr_filename[ION_MAX_FILENAME_LENGTH];
    char    value_filename[ION_MAX_FILENAME_LENGTH];

    int actual_addr_filename_length     = dictionary_get_filename(dictionary->instance->id, "bpt", addr_filename);
    int actual_value_filename_length    = dictionary_get_filename(dictionary->instance->id, "val", value_filename);

    if ((actual_addr_filename_length >= ION_MAX_FILENAME_LENGTH) || (actual_value_filename_length >= ION_MAX_FILENAME_LENGTH)) {
        return err_dictionary_destruction_error;
    }

    error = bpptree_close_dictionary(dictionary);

    if (err_ok != error) {
        return error;
    }

    ion_fremove(addr_filename);
    ion_fremove(value_filename);

    return err_ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void bpptree_destroy_cursor

(

ion_dict_cursor_t **

cursor

)

Destroys the cursor.

Destroys the cursor when the user is finished with it. The destroy function will free up internally allocated memory as well as freeing up any reference to the cursor itself. Cursor pointers will be set to NULL as per ION_DB specification for de-allocated pointers.

Parameters

cursor

pointer to cursor.

Definition at line 516 of file bpp_tree_handler.c.

  {
    (*cursor)->predicate->destroy(&(*cursor)->predicate);
    free(((ion_bpp_cursor_t *) (*cursor))->cur_key);
    free((*cursor));
    *cursor = NULL;
}

Here is the caller graph for this function:

ion_err_t bpptree_destroy_dictionary

(

ion_dictionary_id_t

id

)

Deletes a closed instance of the dictionary and associated data.

Parameters

id	The identifier identifying the dictionary to delete.

Returns

The status of the dictionary deletion.

Definition at line 352 of file bpp_tree_handler.c.

  {
    char    addr_filename[ION_MAX_FILENAME_LENGTH];
    char    value_filename[ION_MAX_FILENAME_LENGTH];

    int actual_addr_filename_length     = dictionary_get_filename(id, "bpt", addr_filename);
    int actual_value_filename_length    = dictionary_get_filename(id, "val", value_filename);

    if ((actual_addr_filename_length >= ION_MAX_FILENAME_LENGTH) || (actual_value_filename_length >= ION_MAX_FILENAME_LENGTH)) {
        return err_dictionary_destruction_error;
    }

    ion_fremove(addr_filename);
    ion_fremove(value_filename);

    return err_ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ion_err_t bpptree_find	(	ion_dictionary_t *	dictionary,
		ion_predicate_t *	predicate,
		ion_dict_cursor_t **	cursor
	)

Finds multiple instances of a keys that satisfy the provided predicate in the dictionary.

Generates a cursor that allows the traversal of items where the items key satisfies the predicate (if the underlying implementation allows it).

Parameters

dictionary	The instance of the dictionary to search.
predicate	The predicate to be used as the condition for matching.
cursor	The pointer to a cursor which is caller declared but callee is responsible for populating.

Returns

The status of the operation.

Definition at line 544 of file bpp_tree_handler.c.

  {
    ion_bpptree_t   *bpptree    = (ion_bpptree_t *) dictionary->instance;
    ion_key_size_t  key_size    = dictionary->instance->record.key_size;

    *cursor = malloc(sizeof(ion_bpp_cursor_t));

    if (NULL == *cursor) {
        return err_out_of_memory;
    }

    ion_bpp_cursor_t *bCursor = (ion_bpp_cursor_t *) (*cursor);

    bCursor->cur_key = malloc(key_size);

    if (NULL == bCursor->cur_key) {
        free(bCursor);
        return err_out_of_memory;
    }

    (*cursor)->dictionary   = dictionary;
    (*cursor)->status       = cs_cursor_uninitialized;

    (*cursor)->destroy      = bpptree_destroy_cursor;
    (*cursor)->next         = bpptree_next;

    (*cursor)->predicate    = malloc(sizeof(ion_predicate_t));

    if (NULL == (*cursor)->predicate) {
        free(bCursor->cur_key);
        free(*cursor);
        return err_out_of_memory;
    }

    (*cursor)->predicate->type      = predicate->type;
    (*cursor)->predicate->destroy   = predicate->destroy;

    switch (predicate->type) {
        case predicate_equality: {
            ion_key_t target_key = predicate->statement.equality.equality_value;

            (*cursor)->predicate->statement.equality.equality_value = malloc(key_size);

            if (NULL == (*cursor)->predicate->statement.equality.equality_value) {
                free((*cursor)->predicate);
                free(bCursor->cur_key);
                free(*cursor);
                return err_out_of_memory;
            }

            memcpy((*cursor)->predicate->statement.equality.equality_value, target_key, key_size);

            memcpy(bCursor->cur_key, target_key, key_size);

            ion_bpp_err_t err = b_get(bpptree->tree, target_key, &bCursor->offset);

            if (bErrOk != err) {
                /* If this happens, that means the target key doesn't exist */
                (*cursor)->status = cs_end_of_results;
                return err_ok;
            }
            else {
                (*cursor)->status = cs_cursor_initialized;
                return err_ok;
            }

            break;
        }

        case predicate_range: {
            (*cursor)->predicate->statement.range.lower_bound = malloc(key_size);

            if (NULL == (*cursor)->predicate->statement.range.lower_bound) {
                free((*cursor)->predicate);
                free(bCursor->cur_key);
                free(*cursor);
                return err_out_of_memory;
            }

            memcpy((*cursor)->predicate->statement.range.lower_bound, predicate->statement.range.lower_bound, key_size);

            (*cursor)->predicate->statement.range.upper_bound = malloc(key_size);

            if (NULL == (*cursor)->predicate->statement.range.upper_bound) {
                free((*cursor)->predicate->statement.range.lower_bound);
                free((*cursor)->predicate);
                free(bCursor->cur_key);
                free(*cursor);
                return err_out_of_memory;
            }

            memcpy((*cursor)->predicate->statement.range.upper_bound, predicate->statement.range.upper_bound, key_size);

            /* We search for the FGEQ of the Lower bound. */
            b_find_first_greater_or_equal(bpptree->tree, (*cursor)->predicate->statement.range.lower_bound, bCursor->cur_key, &bCursor->offset);

            /* If the key returned doesn't satisfy the predicate, we can exit */
            if (boolean_false == test_predicate(*cursor, bCursor->cur_key)) {
                (*cursor)->status = cs_end_of_results;
                return err_ok;
            }
            else {
                (*cursor)->status = cs_cursor_initialized;
                return err_ok;
            }

            break;
        }

        case predicate_all_records: {
            ion_bpp_err_t err;

            /* We search for first key in B++ tree. */
            err                 = b_find_first_key(bpptree->tree, bCursor->cur_key, &bCursor->offset);

            (*cursor)->status   = cs_cursor_initialized;

            if (bErrOk != err) {
                (*cursor)->status = cs_end_of_results;
            }

            return err_ok;
            break;
        }

        case predicate_predicate: {
            break;
        }

        default: {
            return err_invalid_predicate;
            break;
        }
    }

    return err_ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ion_status_t bpptree_get	(	ion_dictionary_t *	dictionary,
		ion_key_t	key,
		ion_value_t	value
	)

Queries a dictionary instance for the given key and returns the associated value.

Queries a dictionary instance for the given key and returns the associated value. If the write_concern is set to wc_insert_unique then if the key exists already, an error will be generated as duplicate keys are prevented. If the write_concern is set to wc_update, the updates are allowed. In this case, if the key exists in the hashmap, the value will be updated. If the key does not exist, then a new item will be inserted to hashmap.

Parameters

dictionary	The instance of the dictionary to query.
key	The key to search for.
value	A pointer that is used to return the value associated with the provided key. The function will malloc memory for the value and it is up to the consumer the free the associated memory.

Returns

The status of the query.

Definition at line 217 of file bpp_tree_handler.c.

  {
    ion_bpptree_t       *bpptree;
    ion_file_offset_t   offset;
    ion_file_offset_t   next;
    ion_bpp_err_t       bErr;
    ion_err_t           err;

    bpptree = (ion_bpptree_t *) dictionary->instance;

    bErr    = b_get(bpptree->tree, key, &offset);

    if (bErrOk != bErr) {
        return ION_STATUS_ERROR(err_item_not_found);
    }

    err = lfb_get(&(bpptree->values), offset, bpptree->super.record.value_size, (ion_byte_t *) value, &next);

    if (err_ok == err) {
        return ION_STATUS_OK(1);
    }

    return ION_STATUS_ERROR(err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void bpptree_get_filename	(	ion_dictionary_id_t	id,
		char *	str
	)

Definition at line 40 of file bpp_tree_handler.c.

  {
    sprintf(str, "%d.val", id);
}

Here is the caller graph for this function:

void bpptree_init

(

ion_dictionary_handler_t *

handler

)

Registers a specific handler for a dictionary instance.

Registers functions for handlers. This only needs to be called once for each type of dictionary that is present.

Parameters

handler

The handler for the dictionary instance that is to be initialized.

Definition at line 711 of file bpp_tree_handler.c.

  {
    handler->insert             = bpptree_insert;
    handler->create_dictionary  = bpptree_create_dictionary;
    handler->get                = bpptree_get;
    handler->update             = bpptree_update;
    handler->find               = bpptree_find;
    handler->remove             = bpptree_delete;
    handler->delete_dictionary  = bpptree_delete_dictionary;
    handler->destroy_dictionary = bpptree_destroy_dictionary;
    handler->open_dictionary    = bpptree_open_dictionary;
    handler->close_dictionary   = bpptree_close_dictionary;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ion_status_t bpptree_insert	(	ion_dictionary_t *	dictionary,
		ion_key_t	key,
		ion_value_t	value
	)

Inserts a key and value into the dictionary.

Parameters

dictionary	The dictionary instance to insert the value into.
key	The key to use.
value	The value to use.

Returns

The status on the insertion of the record.

Definition at line 152 of file bpp_tree_handler.c.

  {
    ion_bpptree_t       *bpptree;
    ion_bpp_err_t       bErr;
    ion_err_t           err;
    ion_file_offset_t   offset;

    bpptree = (ion_bpptree_t *) dictionary->instance;

    offset  = ION_FILE_NULL;
    bErr    = b_get(bpptree->tree, key, &offset);

    if (bErrKeyNotFound == bErr) {
        offset = ION_FILE_NULL;
    }

    err = lfb_put(&(bpptree->values), (ion_byte_t *) value, bpptree->super.record.value_size, offset, &offset);

    if (err_ok == err) {
        if (bErrKeyNotFound == bErr) {
            bErr = b_insert(bpptree->tree, key, offset);
        }
        else {
            bErr = b_update(bpptree->tree, key, offset);
        }

        if (bErrOk != bErr) {
            return ION_STATUS_ERROR(err_unable_to_insert);
        }

        return ION_STATUS_OK(1);
    }
    else {
        return ION_STATUS_ERROR(err_unable_to_insert);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ion_cursor_status_t bpptree_next	(	ion_dict_cursor_t *	cursor,
		ion_record_t *	record
	)

Next function to query and retrieve the next <K,V> that stratifies the predicate of the cursor.

Parameters

cursor	The cursor to iterate over the results.
record	The structure used to hold the returned key value pair. This must be properly initialized and allocated by the user.

Returns

The status of the cursor.

Definition at line 424 of file bpp_tree_handler.c.

  {
    ion_bpp_cursor_t    *bCursor    = (ion_bpp_cursor_t *) cursor;
    ion_bpptree_t       *bpptree    = (ion_bpptree_t *) cursor->dictionary->instance;

    if (cursor->status == cs_cursor_uninitialized) {
        return cursor->status;
    }
    else if (cursor->status == cs_end_of_results) {
        return cursor->status;
    }
    else if ((cursor->status == cs_cursor_initialized) || (cursor->status == cs_cursor_active)) {
        if (cursor->status == cs_cursor_active) {
            ion_boolean_t is_valid = boolean_true;

            switch (cursor->predicate->type) {
                case predicate_equality: {
                    if (-1 == bCursor->offset) {
                        /* End of results, we can quit */
                        is_valid = boolean_false;
                    }

                    break;
                }

                case predicate_range: {
                    /*do b_find_next_key then test_predicate */
                    if (-1 == bCursor->offset) {
                        ion_bpp_err_t bErr = b_find_next_key(bpptree->tree, bCursor->cur_key, &bCursor->offset);

                        if ((bErrOk != bErr) || (boolean_false == test_predicate(cursor, bCursor->cur_key))) {
                            is_valid = boolean_false;
                        }
                    }

                    break;
                }

                case predicate_all_records: {
                    if (-1 == bCursor->offset) {
                        ion_bpp_err_t bErr = b_find_next_key(bpptree->tree, bCursor->cur_key, &bCursor->offset);

                        if (bErrOk != bErr) {
                            is_valid = boolean_false;
                        }
                    }

                    break;
                }

                case predicate_predicate: {
                    break;
                }
                    /*No default since we can assume the predicate is valid. */
            }

            if (boolean_false == is_valid) {
                cursor->status = cs_end_of_results;
                return cursor->status;
            }
        }
        else {
            /* The status is cs_cursor_initialized */
            cursor->status = cs_cursor_active;
        }

        /* Get key */
        memcpy(record->key, bCursor->cur_key, cursor->dictionary->instance->record.key_size);

        /* Get value */
        lfb_get(&(bpptree->values), bCursor->offset, cursor->dictionary->instance->record.value_size, record->value, &bCursor->offset);
        return cursor->status;
    }

    return cs_invalid_cursor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ion_err_t bpptree_open_dictionary	(	ion_dictionary_handler_t *	handler,
		ion_dictionary_t *	dictionary,
		ion_dictionary_config_info_t *	config,
		ion_dictionary_compare_t	compare
	)

Opens a specific BppTree instance of a dictionary.

Parameters

handler	A pointer to the handler for the specific dictionary being opened.
dictionary	The pointer declared by the caller that will reference the instance of the dictionary opened.
config	The configuration info of the specific dictionary to be opened.
compare	Function pointer for the comparison function for the dictionary.

Returns

The status of opening the dictionary.

Definition at line 701 of file bpp_tree_handler.c.

  {
    return bpptree_create_dictionary(config->id, config->type, config->key_size, config->value_size, config->dictionary_size, compare, handler, dictionary);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ion_status_t bpptree_update	(	ion_dictionary_t *	dictionary,
		ion_key_t	key,
		ion_value_t	value
	)

Updates the value for a given key.

Updates the value for a given key. If the key does not currently exist in the hashmap, it will be created and the value sorted.

Parameters

dictionary	The instance of the dictionary to be updated.
key	The key that is to be updated.
value	The value that is to be updated.

Returns

The status of the update.

Definition at line 386 of file bpp_tree_handler.c.

  {
    ion_bpptree_t       *bpptree;
    ion_bpp_err_t       bErr;
    ion_file_offset_t   offset;
    ion_result_count_t  count;

    count   = 0;
    bpptree = (ion_bpptree_t *) dictionary->instance;

    bErr    = b_get(bpptree->tree, key, &offset);

    if (bErrKeyNotFound != bErr) {
        lfb_update_all(&(bpptree->values), offset, bpptree->super.record.value_size, (ion_byte_t *) value, &count);
    }
    else {
        return bpptree_insert(dictionary, key, value);
    }

    return ION_STATUS_OK(count);
}

Here is the call graph for this function:

Here is the caller graph for this function: