/*
* __wt_config_get --
* Given a NULL-terminated list of configuration strings, find
* the final value for a given key.
*/
int
__wt_config_get(WT_SESSION_IMPL *session,
const char **cfg_arg, WT_CONFIG_ITEM *key, WT_CONFIG_ITEM *value)
{
WT_CONFIG cparser;
WT_DECL_RET;
const char **cfg;
if (cfg_arg[0] == NULL)
return (WT_NOTFOUND);
/*
* Search the strings in reverse order, that way the first hit wins
* and we don't search the base set until there's no other choice.
*/
for (cfg = cfg_arg; *cfg != NULL; ++cfg)
;
do {
--cfg;
__wt_config_init(session, &cparser, *cfg);
if ((ret = __config_getraw(&cparser, key, value, true)) == 0)
return (0);
WT_RET_NOTFOUND_OK(ret);
} while (cfg != cfg_arg);
return (WT_NOTFOUND);
}
/*
* __wt_struct_reformat --
* Given a table and a list of columns (which could be values in a column
* group or index keys), calculate the resulting new format string.
* The result will be appended to the format buffer.
*/
int
__wt_struct_reformat(WT_SESSION_IMPL *session, WT_TABLE *table,
const char *columns, size_t len, const char *extra_cols, int value_only,
WT_ITEM *format)
{
WT_CONFIG config;
WT_CONFIG_ITEM k, next_k, next_v;
WT_DECL_RET;
WT_PACK_VALUE pv;
int have_next;
WT_CLEAR(pv); /* -Wuninitialized */
WT_RET(__wt_config_initn(session, &config, columns, len));
WT_RET(__wt_config_next(&config, &next_k, &next_v));
do {
k = next_k;
ret = __wt_config_next(&config, &next_k, &next_v);
if (ret != 0 && ret != WT_NOTFOUND)
return (ret);
have_next = (ret == 0);
if (!have_next && extra_cols != NULL) {
WT_RET(__wt_config_init(session, &config, extra_cols));
WT_RET(__wt_config_next(&config, &next_k, &next_v));
have_next = 1;
extra_cols = NULL;
}
if ((ret = __find_column_format(session,
table, &k, value_only, &pv)) != 0) {
if (value_only && ret == EINVAL)
WT_RET_MSG(session, EINVAL,
"A column group cannot store key column "
"'%.*s' in its value", (int)k.len, k.str);
WT_RET_MSG(session, EINVAL,
"Column '%.*s' not found", (int)k.len, k.str);
}
/*
* Check whether we're moving an unsized WT_ITEM from the end
* to the middle, or vice-versa. This determines whether the
* size needs to be prepended. This is the only case where the
* destination size can be larger than the source size.
*/
if (pv.type == 'u' && !pv.havesize && have_next)
pv.type = 'U';
else if (pv.type == 'U' && !have_next)
pv.type = 'u';
if (pv.havesize)
WT_RET(__wt_buf_catfmt(
session, format, "%d%c", (int)pv.size, pv.type));
else
WT_RET(__wt_buf_catfmt(session, format, "%c", pv.type));
} while (have_next);
return (0);
}
/*
* __wt_config_getone --
* Get the value for a given key from a single config string.
*/
int
__wt_config_getone(WT_SESSION_IMPL *session,
const char *config, WT_CONFIG_ITEM *key, WT_CONFIG_ITEM *value)
{
WT_CONFIG cparser;
WT_RET(__wt_config_init(session, &cparser, config));
return (__config_getraw(&cparser, key, value, true));
}
/*
* __wt_config_concat --
* Given a NULL-terminated list of configuration strings, concatenate them
* into a newly allocated buffer. Nothing special is assumed about any
* of the config strings, they are simply combined in order.
*
* This code deals with the case where some of the config strings are
* wrapped in brackets but others aren't: the resulting string does not
* have brackets.
*/
int
__wt_config_concat(
WT_SESSION_IMPL *session, const char **cfg, const char **config_ret)
{
WT_CONFIG cparser;
WT_CONFIG_ITEM k, v;
WT_ITEM buf;
int ret;
const char **cp;
WT_CLEAR(buf);
ret = 0;
for (cp = cfg; *cp != NULL; ++cp) {
WT_ERR(__wt_config_init(session, &cparser, *cp));
while ((ret = __wt_config_next(&cparser, &k, &v)) == 0) {
if (k.type != ITEM_STRING && k.type != ITEM_ID)
WT_ERR_MSG(session, EINVAL,
"Invalid configuration key found: '%s'\n",
k.str);
/* Include the quotes around string keys/values. */
if (k.type == ITEM_STRING) {
--k.str;
k.len += 2;
}
if (v.type == ITEM_STRING) {
--v.str;
v.len += 2;
}
WT_ERR(__wt_buf_catfmt(session, &buf, "%.*s%s%.*s,",
(int)k.len, k.str,
(v.len > 0) ? "=" : "",
(int)v.len, v.str));
}
if (ret != WT_NOTFOUND)
goto err;
}
/*
* If the caller passes us no valid configuration strings, we end up
* here with no allocated memory to return. Check the final buffer
* size: empty configuration strings are possible, and paranoia is
* good.
*/
if (buf.size == 0)
WT_RET(__wt_buf_initsize(session, &buf, 1));
/* Strip the trailing comma and NUL-terminate */
((char *)buf.data)[buf.size - 1] = '\0';
*config_ret = buf.data;
return (0);
err: __wt_buf_free(session, &buf);
return (ret);
}
/*
* __wt_config_getones --
* Get the value for a given string key from a single config string.
*/
int
__wt_config_getones(WT_SESSION_IMPL *session,
const char *config, const char *key, WT_CONFIG_ITEM *value)
{
WT_CONFIG cparser;
WT_CONFIG_ITEM key_item = { key, strlen(key), 0, ITEM_STRING };
WT_RET(__wt_config_init(session, &cparser, config));
return (__config_getraw(&cparser, &key_item, value, 1));
}
/*
* __wt_config_collapse --
* Collapse a set of configuration strings into newly allocated memory.
*
* This function takes a NULL-terminated list of configuration strings (where
* the first one contains all the defaults and the values are in order from
* least to most preferred, that is, the default values are least preferred),
* and collapses them into newly allocated memory. The algorithm is to walk
* the first of the configuration strings, and for each entry, search all of
* the configuration strings for a final value, keeping the last value found.
*
* Notes:
* Any key not appearing in the first configuration string is discarded
* from the final result, because we'll never search for it.
*
* Nested structures aren't parsed. For example, imagine a configuration
* string contains "key=(k2=v2,k3=v3)", and a subsequent string has
* "key=(k4=v4)", the result will be "key=(k4=v4)", as we search for and
* use the final value of "key", regardless of field overlap or missing
* fields in the nested value.
*/
int
__wt_config_collapse(
WT_SESSION_IMPL *session, const char **cfg, char **config_ret)
{
WT_CONFIG cparser;
WT_CONFIG_ITEM k, v;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
*config_ret = NULL;
WT_RET(__wt_scr_alloc(session, 0, &tmp));
__wt_config_init(session, &cparser, cfg[0]);
while ((ret = __wt_config_next(&cparser, &k, &v)) == 0) {
if (k.type != WT_CONFIG_ITEM_STRING &&
k.type != WT_CONFIG_ITEM_ID)
WT_ERR_MSG(session, EINVAL,
"Invalid configuration key found: '%s'", k.str);
WT_ERR(__wt_config_get(session, cfg, &k, &v));
/* Include the quotes around string keys/values. */
if (k.type == WT_CONFIG_ITEM_STRING) {
--k.str;
k.len += 2;
}
if (v.type == WT_CONFIG_ITEM_STRING) {
--v.str;
v.len += 2;
}
WT_ERR(__wt_buf_catfmt(session, tmp, "%.*s=%.*s,",
(int)k.len, k.str, (int)v.len, v.str));
}
/* We loop until error, and the expected error is WT_NOTFOUND. */
if (ret != WT_NOTFOUND)
goto err;
/*
* If the caller passes us no valid configuration strings, we get here
* with no bytes to copy -- that's OK, the underlying string copy can
* handle empty strings.
*
* Strip any trailing comma.
*/
if (tmp->size != 0)
--tmp->size;
ret = __wt_strndup(session, tmp->data, tmp->size, config_ret);
err: __wt_scr_free(session, &tmp);
return (ret);
}
/*
* __wt_config_get --
* Given a NULL-terminated list of configuration strings, find
* the final value for a given key.
*/
int
__wt_config_get(WT_SESSION_IMPL *session,
const char **cfg, WT_CONFIG_ITEM *key, WT_CONFIG_ITEM *value)
{
WT_CONFIG cparser;
WT_DECL_RET;
int found;
for (found = 0; *cfg != NULL; cfg++) {
WT_RET(__wt_config_init(session, &cparser, *cfg));
if ((ret = __config_getraw(&cparser, key, value, true)) == 0)
found = 1;
else if (ret != WT_NOTFOUND)
return (ret);
}
return (found ? 0 : WT_NOTFOUND);
}
/*
* config_check --
* Check the keys in an application-supplied config string match what is
* specified in an array of check strings.
*/
static int
config_check(WT_SESSION_IMPL *session,
const WT_CONFIG_CHECK *checks, const char *config, size_t config_len)
{
WT_CONFIG parser, cparser, sparser;
WT_CONFIG_ITEM k, v, ck, cv, dummy;
WT_DECL_RET;
int i;
bool badtype, found;
/*
* The config_len parameter is optional, and allows passing in strings
* that are not nul-terminated.
*/
if (config_len == 0)
WT_RET(__wt_config_init(session, &parser, config));
else
WT_RET(__wt_config_initn(session, &parser, config, config_len));
while ((ret = __wt_config_next(&parser, &k, &v)) == 0) {
if (k.type != WT_CONFIG_ITEM_STRING &&
k.type != WT_CONFIG_ITEM_ID)
WT_RET_MSG(session, EINVAL,
"Invalid configuration key found: '%.*s'",
(int)k.len, k.str);
/* Search for a matching entry. */
for (i = 0; checks[i].name != NULL; i++)
if (WT_STRING_MATCH(checks[i].name, k.str, k.len))
break;
if (checks[i].name == NULL)
WT_RET_MSG(session, EINVAL,
"unknown configuration key: '%.*s'",
(int)k.len, k.str);
if (strcmp(checks[i].type, "boolean") == 0) {
badtype = v.type != WT_CONFIG_ITEM_BOOL &&
(v.type != WT_CONFIG_ITEM_NUM ||
(v.val != 0 && v.val != 1));
} else if (strcmp(checks[i].type, "category") == 0) {
/* Deal with categories of the form: XXX=(XXX=blah). */
ret = config_check(session,
checks[i].subconfigs,
k.str + strlen(checks[i].name) + 1, v.len);
if (ret != EINVAL)
badtype = false;
else
badtype = true;
} else if (strcmp(checks[i].type, "format") == 0) {
badtype = false;
} else if (strcmp(checks[i].type, "int") == 0) {
badtype = v.type != WT_CONFIG_ITEM_NUM;
} else if (strcmp(checks[i].type, "list") == 0) {
badtype = v.len > 0 && v.type != WT_CONFIG_ITEM_STRUCT;
} else if (strcmp(checks[i].type, "string") == 0) {
badtype = false;
} else
WT_RET_MSG(session, EINVAL,
"unknown configuration type: '%s'",
checks[i].type);
if (badtype)
WT_RET_MSG(session, EINVAL,
"Invalid value for key '%.*s': expected a %s",
(int)k.len, k.str, checks[i].type);
if (checks[i].checkf != NULL)
WT_RET(checks[i].checkf(session, &v));
if (checks[i].checks == NULL)
continue;
/* Setup an iterator for the check string. */
WT_RET(__wt_config_init(session, &cparser, checks[i].checks));
while ((ret = __wt_config_next(&cparser, &ck, &cv)) == 0) {
if (WT_STRING_MATCH("min", ck.str, ck.len)) {
if (v.val < cv.val)
WT_RET_MSG(session, EINVAL,
"Value too small for key '%.*s' "
"the minimum is %.*s",
(int)k.len, k.str,
(int)cv.len, cv.str);
} else if (WT_STRING_MATCH("max", ck.str, ck.len)) {
if (v.val > cv.val)
WT_RET_MSG(session, EINVAL,
"Value too large for key '%.*s' "
"the maximum is %.*s",
(int)k.len, k.str,
(int)cv.len, cv.str);
} else if (WT_STRING_MATCH("choices", ck.str, ck.len)) {
if (v.len == 0)
WT_RET_MSG(session, EINVAL,
"Key '%.*s' requires a value",
(int)k.len, k.str);
if (v.type == WT_CONFIG_ITEM_STRUCT) {
/*
* Handle the 'verbose' case of a list
* containing restricted choices.
*/
WT_RET(__wt_config_subinit(session,
&sparser, &v));
found = true;
while (found &&
(ret = __wt_config_next(&sparser,
&v, &dummy)) == 0) {
ret = __wt_config_subgetraw(
session, &cv, &v, &dummy);
found = ret == 0;
}
} else {
ret = __wt_config_subgetraw(session,
&cv, &v, &dummy);
found = ret == 0;
}
if (ret != 0 && ret != WT_NOTFOUND)
return (ret);
if (!found)
WT_RET_MSG(session, EINVAL,
"Value '%.*s' not a "
"permitted choice for key '%.*s'",
(int)v.len, v.str,
(int)k.len, k.str);
} else
WT_RET_MSG(session, EINVAL,
"unexpected configuration description "
"keyword %.*s", (int)ck.len, ck.str);
}
}
if (ret == WT_NOTFOUND)
ret = 0;
return (ret);
}
/*
* __config_merge_scan --
* Walk a configuration string, inserting entries into the merged array.
*/
static int
__config_merge_scan(WT_SESSION_IMPL *session,
const char *key, const char *value, WT_CONFIG_MERGE *cp)
{
WT_CONFIG cparser;
WT_CONFIG_ITEM k, v;
WT_DECL_ITEM(kb);
WT_DECL_ITEM(vb);
WT_DECL_RET;
size_t len;
WT_ERR(__wt_scr_alloc(session, 0, &kb));
WT_ERR(__wt_scr_alloc(session, 0, &vb));
WT_ERR(__wt_config_init(session, &cparser, value));
while ((ret = __wt_config_next(&cparser, &k, &v)) == 0) {
if (k.type != WT_CONFIG_ITEM_STRING &&
k.type != WT_CONFIG_ITEM_ID)
WT_ERR_MSG(session, EINVAL,
"Invalid configuration key found: '%s'\n", k.str);
/* Include the quotes around string keys/values. */
if (k.type == WT_CONFIG_ITEM_STRING) {
--k.str;
k.len += 2;
}
if (v.type == WT_CONFIG_ITEM_STRING) {
--v.str;
v.len += 2;
}
/*
* !!!
* We're using a JSON quote character to separate the names we
* create for nested structures. That's not completely safe as
* it's possible to quote characters in JSON such that a quote
* character appears as a literal character in a key name. In
* a few cases, applications can create their own key namespace
* (for example, shared library extension names), and therefore
* it's possible for an application to confuse us. Error if we
* we ever see a key with a magic character.
*/
for (len = 0; len < k.len; ++len)
if (k.str[len] == SEPC)
WT_ERR_MSG(session, EINVAL,
"key %.*s contains a '%c' separator "
"character",
(int)k.len, (char *)k.str, SEPC);
/* Build the key/value strings. */
WT_ERR(__wt_buf_fmt(session,
kb, "%s%s%.*s",
key == NULL ? "" : key,
key == NULL ? "" : SEP,
(int)k.len, k.str));
WT_ERR(__wt_buf_fmt(session,
vb, "%.*s", (int)v.len, v.str));
/*
* If the value is a structure, recursively parse it.
*
* !!!
* Don't merge unless the structure has field names. WiredTiger
* stores checkpoint LSNs in the metadata file using nested
* structures without field names: "checkpoint_lsn=(1,0)", not
* "checkpoint_lsn=(file=1,offset=0)". The value type is still
* WT_CONFIG_ITEM_STRUCT, so we check for a field name in the
* value.
*/
if (v.type == WT_CONFIG_ITEM_STRUCT &&
strchr(vb->data, '=') != NULL) {
WT_ERR(__config_merge_scan(
session, kb->data, vb->data, cp));
continue;
}
/* Insert the value into the array. */
WT_ERR(__wt_realloc_def(session,
&cp->entries_allocated,
cp->entries_next + 1, &cp->entries));
WT_ERR(__wt_strndup(session,
kb->data, kb->size, &cp->entries[cp->entries_next].k));
WT_ERR(__wt_strndup(session,
vb->data, vb->size, &cp->entries[cp->entries_next].v));
cp->entries[cp->entries_next].gen = cp->entries_next;
++cp->entries_next;
}
WT_ERR_NOTFOUND_OK(ret);
err: __wt_scr_free(session, &kb);
__wt_scr_free(session, &vb);
return (ret);
}
/*
* __wt_struct_reformat --
* Given a table and a list of columns (which could be values in a column
* group or index keys), calculate the resulting new format string.
* The result will be appended to the format buffer.
*/
int
__wt_struct_reformat(WT_SESSION_IMPL *session, WT_TABLE *table,
const char *columns, size_t len, const char *extra_cols, bool value_only,
WT_ITEM *format)
{
WT_CONFIG config;
WT_CONFIG_ITEM k, next_k, next_v;
WT_DECL_PACK_VALUE(pv);
WT_DECL_RET;
bool have_next;
__wt_config_initn(session, &config, columns, len);
/*
* If an empty column list is specified, this will fail with
* WT_NOTFOUND, that's okay.
*/
WT_RET_NOTFOUND_OK(ret = __wt_config_next(&config, &next_k, &next_v));
if (ret == WT_NOTFOUND) {
if (extra_cols != NULL) {
__wt_config_init(session, &config, extra_cols);
WT_RET(__wt_config_next(&config, &next_k, &next_v));
extra_cols = NULL;
} else if (format->size == 0) {
WT_RET(__wt_buf_set(session, format, "", 1));
return (0);
}
}
do {
k = next_k;
ret = __wt_config_next(&config, &next_k, &next_v);
if (ret != 0 && ret != WT_NOTFOUND)
return (ret);
have_next = ret == 0;
if (!have_next && extra_cols != NULL) {
__wt_config_init(session, &config, extra_cols);
WT_RET(__wt_config_next(&config, &next_k, &next_v));
have_next = true;
extra_cols = NULL;
}
if ((ret = __find_column_format(session,
table, &k, value_only, &pv)) != 0) {
if (value_only && ret == EINVAL)
WT_RET_MSG(session, EINVAL,
"A column group cannot store key column "
"'%.*s' in its value", (int)k.len, k.str);
WT_RET_MSG(session, EINVAL,
"Column '%.*s' not found", (int)k.len, k.str);
}
/*
* Check whether we're moving an unsized WT_ITEM from the end
* to the middle, or vice-versa. This determines whether the
* size needs to be prepended. This is the only case where the
* destination size can be larger than the source size.
*/
if (pv.type == 'u' && !pv.havesize && have_next)
pv.type = 'U';
else if (pv.type == 'U' && !have_next)
pv.type = 'u';
if (pv.havesize)
WT_RET(__wt_buf_catfmt(session,
format, "%" PRIu32 "%c", pv.size, pv.type));
else
WT_RET(__wt_buf_catfmt(session, format, "%c", pv.type));
} while (have_next);
return (0);
}
/*
* __wt_lsm_meta_read --
* Read the metadata for an LSM tree.
*/
int
__wt_lsm_meta_read(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree)
{
WT_CONFIG cparser, lparser;
WT_CONFIG_ITEM ck, cv, fileconf, lk, lv, metadata;
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
char *lsmconfig;
u_int nchunks;
chunk = NULL; /* -Wconditional-uninitialized */
/* LSM trees inherit the merge setting from the connection. */
if (F_ISSET(S2C(session), WT_CONN_LSM_MERGE))
F_SET(lsm_tree, WT_LSM_TREE_MERGES);
WT_RET(__wt_metadata_search(session, lsm_tree->name, &lsmconfig));
WT_ERR(__wt_config_init(session, &cparser, lsmconfig));
while ((ret = __wt_config_next(&cparser, &ck, &cv)) == 0) {
if (WT_STRING_MATCH("key_format", ck.str, ck.len)) {
__wt_free(session, lsm_tree->key_format);
WT_ERR(__wt_strndup(session,
cv.str, cv.len, &lsm_tree->key_format));
} else if (WT_STRING_MATCH("value_format", ck.str, ck.len)) {
__wt_free(session, lsm_tree->value_format);
WT_ERR(__wt_strndup(session,
cv.str, cv.len, &lsm_tree->value_format));
} else if (WT_STRING_MATCH("collator", ck.str, ck.len)) {
if (cv.len == 0 ||
WT_STRING_MATCH("none", cv.str, cv.len))
continue;
/*
* Extract the application-supplied metadata (if any)
* from the file configuration.
*/
WT_ERR(__wt_config_getones(
session, lsmconfig, "file_config", &fileconf));
WT_CLEAR(metadata);
WT_ERR_NOTFOUND_OK(__wt_config_subgets(
session, &fileconf, "app_metadata", &metadata));
WT_ERR(__wt_collator_config(session, lsm_tree->name,
&cv, &metadata,
&lsm_tree->collator, &lsm_tree->collator_owned));
WT_ERR(__wt_strndup(session,
cv.str, cv.len, &lsm_tree->collator_name));
} else if (WT_STRING_MATCH("bloom_config", ck.str, ck.len)) {
__wt_free(session, lsm_tree->bloom_config);
/* Don't include the brackets. */
WT_ERR(__wt_strndup(session,
cv.str + 1, cv.len - 2, &lsm_tree->bloom_config));
} else if (WT_STRING_MATCH("file_config", ck.str, ck.len)) {
__wt_free(session, lsm_tree->file_config);
/* Don't include the brackets. */
WT_ERR(__wt_strndup(session,
cv.str + 1, cv.len - 2, &lsm_tree->file_config));
} else if (WT_STRING_MATCH("auto_throttle", ck.str, ck.len)) {
if (cv.val)
F_SET(lsm_tree, WT_LSM_TREE_THROTTLE);
else
F_CLR(lsm_tree, WT_LSM_TREE_THROTTLE);
} else if (WT_STRING_MATCH("bloom", ck.str, ck.len))
lsm_tree->bloom = (uint32_t)cv.val;
else if (WT_STRING_MATCH("bloom_bit_count", ck.str, ck.len))
lsm_tree->bloom_bit_count = (uint32_t)cv.val;
else if (WT_STRING_MATCH("bloom_hash_count", ck.str, ck.len))
lsm_tree->bloom_hash_count = (uint32_t)cv.val;
else if (WT_STRING_MATCH("chunk_count_limit", ck.str, ck.len)) {
lsm_tree->chunk_count_limit = (uint32_t)cv.val;
if (cv.val != 0)
F_CLR(lsm_tree, WT_LSM_TREE_MERGES);
} else if (WT_STRING_MATCH("chunk_max", ck.str, ck.len))
lsm_tree->chunk_max = (uint64_t)cv.val;
else if (WT_STRING_MATCH("chunk_size", ck.str, ck.len))
lsm_tree->chunk_size = (uint64_t)cv.val;
else if (WT_STRING_MATCH("merge_max", ck.str, ck.len))
lsm_tree->merge_max = (uint32_t)cv.val;
else if (WT_STRING_MATCH("merge_min", ck.str, ck.len))
lsm_tree->merge_min = (uint32_t)cv.val;
else if (WT_STRING_MATCH("last", ck.str, ck.len))
lsm_tree->last = (u_int)cv.val;
else if (WT_STRING_MATCH("chunks", ck.str, ck.len)) {
WT_ERR(__wt_config_subinit(session, &lparser, &cv));
for (nchunks = 0; (ret =
__wt_config_next(&lparser, &lk, &lv)) == 0; ) {
if (WT_STRING_MATCH("id", lk.str, lk.len)) {
WT_ERR(__wt_realloc_def(session,
&lsm_tree->chunk_alloc,
nchunks + 1, &lsm_tree->chunk));
WT_ERR(
__wt_calloc_one(session, &chunk));
lsm_tree->chunk[nchunks++] = chunk;
chunk->id = (uint32_t)lv.val;
WT_ERR(__wt_lsm_tree_chunk_name(session,
lsm_tree, chunk->id, &chunk->uri));
F_SET(chunk,
WT_LSM_CHUNK_ONDISK |
WT_LSM_CHUNK_STABLE);
} else if (WT_STRING_MATCH(
"bloom", lk.str, lk.len)) {
WT_ERR(__wt_lsm_tree_bloom_name(
session, lsm_tree,
chunk->id, &chunk->bloom_uri));
F_SET(chunk, WT_LSM_CHUNK_BLOOM);
continue;
} else if (WT_STRING_MATCH(
"chunk_size", lk.str, lk.len)) {
chunk->size = (uint64_t)lv.val;
continue;
} else if (WT_STRING_MATCH(
"count", lk.str, lk.len)) {
chunk->count = (uint64_t)lv.val;
continue;
} else if (WT_STRING_MATCH(
"generation", lk.str, lk.len)) {
chunk->generation = (uint32_t)lv.val;
continue;
}
}
WT_ERR_NOTFOUND_OK(ret);
lsm_tree->nchunks = nchunks;
} else if (WT_STRING_MATCH("old_chunks", ck.str, ck.len)) {
WT_ERR(__wt_config_subinit(session, &lparser, &cv));
for (nchunks = 0; (ret =
__wt_config_next(&lparser, &lk, &lv)) == 0; ) {
if (WT_STRING_MATCH("bloom", lk.str, lk.len)) {
WT_ERR(__wt_strndup(session,
lv.str, lv.len, &chunk->bloom_uri));
F_SET(chunk, WT_LSM_CHUNK_BLOOM);
continue;
}
WT_ERR(__wt_realloc_def(session,
&lsm_tree->old_alloc, nchunks + 1,
&lsm_tree->old_chunks));
WT_ERR(__wt_calloc_one(session, &chunk));
lsm_tree->old_chunks[nchunks++] = chunk;
WT_ERR(__wt_strndup(session,
lk.str, lk.len, &chunk->uri));
F_SET(chunk, WT_LSM_CHUNK_ONDISK);
}
WT_ERR_NOTFOUND_OK(ret);
lsm_tree->nold_chunks = nchunks;
}
/*
* Ignore any other values: the metadata entry might have been
* created by a future release, with unknown options.
*/
}
WT_ERR_NOTFOUND_OK(ret);
/*
* If the default merge_min was not overridden, calculate it now. We
* do this here so that trees created before merge_min was added get a
* sane value.
*/
if (lsm_tree->merge_min < 2)
lsm_tree->merge_min = WT_MAX(2, lsm_tree->merge_max / 2);
err: __wt_free(session, lsmconfig);
return (ret);
}
