/*
* __wt_config_subgets --
* Get the value for a given key from a config string in a WT_CONFIG_ITEM.
* This is useful for dealing with nested structs in config strings.
*/
int
__wt_config_subgets(WT_SESSION_IMPL *session,
WT_CONFIG_ITEM *cfg, const char *key, WT_CONFIG_ITEM *value)
{
WT_CONFIG_ITEM key_item =
{ key, strlen(key), 0, WT_CONFIG_ITEM_STRING };
return (__wt_config_subgetraw(session, cfg, &key_item, value));
}
/*
* __wt_config_subgets --
* Get the value for a given key from a config string in a WT_CONFIG_ITEM.
* This is useful for dealing with nested structs in config strings.
*/
int
__wt_config_subgets(WT_SESSION_IMPL *session,
WT_CONFIG_ITEM *cfg, const char *key, WT_CONFIG_ITEM *value)
{
WT_CONFIG_ITEM key_item;
key_item.str = key;
key_item.len = strlen(key);
return (__wt_config_subgetraw(session, cfg, &key_item, value));
}
/*
* __open_index --
* Open an index.
*/
static int
__open_index(WT_SESSION_IMPL *session, WT_TABLE *table, WT_INDEX *idx)
{
WT_CONFIG colconf;
WT_CONFIG_ITEM ckey, cval, metadata;
WT_DECL_ITEM(buf);
WT_DECL_ITEM(plan);
WT_DECL_RET;
u_int npublic_cols, i;
WT_ERR(__wt_scr_alloc(session, 0, &buf));
/* Get the data source from the index config. */
WT_ERR(__wt_config_getones(session, idx->config, "source", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len, &idx->source));
WT_ERR(__wt_config_getones(session, idx->config, "immutable", &cval));
if (cval.val)
F_SET(idx, WT_INDEX_IMMUTABLE);
/*
* Compatibility: we didn't always maintain collator information in
* index metadata, cope when it isn't found.
*/
WT_CLEAR(cval);
WT_ERR_NOTFOUND_OK(__wt_config_getones(
session, idx->config, "collator", &cval));
if (cval.len != 0) {
WT_CLEAR(metadata);
WT_ERR_NOTFOUND_OK(__wt_config_getones(
session, idx->config, "app_metadata", &metadata));
WT_ERR(__wt_collator_config(
session, idx->name, &cval, &metadata,
&idx->collator, &idx->collator_owned));
}
WT_ERR(__wt_extractor_config(
session, idx->name, idx->config, &idx->extractor,
&idx->extractor_owned));
WT_ERR(__wt_config_getones(session, idx->config, "key_format", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len, &idx->key_format));
/*
* The key format for an index is somewhat subtle: the application
* specifies a set of columns that it will use for the key, but the
* engine usually adds some hidden columns in order to derive the
* primary key. These hidden columns are part of the file's key.
*
* The file's key_format is stored persistently, we need to calculate
* the index cursor key format (which will usually omit some of those
* keys).
*/
WT_ERR(__wt_buf_init(session, buf, 0));
WT_ERR(__wt_config_getones(
session, idx->config, "columns", &idx->colconf));
/* Start with the declared index columns. */
WT_ERR(__wt_config_subinit(session, &colconf, &idx->colconf));
for (npublic_cols = 0;
(ret = __wt_config_next(&colconf, &ckey, &cval)) == 0;
++npublic_cols)
WT_ERR(__wt_buf_catfmt(
session, buf, "%.*s,", (int)ckey.len, ckey.str));
if (ret != WT_NOTFOUND)
goto err;
/*
* If we didn't find any columns, the index must have an extractor.
* We don't rely on this unconditionally because it was only added to
* the metadata after version 2.3.1.
*/
if (npublic_cols == 0) {
WT_ERR(__wt_config_getones(
session, idx->config, "index_key_columns", &cval));
npublic_cols = (u_int)cval.val;
WT_ASSERT(session, npublic_cols != 0);
for (i = 0; i < npublic_cols; i++)
WT_ERR(__wt_buf_catfmt(session, buf, "\"bad col\","));
}
/*
* Now add any primary key columns from the table that are not
* already part of the index key.
*/
WT_ERR(__wt_config_subinit(session, &colconf, &table->colconf));
for (i = 0; i < table->nkey_columns &&
(ret = __wt_config_next(&colconf, &ckey, &cval)) == 0;
i++) {
/*
* If the primary key column is already in the secondary key,
* don't add it again.
*/
if (__wt_config_subgetraw(
session, &idx->colconf, &ckey, &cval) == 0)
continue;
WT_ERR(__wt_buf_catfmt(
session, buf, "%.*s,", (int)ckey.len, ckey.str));
}
WT_ERR_NOTFOUND_OK(ret);
/*
* If the table doesn't yet have its column groups, don't try to
* calculate a plan: we are just checking that the index creation is
* sane.
*/
if (!table->cg_complete)
goto err;
WT_ERR(__wt_scr_alloc(session, 0, &plan));
WT_ERR(__wt_struct_plan(
session, table, buf->data, buf->size, false, plan));
WT_ERR(__wt_strndup(session, plan->data, plan->size, &idx->key_plan));
/* Set up the cursor key format (the visible columns). */
WT_ERR(__wt_buf_init(session, buf, 0));
WT_ERR(__wt_struct_truncate(session,
idx->key_format, npublic_cols, buf));
WT_ERR(__wt_strndup(
session, buf->data, buf->size, &idx->idxkey_format));
/*
* Add a trailing padding byte to the format. This ensures that there
* will be no special optimization of the last column, so the primary
* key columns can be simply appended.
*/
WT_ERR(__wt_buf_catfmt(session, buf, "x"));
WT_ERR(__wt_strndup(session, buf->data, buf->size, &idx->exkey_format));
/* By default, index cursor values are the table value columns. */
/* TODO Optimize to use index columns in preference to table lookups. */
WT_ERR(__wt_buf_init(session, plan, 0));
WT_ERR(__wt_struct_plan(session,
table, table->colconf.str, table->colconf.len, true, plan));
WT_ERR(__wt_strndup(session, plan->data, plan->size, &idx->value_plan));
err: __wt_scr_free(session, &buf);
__wt_scr_free(session, &plan);
return (ret);
}
/*
* 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);
}
/*
* __create_index --
* Create an index.
*/
static int
__create_index(WT_SESSION_IMPL *session,
const char *name, int exclusive, const char *config)
{
WT_CONFIG kcols, pkcols;
WT_CONFIG_ITEM ckey, cval, icols, kval;
WT_DECL_PACK_VALUE(pv);
WT_DECL_RET;
WT_ITEM confbuf, extra_cols, fmt, namebuf;
WT_PACK pack;
WT_TABLE *table;
const char *cfg[4] =
{ WT_CONFIG_BASE(session, index_meta), NULL, NULL, NULL };
const char *sourcecfg[] = { config, NULL, NULL };
const char *source, *sourceconf, *idxname, *tablename;
char *idxconf;
size_t tlen;
int have_extractor;
u_int i, npublic_cols;
sourceconf = NULL;
idxconf = NULL;
WT_CLEAR(confbuf);
WT_CLEAR(fmt);
WT_CLEAR(extra_cols);
WT_CLEAR(namebuf);
have_extractor = 0;
tablename = name;
if (!WT_PREFIX_SKIP(tablename, "index:"))
return (EINVAL);
idxname = strchr(tablename, ':');
if (idxname == NULL)
WT_RET_MSG(session, EINVAL, "Invalid index name, "
"should be <table name>:<index name>: %s", name);
tlen = (size_t)(idxname++ - tablename);
if ((ret =
__wt_schema_get_table(session, tablename, tlen, 1, &table)) != 0)
WT_RET_MSG(session, ret,
"Can't create an index for a non-existent table: %.*s",
(int)tlen, tablename);
if (table->is_simple)
WT_RET_MSG(session, EINVAL,
"%s requires a table with named columns", name);
if (__wt_config_getones(session, config, "source", &cval) == 0) {
WT_ERR(__wt_buf_fmt(session, &namebuf,
"%.*s", (int)cval.len, cval.str));
source = namebuf.data;
} else {
WT_ERR(__wt_schema_index_source(
session, table, idxname, config, &namebuf));
source = namebuf.data;
/* Add the source name to the index config before collapsing. */
WT_ERR(__wt_buf_catfmt(session, &confbuf,
",source=\"%s\"", source));
}
if (__wt_config_getones_none(
session, config, "extractor", &cval) == 0 && cval.len != 0) {
have_extractor = 1;
/* Custom extractors must supply a key format. */
if ((ret = __wt_config_getones(
session, config, "key_format", &kval)) != 0)
WT_ERR_MSG(session, EINVAL,
"%s: custom extractors require a key_format", name);
}
/* Calculate the key/value formats. */
WT_CLEAR(icols);
if (__wt_config_getones(session, config, "columns", &icols) != 0 &&
!have_extractor)
WT_ERR_MSG(session, EINVAL,
"%s: requires 'columns' configuration", name);
/*
* Count the public columns using the declared columns for normal
* indices or the key format for custom extractors.
*/
npublic_cols = 0;
if (!have_extractor) {
WT_ERR(__wt_config_subinit(session, &kcols, &icols));
while ((ret = __wt_config_next(&kcols, &ckey, &cval)) == 0)
++npublic_cols;
WT_ERR_NOTFOUND_OK(ret);
} else {
WT_ERR(__pack_initn(session, &pack, kval.str, kval.len));
while ((ret = __pack_next(&pack, &pv)) == 0)
++npublic_cols;
WT_ERR_NOTFOUND_OK(ret);
}
/*
* The key format for an index is somewhat subtle: the application
* specifies a set of columns that it will use for the key, but the
* engine usually adds some hidden columns in order to derive the
* primary key. These hidden columns are part of the source's
* key_format, which we are calculating now, but not part of an index
* cursor's key_format.
*/
WT_ERR(__wt_config_subinit(session, &pkcols, &table->colconf));
for (i = 0; i < table->nkey_columns &&
(ret = __wt_config_next(&pkcols, &ckey, &cval)) == 0;
i++) {
/*
* If the primary key column is already in the secondary key,
* don't add it again.
*/
if (__wt_config_subgetraw(session, &icols, &ckey, &cval) == 0) {
if (have_extractor)
WT_ERR_MSG(session, EINVAL,
"an index with a custom extractor may not "
"include primary key columns");
continue;
}
WT_ERR(__wt_buf_catfmt(
session, &extra_cols, "%.*s,", (int)ckey.len, ckey.str));
}
if (ret != 0 && ret != WT_NOTFOUND)
goto err;
/* Index values are empty: all columns are packed into the index key. */
WT_ERR(__wt_buf_fmt(session, &fmt, "value_format=,key_format="));
if (have_extractor) {
WT_ERR(__wt_buf_catfmt(session, &fmt, "%.*s",
(int)kval.len, kval.str));
WT_CLEAR(icols);
}
/*
* Construct the index key format, or append the primary key columns
* for custom extractors.
*/
WT_ERR(__wt_struct_reformat(session, table,
icols.str, icols.len, (const char *)extra_cols.data, 0, &fmt));
/* Check for a record number index key, which makes no sense. */
WT_ERR(__wt_config_getones(session, fmt.data, "key_format", &cval));
if (cval.len == 1 && cval.str[0] == 'r')
WT_ERR_MSG(session, EINVAL,
"column-store index may not use the record number as its "
"index key");
WT_ERR(__wt_buf_catfmt(
session, &fmt, ",index_key_columns=%u", npublic_cols));
sourcecfg[1] = fmt.data;
WT_ERR(__wt_config_merge(session, sourcecfg, NULL, &sourceconf));
WT_ERR(__wt_schema_create(session, source, sourceconf));
cfg[1] = sourceconf;
cfg[2] = confbuf.data;
WT_ERR(__wt_config_collapse(session, cfg, &idxconf));
if ((ret = __wt_metadata_insert(session, name, idxconf)) != 0) {
/*
* If the entry already exists in the metadata, we're done.
* This is an error for exclusive creates but okay otherwise.
*/
if (ret == WT_DUPLICATE_KEY)
ret = exclusive ? EEXIST : 0;
goto err;
}
/* Make sure that the configuration is valid. */
WT_ERR(__wt_schema_open_index(
session, table, idxname, strlen(idxname), NULL));
err: __wt_free(session, idxconf);
__wt_free(session, sourceconf);
__wt_buf_free(session, &confbuf);
__wt_buf_free(session, &extra_cols);
__wt_buf_free(session, &fmt);
__wt_buf_free(session, &namebuf);
__wt_schema_release_table(session, table);
return (ret);
}
/*
* ___open_index --
* Open an index.
*/
static int
__open_index(WT_SESSION_IMPL *session, WT_TABLE *table, WT_INDEX *idx)
{
WT_CONFIG colconf;
WT_CONFIG_ITEM ckey, cval;
WT_DECL_ITEM(buf);
WT_DECL_ITEM(plan);
WT_DECL_RET;
u_int cursor_key_cols, i;
WT_ERR(__wt_scr_alloc(session, 0, &buf));
/* Get the data source from the index config. */
WT_ERR(__wt_config_getones(session, idx->config, "source", &cval));
WT_ERR(__wt_buf_fmt(
session, buf, "%.*s", (int)cval.len, cval.str));
idx->source = __wt_buf_steal(session, buf, NULL);
idx->need_value = WT_PREFIX_MATCH(idx->source, "lsm:");
WT_ERR(__wt_config_getones(session, idx->config, "key_format", &cval));
WT_ERR(__wt_buf_fmt(
session, buf, "%.*s", (int)cval.len, cval.str));
idx->key_format = __wt_buf_steal(session, buf, NULL);
/*
* The key format for an index is somewhat subtle: the application
* specifies a set of columns that it will use for the key, but the
* engine usually adds some hidden columns in order to derive the
* primary key. These hidden columns are part of the file's key.
*
* The file's key_format is stored persistently, we need to calculate
* the index cursor key format (which will usually omit some of those
* keys).
*/
WT_ERR(__wt_config_getones(
session, idx->config, "columns", &idx->colconf));
/* Start with the declared index columns. */
WT_ERR(__wt_config_subinit(session, &colconf, &idx->colconf));
cursor_key_cols = 0;
while ((ret = __wt_config_next(&colconf, &ckey, &cval)) == 0) {
WT_ERR(__wt_buf_catfmt(
session, buf, "%.*s,", (int)ckey.len, ckey.str));
++cursor_key_cols;
}
if (ret != 0 && ret != WT_NOTFOUND)
goto err;
/*
* Now add any primary key columns from the table that are not
* already part of the index key.
*/
WT_ERR(__wt_config_subinit(session, &colconf, &table->colconf));
for (i = 0; i < table->nkey_columns &&
(ret = __wt_config_next(&colconf, &ckey, &cval)) == 0;
i++) {
/*
* If the primary key column is already in the secondary key,
* don't add it again.
*/
if (__wt_config_subgetraw(
session, &idx->colconf, &ckey, &cval) == 0)
continue;
WT_ERR(__wt_buf_catfmt(
session, buf, "%.*s,", (int)ckey.len, ckey.str));
}
if (ret != 0 && ret != WT_NOTFOUND)
goto err;
WT_ERR(__wt_scr_alloc(session, 0, &plan));
WT_ERR(__wt_struct_plan(session, table, buf->data, buf->size, 0, plan));
idx->key_plan = __wt_buf_steal(session, plan, NULL);
/* Set up the cursor key format (the visible columns). */
WT_ERR(__wt_buf_init(session, buf, 0));
WT_ERR(__wt_struct_truncate(session,
idx->key_format, cursor_key_cols, buf));
idx->idxkey_format = __wt_buf_steal(session, buf, NULL);
/* By default, index cursor values are the table value columns. */
/* TODO Optimize to use index columns in preference to table lookups. */
WT_ERR(__wt_struct_plan(session,
table, table->colconf.str, table->colconf.len, 1, plan));
idx->value_plan = __wt_buf_steal(session, plan, NULL);
err: __wt_scr_free(&buf);
__wt_scr_free(&plan);
return (ret);
}
/*
* __create_index --
* Create an index.
*/
static int
__create_index(WT_SESSION_IMPL *session,
const char *name, int exclusive, const char *config)
{
WT_CONFIG pkcols;
WT_CONFIG_ITEM ckey, cval, icols;
WT_DECL_RET;
WT_ITEM confbuf, extra_cols, fmt, namebuf;
WT_TABLE *table;
const char *cfg[4] =
{ WT_CONFIG_BASE(session, index_meta), NULL, NULL, NULL };
const char *sourcecfg[] = { config, NULL, NULL };
const char *sourceconf, *source, *idxconf, *idxname;
const char *tablename;
size_t tlen;
u_int i;
idxconf = sourceconf = NULL;
WT_CLEAR(confbuf);
WT_CLEAR(fmt);
WT_CLEAR(extra_cols);
WT_CLEAR(namebuf);
tablename = name;
if (!WT_PREFIX_SKIP(tablename, "index:"))
return (EINVAL);
idxname = strchr(tablename, ':');
if (idxname == NULL)
WT_RET_MSG(session, EINVAL, "Invalid index name, "
"should be <table name>:<index name>: %s", name);
tlen = (size_t)(idxname++ - tablename);
if ((ret =
__wt_schema_get_table(session, tablename, tlen, 1, &table)) != 0)
WT_RET_MSG(session, ret,
"Can't create an index for a non-existent table: %.*s",
(int)tlen, tablename);
if (__wt_config_getones(session, config, "source", &cval) == 0) {
WT_ERR(__wt_buf_fmt(session, &namebuf,
"%.*s", (int)cval.len, cval.str));
source = namebuf.data;
} else {
WT_ERR(__wt_schema_index_source(
session, table, idxname, config, &namebuf));
source = namebuf.data;
/* Add the source name to the index config before collapsing. */
WT_ERR(__wt_buf_catfmt(session, &confbuf,
",source=\"%s\"", source));
}
/* Calculate the key/value formats. */
if (__wt_config_getones(session, config, "columns", &icols) != 0)
WT_ERR_MSG(session, EINVAL,
"No 'columns' configuration for '%s'", name);
/*
* The key format for an index is somewhat subtle: the application
* specifies a set of columns that it will use for the key, but the
* engine usually adds some hidden columns in order to derive the
* primary key. These hidden columns are part of the source's
* key_format, which we are calculating now, but not part of an index
* cursor's key_format.
*/
WT_ERR(__wt_config_subinit(session, &pkcols, &table->colconf));
for (i = 0; i < table->nkey_columns &&
(ret = __wt_config_next(&pkcols, &ckey, &cval)) == 0;
i++) {
/*
* If the primary key column is already in the secondary key,
* don't add it again.
*/
if (__wt_config_subgetraw(session, &icols, &ckey, &cval) == 0)
continue;
WT_ERR(__wt_buf_catfmt(
session, &extra_cols, "%.*s,", (int)ckey.len, ckey.str));
}
if (ret != 0 && ret != WT_NOTFOUND)
goto err;
/*
* Index values are normally empty: all columns are packed into the
* index key. The exception is LSM, which (currently) reserves empty
* values as tombstones. Use a single padding byte in that case.
*/
if (WT_PREFIX_MATCH(source, "lsm:"))
WT_ERR(__wt_buf_fmt(session, &fmt, "value_format=x,"));
else
WT_ERR(__wt_buf_fmt(session, &fmt, "value_format=,"));
WT_ERR(__wt_buf_fmt(session, &fmt, "value_format=,key_format="));
WT_ERR(__wt_struct_reformat(session, table,
icols.str, icols.len, (const char *)extra_cols.data, 0, &fmt));
/* Check for a record number index key, which makes no sense. */
WT_ERR(__wt_config_getones(session, fmt.data, "key_format", &cval));
if (cval.len == 1 && cval.str[0] == 'r')
WT_ERR_MSG(session, EINVAL,
"column-store index may not use the record number as its "
"index key");
sourcecfg[1] = fmt.data;
WT_ERR(__wt_config_concat(session, sourcecfg, &sourceconf));
WT_ERR(__wt_schema_create(session, source, sourceconf));
cfg[1] = sourceconf;
cfg[2] = confbuf.data;
WT_ERR(__wt_config_collapse(session, cfg, &idxconf));
if ((ret = __wt_metadata_insert(session, name, idxconf)) != 0) {
/*
* If the entry already exists in the metadata, we're done.
* This is an error for exclusive creates but okay otherwise.
*/
if (ret == WT_DUPLICATE_KEY)
ret = exclusive ? EEXIST : 0;
goto err;
}
err: __wt_free(session, idxconf);
__wt_free(session, sourceconf);
__wt_buf_free(session, &confbuf);
__wt_buf_free(session, &extra_cols);
__wt_buf_free(session, &fmt);
__wt_buf_free(session, &namebuf);
__wt_schema_release_table(session, table);
return (ret);
}
