/*
* config_update --
* Reconcile and update the command line configuration against the
* config we found.
*/
int
config_update(WT_SESSION *session, char **list)
{
int found;
const char *cfg[] = { NULL, NULL, NULL };
char **configp, **listp;
const char **rm;
static const char *rmnames[] = {
"filename", "id", "checkpoint", "checkpoint_lsn",
"version", "source", NULL };
/*
* If the object has been renamed, replace all of the column group,
* index, file and table names with the new name.
*/
if (cmdname != NULL) {
for (listp = list; *listp != NULL; listp += 2)
if (WT_PREFIX_MATCH(*listp, "colgroup:") ||
WT_PREFIX_MATCH(*listp, "file:") ||
WT_PREFIX_MATCH(*listp, "index:") ||
WT_PREFIX_MATCH(*listp, "table:"))
if (config_rename(listp, cmdname))
return (1);
/*
* If the object was renamed, and there are configuration pairs,
* rename the configuration pairs as well, because we don't know
* if the user used the old or new names for the pair's URI.
*/
for (configp = cmdconfig;
cmdconfig != NULL && *configp != NULL; configp += 2)
if (config_rename(configp, cmdname))
return (1);
}
/*
* Remove all "filename=", "source=" and other configurations
* that foil loading from the values. New filenames are chosen
* as part of table load.
*/
for (listp = list; *listp != NULL; listp += 2)
for (rm = rmnames; *rm != NULL; rm++)
if (strstr(listp[1], *rm) != NULL)
config_remove(listp[1], *rm);
/*
* It's possible to update everything except the key/value formats.
* If there were command-line configuration pairs, walk the list of
* command-line configuration strings, and check.
*/
for (configp = cmdconfig;
cmdconfig != NULL && *configp != NULL; configp += 2)
if (strstr(configp[1], "key_format=") ||
strstr(configp[1], "value_format="))
return (util_err(0,
"the command line configuration string may not "
"modify the object's key or value format"));
/*
* If there were command-line configuration pairs, walk the list of
* command-line URIs and find a matching dump URI. For each match,
* rewrite the dump configuration as described by the command-line
* configuration. It is an error if a command-line URI doesn't find
* a single, exact match, that's likely a mistake.
*/
for (configp = cmdconfig;
cmdconfig != NULL && *configp != NULL; configp += 2) {
found = 0;
for (listp = list; *listp != NULL; listp += 2) {
if (strncmp(*configp, listp[0], strlen(*configp)) != 0)
continue;
/*
* !!!
* We support JSON configuration strings, which leads to
* configuration strings with brackets. Unfortunately,
* that implies we can't simply append new configuration
* strings to existing ones. We call an unpublished
* WiredTiger API to do the concatenation: if anyone
* else ever needs it we can make it public, but I think
* that's unlikely. We're also playing fast and loose
* with types, but it should work.
*/
cfg[0] = listp[1];
cfg[1] = configp[1];
if (__wt_config_concat(
(WT_SESSION_IMPL *)session, cfg, &listp[1]) != 0)
return (1);
++found;
}
switch (found) {
case 0:
return (util_err(0,
"the command line object name %s was not matched "
"by any loaded object name", *configp));
case 1:
break;
default:
return (util_err(0,
"the command line object name %s was not unique, "
"matching more than a single loaded object name",
*configp));
}
}
/* Leak the memory, I don't care. */
return (0);
}
/*
* __create_colgroup --
* Create a column group.
*/
static int
__create_colgroup(WT_SESSION_IMPL *session,
const char *name, int exclusive, const char *config)
{
WT_CONFIG_ITEM cval;
WT_DECL_RET;
WT_ITEM confbuf, fmt, namebuf;
WT_TABLE *table;
size_t tlen;
const char *cfg[4] =
{ WT_CONFIG_BASE(session, colgroup_meta), config, NULL, NULL };
const char *sourcecfg[] = { config, NULL, NULL };
const char **cfgp;
const char *cgconf, *cgname, *sourceconf, *oldconf;
const char *source, *tablename;
cgconf = sourceconf = oldconf = NULL;
WT_CLEAR(fmt);
WT_CLEAR(confbuf);
WT_CLEAR(namebuf);
tablename = name;
if (!WT_PREFIX_SKIP(tablename, "colgroup:"))
return (EINVAL);
cgname = strchr(tablename, ':');
if (cgname != NULL) {
tlen = (size_t)(cgname - tablename);
++cgname;
} else
tlen = strlen(tablename);
if ((ret =
__wt_schema_get_table(session, tablename, tlen, 1, &table)) != 0)
WT_RET_MSG(session, (ret == WT_NOTFOUND) ? ENOENT : ret,
"Can't create '%s' for non-existent table '%.*s'",
name, (int)tlen, tablename);
/* Make sure the column group is referenced from the table. */
if (cgname != NULL && (ret =
__wt_config_subgets(session, &table->cgconf, cgname, &cval)) != 0)
WT_ERR_MSG(session, EINVAL,
"Column group '%s' not found in table '%.*s'",
cgname, (int)tlen, tablename);
/* Find the first NULL entry in the cfg stack. */
for (cfgp = &cfg[1]; *cfgp; cfgp++)
;
/* Add the source to the colgroup config before collapsing. */
if (__wt_config_getones(
session, config, "source", &cval) == 0 && cval.len != 0) {
WT_ERR(__wt_buf_fmt(
session, &namebuf, "%.*s", (int)cval.len, cval.str));
source = namebuf.data;
} else {
WT_ERR(__wt_schema_colgroup_source(
session, table, cgname, config, &namebuf));
source = namebuf.data;
WT_ERR(__wt_buf_fmt(
session, &confbuf, "source=\"%s\"", source));
*cfgp++ = confbuf.data;
}
/* Calculate the key/value formats: these go into the source config. */
WT_ERR(__wt_buf_fmt(session, &fmt, "key_format=%s", table->key_format));
if (cgname == NULL)
WT_ERR(__wt_buf_catfmt
(session, &fmt, ",value_format=%s", table->value_format));
else {
if (__wt_config_getones(session, config, "columns", &cval) != 0)
WT_ERR_MSG(session, EINVAL,
"No 'columns' configuration for '%s'", name);
WT_ERR(__wt_buf_catfmt(session, &fmt, ",value_format="));
WT_ERR(__wt_struct_reformat(session,
table, cval.str, cval.len, NULL, 1, &fmt));
}
sourcecfg[1] = fmt.data;
WT_ERR(__wt_config_concat(session, sourcecfg, &sourceconf));
WT_ERR(__wt_schema_create(session, source, sourceconf));
WT_ERR(__wt_config_collapse(session, cfg, &cgconf));
if ((ret = __wt_metadata_insert(session, name, cgconf)) != 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;
}
WT_ERR(__wt_schema_open_colgroups(session, table));
err: __wt_free(session, cgconf);
__wt_free(session, sourceconf);
__wt_free(session, oldconf);
__wt_buf_free(session, &confbuf);
__wt_buf_free(session, &fmt);
__wt_buf_free(session, &namebuf);
__wt_schema_release_table(session, table);
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);
}
/*
* __create_index --
* Create an index.
*/
static int
__create_index(WT_SESSION_IMPL *session,
const char *name, bool 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, *idxname, *tablename;
char *sourceconf, *idxconf;
size_t tlen;
bool have_extractor;
u_int i, npublic_cols;
idxconf = sourceconf = NULL;
WT_CLEAR(confbuf);
WT_CLEAR(fmt);
WT_CLEAR(extra_cols);
WT_CLEAR(namebuf);
have_extractor = false;
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, true, &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 = true;
/* 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, false, &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_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);
}
