mirror of
https://github.com/MariaDB/server.git
synced 2025-01-18 13:02:28 +01:00
1d1dc31a06
symbols. Use it for all definitions of non-static variables and functions. lexyy.c, make_flex.sh: Declare yylex as UNIV_INTERN, not static. It is referenced from pars0grm.c. Actually, according to nm .libs/ha_innodb.so|grep -w '[ABCE-TVXYZ]' the following symbols are still global: * The vtable for class ha_innodb * pars0grm.c: The function yyparse() and the variables yychar, yylval, yynerrs The required changes to the Bison-generated file pars0grm.c will be addressed in a separate commit, which will add a script similar to make_flex.sh. The class ha_innodb is renamed from class ha_innobase by a #define. Thus, there will be no clash with the builtin InnoDB. However, there will be some overhead for invoking virtual methods of class ha_innodb. Ideas for making the vtable hidden are welcome. -fvisibility=hidden is not available in GCC 3.
166 lines
4 KiB
C
166 lines
4 KiB
C
/******************************************************
|
|
Hash storage.
|
|
Provides a data structure that stores chunks of data in
|
|
its own storage, avoiding duplicates.
|
|
|
|
(c) 2007 Innobase Oy
|
|
|
|
Created September 22, 2007 Vasil Dimov
|
|
*******************************************************/
|
|
|
|
#include "univ.i"
|
|
#include "ha0storage.h"
|
|
#include "hash0hash.h"
|
|
#include "mem0mem.h"
|
|
#include "ut0rnd.h"
|
|
|
|
#ifdef UNIV_NONINL
|
|
#include "ha0storage.ic"
|
|
#endif
|
|
|
|
/***********************************************************************
|
|
Retrieves a data from a storage. If it is present, a pointer to the
|
|
stored copy of data is returned, otherwise NULL is returned. */
|
|
static
|
|
const void*
|
|
ha_storage_get(
|
|
/*===========*/
|
|
ha_storage_t* storage, /* in: hash storage */
|
|
const void* data, /* in: data to check for */
|
|
ulint data_len) /* in: data length */
|
|
{
|
|
ha_storage_node_t* node;
|
|
ulint fold;
|
|
|
|
/* avoid repetitive calls to ut_fold_binary() in the HASH_SEARCH
|
|
macro */
|
|
fold = ut_fold_binary(data, data_len);
|
|
|
|
#define IS_FOUND \
|
|
node->data_len == data_len && memcmp(node->data, data, data_len) == 0
|
|
|
|
HASH_SEARCH(
|
|
next, /* node->"next" */
|
|
storage->hash, /* the hash table */
|
|
fold, /* key */
|
|
ha_storage_node_t*, /* type of node->next */
|
|
node, /* auxiliary variable */
|
|
IS_FOUND); /* search criteria */
|
|
|
|
if (node == NULL) {
|
|
|
|
return(NULL);
|
|
}
|
|
/* else */
|
|
|
|
return(node->data);
|
|
}
|
|
|
|
/***********************************************************************
|
|
Copies data into the storage and returns a pointer to the copy. If the
|
|
same data chunk is already present, then pointer to it is returned.
|
|
Data chunks are considered to be equal if len1 == len2 and
|
|
memcmp(data1, data2, len1) == 0. If "data" is not present (and thus
|
|
data_len bytes need to be allocated) and the size of storage is going to
|
|
become more than "memlim" then "data" is not added and NULL is returned.
|
|
To disable this behavior "memlim" can be set to 0, which stands for
|
|
"no limit". */
|
|
UNIV_INTERN
|
|
const void*
|
|
ha_storage_put_memlim(
|
|
/*==================*/
|
|
ha_storage_t* storage, /* in/out: hash storage */
|
|
const void* data, /* in: data to store */
|
|
ulint data_len, /* in: data length */
|
|
ulint memlim) /* in: memory limit to obey */
|
|
{
|
|
void* raw;
|
|
ha_storage_node_t* node;
|
|
const void* data_copy;
|
|
ulint fold;
|
|
|
|
/* check if data chunk is already present */
|
|
data_copy = ha_storage_get(storage, data, data_len);
|
|
if (data_copy != NULL) {
|
|
|
|
return(data_copy);
|
|
}
|
|
|
|
/* not present */
|
|
|
|
/* check if we are allowed to allocate data_len bytes */
|
|
if (memlim > 0
|
|
&& ha_storage_get_size(storage) + data_len > memlim) {
|
|
|
|
return(NULL);
|
|
}
|
|
|
|
/* we put the auxiliary node struct and the data itself in one
|
|
continuous block */
|
|
raw = mem_heap_alloc(storage->heap,
|
|
sizeof(ha_storage_node_t) + data_len);
|
|
|
|
node = (ha_storage_node_t*) raw;
|
|
data_copy = (byte*) raw + sizeof(*node);
|
|
|
|
memcpy((byte*) raw + sizeof(*node), data, data_len);
|
|
|
|
node->data_len = data_len;
|
|
node->data = data_copy;
|
|
|
|
/* avoid repetitive calls to ut_fold_binary() in the HASH_INSERT
|
|
macro */
|
|
fold = ut_fold_binary(data, data_len);
|
|
|
|
HASH_INSERT(
|
|
ha_storage_node_t, /* type used in the hash chain */
|
|
next, /* node->"next" */
|
|
storage->hash, /* the hash table */
|
|
fold, /* key */
|
|
node); /* add this data to the hash */
|
|
|
|
/* the output should not be changed because it will spoil the
|
|
hash table */
|
|
return(data_copy);
|
|
}
|
|
|
|
#ifdef UNIV_COMPILE_TEST_FUNCS
|
|
|
|
void
|
|
test_ha_storage()
|
|
{
|
|
ha_storage_t* storage;
|
|
char buf[1024];
|
|
int i;
|
|
const void* stored[256];
|
|
const void* p;
|
|
|
|
storage = ha_storage_create(0, 0);
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
|
|
memset(buf, i, sizeof(buf));
|
|
stored[i] = ha_storage_put(storage, buf, sizeof(buf));
|
|
}
|
|
|
|
//ha_storage_empty(&storage);
|
|
|
|
for (i = 255; i >= 0; i--) {
|
|
|
|
memset(buf, i, sizeof(buf));
|
|
p = ha_storage_put(storage, buf, sizeof(buf));
|
|
|
|
if (p != stored[i]) {
|
|
|
|
fprintf(stderr, "ha_storage_put() returned %p "
|
|
"instead of %p, i=%d\n", p, stored[i], i);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fprintf(stderr, "all ok\n");
|
|
|
|
ha_storage_free(storage);
|
|
}
|
|
|
|
#endif /* UNIV_COMPILE_TEST_FUNCS */
|