/*
* __wt_lsm_tree_setup_chunk --
* Initialize a chunk of an LSM tree.
*/
int
__wt_lsm_tree_setup_chunk(
WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree, WT_LSM_CHUNK *chunk)
{
const char *cfg[] =
{ WT_CONFIG_BASE(session, session_drop), "force", NULL };
int exists;
WT_RET(__wt_epoch(session, &chunk->create_ts));
WT_RET(__wt_lsm_tree_chunk_name(
session, lsm_tree, chunk->id, &chunk->uri));
/*
* If the underlying file exists, drop the chunk first - there may be
* some content hanging over from an aborted merge or checkpoint.
*
* Don't do this for the very first chunk: we are called during
* WT_SESSION::create, and doing a drop inside there does interesting
* things with handle locks and metadata tracking. It can never have
* been the result of an interrupted merge, anyway.
*/
if (chunk->id > 1) {
WT_RET(__wt_exist(
session, chunk->uri + strlen("file:"), &exists));
if (exists)
WT_RET(__wt_schema_drop(session, chunk->uri, cfg));
}
return (__wt_schema_create(session, chunk->uri, lsm_tree->file_config));
}
/*
* __wt_lsm_tree_setup_chunk --
* Initialize a chunk of an LSM tree.
*/
int
__wt_lsm_tree_setup_chunk(
WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree, WT_LSM_CHUNK *chunk)
{
WT_ITEM buf;
const char *cfg[] = API_CONF_DEFAULTS(session, drop, "force");
WT_CLEAR(buf);
WT_RET(__wt_lsm_tree_chunk_name(session, lsm_tree, chunk->id, &buf));
chunk->uri = __wt_buf_steal(session, &buf, NULL);
/*
* Drop the chunk first - there may be some content hanging over from
* an aborted merge or checkpoint.
*
* Don't do this for the very first chunk: we are called during
* WT_SESSION::create, and doing a drop inside there does interesting
* things with handle locks and metadata tracking. It can never have
* been the result of an interrupted merge, anyway.
*/
if (chunk->id > 1)
WT_RET(__wt_schema_drop(session, chunk->uri, cfg));
return (__wt_schema_create(session, chunk->uri, lsm_tree->file_config));
}
/*
* __metadata_init --
* Create the metadata file.
*/
static int
__metadata_init(WT_SESSION_IMPL *session)
{
WT_DECL_RET;
/*
* We're single-threaded, but acquire the schema lock regardless: the
* lower level code checks that it is appropriately synchronized.
*/
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_schema_create(session, WT_METAFILE_URI, NULL));
return (ret);
}
/*
* __session_create --
* WT_SESSION->create method.
*/
static int
__session_create(WT_SESSION *wt_session, const char *name, const char *config)
{
WT_SESSION_IMPL *session;
int ret;
session = (WT_SESSION_IMPL *)wt_session;
SESSION_API_CALL(session, create, config, cfg);
WT_UNUSED(cfg);
WT_ERR(__wt_schema_create(session, name, config));
err:
API_END_NOTFOUND_MAP(session, ret);
}
/*
* __session_create --
* WT_SESSION->create method.
*/
static int
__session_create(WT_SESSION *wt_session, const char *uri, const char *config)
{
WT_DECL_RET;
WT_SESSION_IMPL *session;
session = (WT_SESSION_IMPL *)wt_session;
SESSION_API_CALL(session, create, config, cfg);
WT_UNUSED(cfg);
/* Disallow objects in the WiredTiger name space. */
WT_ERR(__wt_schema_name_check(session, uri));
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_schema_create(session, uri, config));
err: API_END_NOTFOUND_MAP(session, ret);
}
/*
* wiredtiger_open --
* Main library entry point: open a new connection to a WiredTiger
* database.
*/
int
wiredtiger_open(const char *home, WT_EVENT_HANDLER *event_handler,
const char *config, WT_CONNECTION **wt_connp)
{
static WT_CONNECTION stdc = {
__conn_close,
__conn_reconfigure,
__conn_get_home,
__conn_is_new,
__conn_open_session,
__conn_load_extension,
__conn_add_data_source,
__conn_add_collator,
__conn_add_compressor,
__conn_add_extractor
};
static struct {
const char *name;
uint32_t flag;
} *ft, directio_types[] = {
{ "data", WT_DIRECTIO_DATA },
{ "log", WT_DIRECTIO_LOG },
{ NULL, 0 }
};
WT_CONFIG subconfig;
WT_CONFIG_ITEM cval, skey, sval;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_ITEM *cbuf, expath, exconfig;
WT_SESSION_IMPL *session;
const char *cfg[] =
{ __wt_confdfl_wiredtiger_open, config, NULL, NULL, NULL };
int exist;
*wt_connp = NULL;
session = NULL;
cbuf = NULL;
WT_CLEAR(expath);
WT_CLEAR(exconfig);
WT_RET(__wt_library_init());
WT_RET(__wt_calloc_def(NULL, 1, &conn));
conn->iface = stdc;
/*
* Immediately link the structure into the connection structure list:
* the only thing ever looked at on that list is the database name,
* and a NULL value is fine.
*/
__wt_spin_lock(NULL, &__wt_process.spinlock);
TAILQ_INSERT_TAIL(&__wt_process.connqh, conn, q);
__wt_spin_unlock(NULL, &__wt_process.spinlock);
session = conn->default_session = &conn->dummy_session;
session->iface.connection = &conn->iface;
session->name = "wiredtiger_open";
__wt_event_handler_set(session, event_handler);
/* Remaining basic initialization of the connection structure. */
WT_ERR(__wt_connection_init(conn));
/* Check the configuration strings. */
WT_ERR(__wt_config_check(
session, __wt_confchk_wiredtiger_open, config, 0));
/* Get the database home. */
WT_ERR(__conn_home(session, home, cfg));
/* Make sure no other thread of control already owns this database. */
WT_ERR(__conn_single(session, cfg));
/* Read the database-home configuration file. */
WT_ERR(__conn_config_file(session, cfg, &cbuf));
/* Read the environment variable configuration. */
WT_ERR(__conn_config_env(session, cfg));
WT_ERR(__wt_config_gets(session, cfg, "hazard_max", &cval));
conn->hazard_max = (uint32_t)cval.val;
WT_ERR(__wt_config_gets(session, cfg, "session_max", &cval));
conn->session_size = (uint32_t)cval.val + WT_NUM_INTERNAL_SESSIONS;
WT_ERR(__wt_config_gets(session, cfg, "lsm_merge", &cval));
if (cval.val)
F_SET(conn, WT_CONN_LSM_MERGE);
WT_ERR(__wt_config_gets(session, cfg, "sync", &cval));
if (cval.val)
F_SET(conn, WT_CONN_SYNC);
WT_ERR(__wt_config_gets(session, cfg, "transactional", &cval));
if (cval.val)
F_SET(conn, WT_CONN_TRANSACTIONAL);
/* Configure verbose flags. */
WT_ERR(__conn_verbose_config(session, cfg));
WT_ERR(__wt_conn_cache_pool_config(session, cfg));
WT_ERR(__wt_config_gets(session, cfg, "logging", &cval));
if (cval.val != 0)
WT_ERR(__wt_open(
session, WT_LOG_FILENAME, 1, 0, 0, &conn->log_fh));
/* Configure direct I/O and buffer alignment. */
WT_ERR(__wt_config_gets(session, cfg, "buffer_alignment", &cval));
if (cval.val == -1)
conn->buffer_alignment = WT_BUFFER_ALIGNMENT_DEFAULT;
else
conn->buffer_alignment = (size_t)cval.val;
#ifndef HAVE_POSIX_MEMALIGN
if (conn->buffer_alignment != 0)
WT_ERR_MSG(session, EINVAL,
"buffer_alignment requires posix_memalign");
#endif
/*
* Configuration: direct_io, mmap, statistics.
*/
WT_ERR(__wt_config_gets(session, cfg, "direct_io", &cval));
for (ft = directio_types; ft->name != NULL; ft++) {
ret = __wt_config_subgets(session, &cval, ft->name, &sval);
if (ret == 0) {
if (sval.val)
FLD_SET(conn->direct_io, ft->flag);
} else if (ret != WT_NOTFOUND)
goto err;
}
WT_ERR(__wt_config_gets(session, cfg, "mmap", &cval));
conn->mmap = cval.val == 0 ? 0 : 1;
WT_ERR(__wt_config_gets(session, cfg, "statistics", &cval));
conn->statistics = cval.val == 0 ? 0 : 1;
/* Load any extensions referenced in the config. */
WT_ERR(__wt_config_gets(session, cfg, "extensions", &cval));
WT_ERR(__wt_config_subinit(session, &subconfig, &cval));
while ((ret = __wt_config_next(&subconfig, &skey, &sval)) == 0) {
WT_ERR(__wt_buf_fmt(
session, &expath, "%.*s", (int)skey.len, skey.str));
if (sval.len > 0)
WT_ERR(__wt_buf_fmt(session, &exconfig,
"entry=%.*s\n", (int)sval.len, sval.str));
WT_ERR(conn->iface.load_extension(&conn->iface,
expath.data, (sval.len > 0) ? exconfig.data : NULL));
}
WT_ERR_NOTFOUND_OK(ret);
/*
* Open the connection; if that fails, the connection handle has been
* destroyed by the time the open function returns.
*/
if ((ret = __wt_connection_open(conn, cfg)) != 0) {
conn = NULL;
WT_ERR(ret);
}
/* Open the default session. */
WT_ERR(__wt_open_session(conn, 1, NULL, NULL, &conn->default_session));
session = conn->default_session;
/*
* Check on the turtle and metadata files, creating them if necessary
* (which avoids application threads racing to create the metadata file
* later).
*/
WT_ERR(__wt_meta_turtle_init(session, &exist));
if (!exist) {
/*
* We're single-threaded, but acquire the schema lock
* regardless: the lower level code checks that it is
* appropriately synchronized.
*/
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_schema_create(session, WT_METADATA_URI, NULL));
WT_ERR(ret);
}
WT_ERR(__wt_metadata_open(session));
/* If there's a hot-backup file, load it. */
WT_ERR(__wt_metadata_load_backup(session));
/*
* XXX LSM initialization.
* This is structured so that it could be moved to an extension.
*/
WT_ERR(__wt_lsm_init(&conn->iface, NULL));
STATIC_ASSERT(offsetof(WT_CONNECTION_IMPL, iface) == 0);
*wt_connp = &conn->iface;
/*
* Destroying the connection on error will destroy our session handle,
* cleanup using the session handle first, then discard the connection.
*/
err: if (cbuf != NULL)
__wt_buf_free(session, cbuf);
__wt_buf_free(session, &expath);
__wt_buf_free(session, &exconfig);
if (ret != 0 && conn != NULL)
WT_TRET(__wt_connection_destroy(conn));
/* Let the server threads proceed. */
if (ret == 0)
conn->connection_initialized = 1;
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);
}
/*
* __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 **cfgp, *cfg[4] =
{ WT_CONFIG_BASE(session, colgroup_meta), config, NULL, NULL };
const char *sourcecfg[] = { config, NULL, NULL };
const char *cgname, *source, *sourceconf, *tablename;
char *cgconf, *oldconf;
sourceconf = NULL;
cgconf = 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_merge(session, sourcecfg, NULL, &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);
}