/*
* __drop_index --
* WT_SESSION::drop for a colgroup.
*/
static int
__drop_index(
WT_SESSION_IMPL *session, const char *uri, int force, const char *cfg[])
{
WT_BTREE *btree;
WT_TABLE *table;
const char *idxname, *tablename;
size_t tlen;
int i, ret;
tablename = uri;
if (!WT_PREFIX_SKIP(tablename, "index:") ||
(idxname = strchr(tablename, ':')) == NULL)
return (EINVAL);
tlen = (size_t)(idxname - tablename);
++idxname;
/*
* Try to get the btree handle. Ideally, we would use an exclusive
* lock here to prevent access to the table while we are dropping it,
* but conflicts with the exclusive lock taken by
* __wt_session_close_any_open_btree. If two threads race dropping
* the same object, it will be caught there.
*
* If we can't get a tree, try to remove it from the schema table.
*/
if ((ret = __wt_schema_get_btree(
session, uri, strlen(uri), cfg, WT_BTREE_NO_LOCK)) != 0) {
(void)__wt_schema_table_remove(session, uri);
return (ret);
}
btree = session->btree;
/* If we can get the table, detach the index from it. */
if ((ret = __wt_schema_get_table(
session, tablename, tlen, &table)) == 0 &&
(ret = __wt_schema_open_index(
session, table, idxname, strlen(idxname))) == 0) {
for (i = 0; i < table->nindices; i++)
if (table->index[i] == btree) {
table->index[i] = NULL;
table->idx_complete = 0;
}
} else if (ret != WT_NOTFOUND)
WT_TRET(ret);
WT_TRET(__drop_tree(session, btree, force));
return (ret);
}
/*
* __wt_schema_get_index --
* Find an index by URI.
*/
int
__wt_schema_get_index(WT_SESSION_IMPL *session,
const char *uri, bool quiet, WT_TABLE **tablep, WT_INDEX **indexp)
{
WT_DECL_RET;
WT_INDEX *idx;
WT_TABLE *table;
const char *tablename, *tend;
u_int i;
*indexp = NULL;
tablename = uri;
if (!WT_PREFIX_SKIP(tablename, "index:") ||
(tend = strchr(tablename, ':')) == NULL)
return (__wt_bad_object_type(session, uri));
WT_RET(__wt_schema_get_table(session,
tablename, WT_PTRDIFF(tend, tablename), false, &table));
/* Try to find the index in the table. */
for (i = 0; i < table->nindices; i++) {
idx = table->indices[i];
if (idx != NULL && strcmp(idx->name, uri) == 0) {
if (tablep != NULL)
*tablep = table;
else
__wt_schema_release_table(session, table);
*indexp = idx;
return (0);
}
}
/* Otherwise, open it. */
WT_ERR(__wt_schema_open_index(
session, table, tend + 1, strlen(tend + 1), indexp));
if (tablep != NULL)
*tablep = table;
err: __wt_schema_release_table(session, table);
WT_RET(ret);
if (*indexp != NULL)
return (0);
if (quiet)
WT_RET(ENOENT);
WT_RET_MSG(session, ENOENT, "%s not found in table", uri);
}
/*
* __drop_table --
* WT_SESSION::drop for a table.
*/
static int
__drop_table(WT_SESSION_IMPL *session, const char *uri, int force)
{
WT_BTREE *btree;
WT_TABLE *table;
int i, ret;
const char *name;
ret = 0;
name = uri;
(void)WT_PREFIX_SKIP(name, "table:");
WT_ERR(__wt_schema_get_table(session, name, strlen(name), &table));
/* Drop the column groups. */
for (i = 0; i < WT_COLGROUPS(table); i++) {
if ((btree = table->colgroup[i]) == NULL)
continue;
table->colgroup[i] = NULL;
WT_TRET(__drop_tree(session, btree, force));
}
/* Drop the indices. */
WT_TRET(__wt_schema_open_index(session, table, NULL, 0));
for (i = 0; i < table->nindices; i++) {
btree = table->index[i];
table->index[i] = NULL;
WT_TRET(__drop_tree(session, btree, force));
}
WT_TRET(__wt_schema_remove_table(session, table));
/* Remove the schema table entry (ignore missing items). */
WT_TRET(__wt_schema_table_remove(session, uri));
err: if (force && ret == WT_NOTFOUND)
ret = 0;
return (ret);
}
/*
* __rename_table --
* WT_SESSION::rename for a table.
*/
static int
__rename_table(
WT_SESSION_IMPL *session, const char *oldname, const char *newname)
{
WT_DECL_RET;
WT_ITEM *buf;
WT_TABLE *table;
int i;
const char *value;
buf = NULL;
WT_RET(
__wt_schema_get_table(session, oldname, strlen(oldname), &table));
/* Rename the column groups. */
for (i = 0; i < WT_COLGROUPS(table); i++)
WT_RET(__rename_tree(session, table->cg_name[i], newname));
/* Rename the indices. */
WT_RET(__wt_schema_open_index(session, table, NULL, 0));
for (i = 0; i < table->nindices; i++)
WT_RET(__rename_tree(session, table->idx_name[i], newname));
WT_RET(__wt_schema_remove_table(session, table));
/* Rename the table. */
WT_ERR(__wt_scr_alloc(session, 0, &buf));
WT_ERR(__wt_buf_fmt(session, buf, "table:%s", oldname));
WT_ERR(__wt_metadata_read(session, buf->data, &value));
WT_ERR(__wt_metadata_remove(session, buf->data));
WT_ERR(__wt_buf_fmt(session, buf, "table:%s", newname));
WT_ERR(__wt_metadata_insert(session, buf->data, value));
err: __wt_scr_free(&buf);
return (ret);
}
/*
* __wt_schema_open_indices --
* Open the indices for a table.
*/
int
__wt_schema_open_indices(WT_SESSION_IMPL *session, WT_TABLE *table)
{
return (__wt_schema_open_index(session, table, NULL, 0, NULL));
}
/*
* __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);
}
/*
* __wt_curindex_open --
* WT_SESSION->open_cursor method for index cursors.
*/
int
__wt_curindex_open(WT_SESSION_IMPL *session,
const char *uri, WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CURSOR_STATIC_INIT(iface,
__wt_cursor_get_key, /* get-key */
__curindex_get_value, /* get-value */
__wt_cursor_set_key, /* set-key */
__curindex_set_value, /* set-value */
__curindex_compare, /* compare */
__wt_cursor_equals, /* equals */
__curindex_next, /* next */
__curindex_prev, /* prev */
__curindex_reset, /* reset */
__curindex_search, /* search */
__curindex_search_near, /* search-near */
__wt_cursor_notsup, /* insert */
__wt_cursor_notsup, /* update */
__wt_cursor_notsup, /* remove */
__wt_cursor_reconfigure_notsup, /* reconfigure */
__curindex_close); /* close */
WT_CURSOR_INDEX *cindex;
WT_CURSOR *cursor;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
WT_INDEX *idx;
WT_TABLE *table;
const char *columns, *idxname, *tablename;
size_t namesize;
tablename = uri;
if (!WT_PREFIX_SKIP(tablename, "index:") ||
(idxname = strchr(tablename, ':')) == NULL)
WT_RET_MSG(session, EINVAL, "Invalid cursor URI: '%s'", uri);
namesize = (size_t)(idxname - tablename);
++idxname;
if ((ret = __wt_schema_get_table(session,
tablename, namesize, false, &table)) != 0) {
if (ret == WT_NOTFOUND)
WT_RET_MSG(session, EINVAL,
"Cannot open cursor '%s' on unknown table", uri);
return (ret);
}
columns = strchr(idxname, '(');
if (columns == NULL)
namesize = strlen(idxname);
else
namesize = (size_t)(columns - idxname);
if ((ret = __wt_schema_open_index(
session, table, idxname, namesize, &idx)) != 0) {
__wt_schema_release_table(session, table);
return (ret);
}
WT_RET(__wt_calloc_one(session, &cindex));
cursor = &cindex->iface;
*cursor = iface;
cursor->session = &session->iface;
cindex->table = table;
cindex->index = idx;
cindex->key_plan = idx->key_plan;
cindex->value_plan = idx->value_plan;
cursor->internal_uri = idx->name;
cursor->key_format = idx->idxkey_format;
cursor->value_format = table->value_format;
/*
* XXX
* A very odd corner case is an index with a recno key.
* The only way to get here is by creating an index on a column store
* using only the primary's recno as the index key. Disallow that for
* now.
*/
if (WT_CURSOR_RECNO(cursor))
WT_ERR_MSG(session, WT_ERROR,
"Column store indexes based on a record number primary "
"key are not supported");
/* Handle projections. */
if (columns != NULL) {
WT_ERR(__wt_scr_alloc(session, 0, &tmp));
WT_ERR(__wt_struct_reformat(session, table,
columns, strlen(columns), NULL, false, tmp));
WT_ERR(__wt_strndup(
session, tmp->data, tmp->size, &cursor->value_format));
WT_ERR(__wt_buf_init(session, tmp, 0));
WT_ERR(__wt_struct_plan(session, table,
columns, strlen(columns), false, tmp));
WT_ERR(__wt_strndup(
session, tmp->data, tmp->size, &cindex->value_plan));
}
WT_ERR(__wt_cursor_init(
cursor, cursor->internal_uri, owner, cfg, cursorp));
WT_ERR(__wt_open_cursor(
session, idx->source, cursor, cfg, &cindex->child));
/* Open the column groups needed for this index cursor. */
WT_ERR(__curindex_open_colgroups(session, cindex, cfg));
if (F_ISSET(cursor, WT_CURSTD_DUMP_JSON))
__wt_json_column_init(
cursor, table->key_format, &idx->colconf, &table->colconf);
if (0) {
err: WT_TRET(__curindex_close(cursor));
*cursorp = NULL;
}
__wt_scr_free(session, &tmp);
return (ret);
}
