/*
* __drop_table --
* WT_SESSION::drop for a table.
*/
static int
__drop_table(WT_SESSION_IMPL *session, const char *uri, const char *cfg[])
{
WT_COLGROUP *colgroup;
WT_DECL_RET;
WT_INDEX *idx;
WT_TABLE *table;
const char *name;
u_int i;
name = uri;
(void)WT_PREFIX_SKIP(name, "table:");
table = NULL;
WT_ERR(__wt_schema_get_table(
session, name, strlen(name), true, &table));
/* Drop the column groups. */
for (i = 0; i < WT_COLGROUPS(table); i++) {
if ((colgroup = table->cgroups[i]) == NULL)
continue;
/*
* Drop the column group before updating the metadata to avoid
* the metadata for the table becoming inconsistent if we can't
* get exclusive access.
*/
WT_ERR(__wt_schema_drop(session, colgroup->source, cfg));
WT_ERR(__wt_metadata_remove(session, colgroup->name));
}
/* Drop the indices. */
WT_ERR(__wt_schema_open_indices(session, table));
for (i = 0; i < table->nindices; i++) {
if ((idx = table->indices[i]) == NULL)
continue;
/*
* Drop the column group before updating the metadata to avoid
* the metadata for the table becoming inconsistent if we can't
* get exclusive access.
*/
WT_ERR(__wt_schema_drop(session, idx->source, cfg));
WT_ERR(__wt_metadata_remove(session, idx->name));
}
WT_ERR(__wt_schema_remove_table(session, table));
table = NULL;
/* Remove the metadata entry (ignore missing items). */
WT_ERR(__wt_metadata_remove(session, uri));
err:
if (table != NULL)
__wt_schema_release_table(session, table);
return (ret);
}
/*
* __wt_lsm_tree_drop --
* Drop an LSM tree.
*/
int
__wt_lsm_tree_drop(
WT_SESSION_IMPL *session, const char *name, const char *cfg[])
{
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_TREE *lsm_tree;
u_int i;
int locked;
locked = 0;
/* Get the LSM tree. */
WT_RET(__wt_lsm_tree_get(session, name, 1, &lsm_tree));
/* Shut down the LSM worker. */
WT_ERR(__lsm_tree_close(session, lsm_tree));
/* Prevent any new opens. */
WT_ERR(__wt_try_writelock(session, lsm_tree->rwlock));
locked = 1;
/* Drop the chunks. */
for (i = 0; i < lsm_tree->nchunks; i++) {
chunk = lsm_tree->chunk[i];
WT_ERR(__wt_schema_drop(session, chunk->uri, cfg));
if (F_ISSET(chunk, WT_LSM_CHUNK_BLOOM))
WT_ERR(
__wt_schema_drop(session, chunk->bloom_uri, cfg));
}
/* Drop any chunks on the obsolete list. */
for (i = 0; i < lsm_tree->nold_chunks; i++) {
if ((chunk = lsm_tree->old_chunks[i]) == NULL)
continue;
WT_ERR(__wt_schema_drop(session, chunk->uri, cfg));
if (F_ISSET(chunk, WT_LSM_CHUNK_BLOOM))
WT_ERR(
__wt_schema_drop(session, chunk->bloom_uri, cfg));
}
ret = __wt_rwunlock(session, lsm_tree->rwlock);
locked = 0;
if (ret == 0)
ret = __wt_metadata_remove(session, name);
err: if (locked)
WT_TRET(__wt_rwunlock(session, lsm_tree->rwlock));
WT_TRET(__lsm_tree_discard(session, lsm_tree));
return (ret);
}
/*
* __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));
}
/*
* __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));
}
/*
* __lsm_drop_file --
* Helper function to drop part of an LSM tree.
*/
static int
__lsm_drop_file(WT_SESSION_IMPL *session, const char *uri)
{
WT_DECL_RET;
const char *drop_cfg[] = { WT_CONFIG_BASE(
session, WT_SESSION_drop), "remove_files=false", NULL };
/*
* We need to grab the schema lock to drop the file, so first try to
* make sure there is minimal work to freeing space in the cache. Only
* bother trying to discard the checkpoint handle: the in-memory handle
* should have been closed already.
*
* This will fail with EBUSY if the file is still in use.
*/
WT_RET(__lsm_discard_handle(session, uri, WT_CHECKPOINT));
/*
* Take the schema lock for the drop operation. Since __wt_schema_drop
* results in the hot backup lock being taken when it updates the
* metadata (which would be too late to prevent our drop).
*/
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_schema_drop(session, uri, drop_cfg));
if (ret == 0)
ret = __wt_remove(session, uri + strlen("file:"));
WT_RET(__wt_verbose(session, WT_VERB_LSM, "Dropped %s", uri));
if (ret == EBUSY || ret == ENOENT)
WT_RET(__wt_verbose(session, WT_VERB_LSM,
"LSM worker drop of %s failed with %d", uri, ret));
return (ret);
}
/*
* __wt_lsm_tree_truncate --
* Truncate an LSM tree.
*/
int
__wt_lsm_tree_truncate(
WT_SESSION_IMPL *session, const char *name, const char *cfg[])
{
WT_DECL_RET;
WT_LSM_CHUNK *chunk;
WT_LSM_TREE *lsm_tree;
int locked;
WT_UNUSED(cfg);
chunk = NULL;
locked = 0;
/* Get the LSM tree. */
WT_RET(__wt_lsm_tree_get(session, name, 1, &lsm_tree));
/* Shut down the LSM worker. */
WT_RET(__lsm_tree_close(session, lsm_tree));
/* Prevent any new opens. */
WT_RET(__wt_lsm_tree_lock(session, lsm_tree, 1));
locked = 1;
/* Create the new chunk. */
WT_ERR(__wt_calloc_def(session, 1, &chunk));
chunk->id = WT_ATOMIC_ADD(lsm_tree->last, 1);
WT_ERR(__wt_lsm_tree_setup_chunk(session, lsm_tree, chunk));
/* Mark all chunks old. */
WT_ERR(__wt_lsm_merge_update_tree(
session, lsm_tree, 0, lsm_tree->nchunks, chunk));
WT_ERR(__wt_lsm_meta_write(session, lsm_tree));
WT_ERR(__lsm_tree_start_worker(session, lsm_tree));
locked = 0;
WT_ERR(__wt_lsm_tree_unlock(session, lsm_tree));
__wt_lsm_tree_release(session, lsm_tree);
err: if (locked)
WT_TRET(__wt_lsm_tree_unlock(session, lsm_tree));
if (ret != 0) {
if (chunk != NULL) {
(void)__wt_schema_drop(session, chunk->uri, NULL);
__wt_free(session, chunk);
}
/*
* Discard the LSM tree structure on error. This will force the
* LSM tree to be re-opened the next time it is accessed and
* the last good version of the metadata will be used, resulting
* in a valid (not truncated) tree.
*/
WT_TRET(__lsm_tree_discard(session, lsm_tree));
}
return (ret);
}
/*
* __session_drop --
* WT_SESSION->drop method.
*/
static int
__session_drop(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, drop, config, cfg);
ret = __wt_schema_drop(session, name, cfg);
err:
API_END_NOTFOUND_MAP(session, ret);
}
/*
* __drop_index --
* WT_SESSION::drop for an index.
*/
static int
__drop_index(
WT_SESSION_IMPL *session, const char *uri, bool force, const char *cfg[])
{
WT_DECL_RET;
WT_INDEX *idx;
/* If we can get the index, detach it from the table. */
if ((ret = __wt_schema_get_index(session, uri, true, force, &idx)) == 0)
WT_TRET(__wt_schema_drop(session, idx->source, cfg));
WT_TRET(__wt_metadata_remove(session, uri));
return (ret);
}
/*
* __session_drop --
* WT_SESSION->drop method.
*/
static int
__session_drop(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, drop, config, cfg);
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_schema_drop(session, uri, cfg));
err: /* Note: drop operations cannot be unrolled (yet?). */
API_END_NOTFOUND_MAP(session, ret);
}
/*
* __drop_index --
* WT_SESSION::drop for a colgroup.
*/
static int
__drop_index(
WT_SESSION_IMPL *session, const char *uri, bool force, const char *cfg[])
{
WT_INDEX *idx;
WT_DECL_RET;
WT_TABLE *table;
/* If we can get the colgroup, detach it from the table. */
if ((ret = __wt_schema_get_index(
session, uri, force, &table, &idx)) == 0) {
table->idx_complete = false;
WT_TRET(__wt_schema_drop(session, idx->source, cfg));
}
WT_TRET(__wt_metadata_remove(session, uri));
return (ret);
}
/*
* __drop_colgroup --
* WT_SESSION::drop for a colgroup.
*/
static int
__drop_colgroup(
WT_SESSION_IMPL *session, const char *uri, const char *cfg[])
{
WT_COLGROUP *colgroup;
WT_DECL_RET;
WT_TABLE *table;
/* If we can get the colgroup, detach it from the table. */
if ((ret = __wt_schema_get_colgroup(
session, uri, &table, &colgroup)) == 0) {
table->cg_complete = 0;
WT_TRET(__wt_schema_drop(session, colgroup->source, cfg));
}
WT_TRET(__wt_metadata_remove(session, uri));
return (ret);
}
/*
* __wt_las_create --
* Initialize the database's lookaside store.
*/
int
__wt_las_create(WT_SESSION_IMPL *session)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
uint32_t session_flags;
const char *drop_cfg[] = {
WT_CONFIG_BASE(session, WT_SESSION_drop), "force=true", NULL };
conn = S2C(session);
/* Read-only and in-memory configurations don't need the LAS table. */
if (F_ISSET(conn, WT_CONN_IN_MEMORY | WT_CONN_READONLY))
return (0);
/*
* Done at startup: we cannot do it on demand because we require the
* schema lock to create and drop the table, and it may not always be
* available.
*
* Discard any previous incarnation of the table.
*/
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_schema_drop(session, WT_LAS_URI, drop_cfg));
WT_RET(ret);
/* Re-create the table. */
WT_RET(__wt_session_create(session, WT_LAS_URI, WT_LAS_FORMAT));
/*
* Open a shared internal session used to access the lookaside table.
* This session should never be tapped for eviction.
*/
session_flags = WT_SESSION_LOOKASIDE_CURSOR | WT_SESSION_NO_EVICTION;
WT_RET(__wt_open_internal_session(
conn, "lookaside table", true, session_flags, &conn->las_session));
/* Flag that the lookaside table has been created. */
F_SET(conn, WT_CONN_LAS_OPEN);
return (0);
}
/*
* __drop_colgroup --
* WT_SESSION::drop for a colgroup.
*/
static int
__drop_colgroup(
WT_SESSION_IMPL *session, const char *uri, bool force, const char *cfg[])
{
WT_COLGROUP *colgroup;
WT_DECL_RET;
WT_TABLE *table;
WT_ASSERT(session, F_ISSET(session, WT_SESSION_LOCKED_TABLE_WRITE));
/* If we can get the colgroup, detach it from the table. */
if ((ret = __wt_schema_get_colgroup(
session, uri, force, &table, &colgroup)) == 0) {
WT_TRET(__wt_schema_drop(session, colgroup->source, cfg));
if (ret == 0)
table->cg_complete = false;
}
WT_TRET(__wt_metadata_remove(session, uri));
return (ret);
}
/*
* __wt_lsm_merge --
* Merge a set of chunks of an LSM tree.
*/
int
__wt_lsm_merge(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree, u_int id)
{
WT_BLOOM *bloom;
WT_CURSOR *dest, *src;
WT_DECL_RET;
WT_ITEM key, value;
WT_LSM_CHUNK *chunk;
uint32_t generation;
uint64_t insert_count, record_count;
u_int dest_id, end_chunk, i, nchunks, start_chunk, start_id, verb;
int tret;
bool created_chunk, create_bloom, locked, in_sync;
const char *cfg[3];
const char *drop_cfg[] =
{ WT_CONFIG_BASE(session, WT_SESSION_drop), "force", NULL };
bloom = NULL;
chunk = NULL;
dest = src = NULL;
start_id = 0;
created_chunk = create_bloom = locked = in_sync = false;
/* Fast path if it's obvious no merges could be done. */
if (lsm_tree->nchunks < lsm_tree->merge_min &&
lsm_tree->merge_aggressiveness < WT_LSM_AGGRESSIVE_THRESHOLD)
return (WT_NOTFOUND);
/*
* Use the lsm_tree lock to read the chunks (so no switches occur), but
* avoid holding it while the merge is in progress: that may take a
* long time.
*/
WT_RET(__wt_lsm_tree_writelock(session, lsm_tree));
locked = true;
WT_ERR(__lsm_merge_span(session,
lsm_tree, id, &start_chunk, &end_chunk, &record_count));
nchunks = (end_chunk + 1) - start_chunk;
WT_ASSERT(session, nchunks > 0);
start_id = lsm_tree->chunk[start_chunk]->id;
/* Find the merge generation. */
for (generation = 0, i = 0; i < nchunks; i++)
generation = WT_MAX(generation,
lsm_tree->chunk[start_chunk + i]->generation + 1);
WT_ERR(__wt_lsm_tree_writeunlock(session, lsm_tree));
locked = false;
/* Allocate an ID for the merge. */
dest_id = __wt_atomic_add32(&lsm_tree->last, 1);
/*
* We only want to do the chunk loop if we're running with verbose,
* so we wrap these statements in the conditional. Avoid the loop
* in the normal path.
*/
if (WT_VERBOSE_ISSET(session, WT_VERB_LSM)) {
WT_ERR(__wt_verbose(session, WT_VERB_LSM,
"Merging %s chunks %u-%u into %u (%" PRIu64 " records)"
", generation %" PRIu32,
lsm_tree->name,
start_chunk, end_chunk, dest_id, record_count, generation));
for (verb = start_chunk; verb <= end_chunk; verb++)
WT_ERR(__wt_verbose(session, WT_VERB_LSM,
"Merging %s: Chunk[%u] id %u, gen: %" PRIu32
", size: %" PRIu64 ", records: %" PRIu64,
lsm_tree->name, verb, lsm_tree->chunk[verb]->id,
lsm_tree->chunk[verb]->generation,
lsm_tree->chunk[verb]->size,
lsm_tree->chunk[verb]->count));
}
WT_ERR(__wt_calloc_one(session, &chunk));
created_chunk = true;
chunk->id = dest_id;
if (FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_MERGED) &&
(FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_OLDEST) ||
start_chunk > 0) && record_count > 0)
create_bloom = true;
/*
* Special setup for the merge cursor:
* first, reset to open the dependent cursors;
* then restrict the cursor to a specific number of chunks;
* then set MERGE so the cursor doesn't track updates to the tree.
*/
WT_ERR(__wt_open_cursor(session, lsm_tree->name, NULL, NULL, &src));
F_SET(src, WT_CURSTD_RAW);
WT_ERR(__wt_clsm_init_merge(src, start_chunk, start_id, nchunks));
WT_WITH_SCHEMA_LOCK(session,
ret = __wt_lsm_tree_setup_chunk(session, lsm_tree, chunk));
WT_ERR(ret);
if (create_bloom) {
WT_ERR(__wt_lsm_tree_setup_bloom(session, lsm_tree, chunk));
WT_ERR(__wt_bloom_create(session, chunk->bloom_uri,
lsm_tree->bloom_config,
record_count, lsm_tree->bloom_bit_count,
lsm_tree->bloom_hash_count, &bloom));
}
/* Discard pages we read as soon as we're done with them. */
F_SET(session, WT_SESSION_NO_CACHE);
cfg[0] = WT_CONFIG_BASE(session, WT_SESSION_open_cursor);
cfg[1] = "bulk,raw,skip_sort_check";
cfg[2] = NULL;
WT_ERR(__wt_open_cursor(session, chunk->uri, NULL, cfg, &dest));
#define LSM_MERGE_CHECK_INTERVAL WT_THOUSAND
for (insert_count = 0; (ret = src->next(src)) == 0; insert_count++) {
if (insert_count % LSM_MERGE_CHECK_INTERVAL == 0) {
if (!F_ISSET(lsm_tree, WT_LSM_TREE_ACTIVE))
WT_ERR(EINTR);
WT_STAT_FAST_CONN_INCRV(session,
lsm_rows_merged, LSM_MERGE_CHECK_INTERVAL);
++lsm_tree->merge_progressing;
}
WT_ERR(src->get_key(src, &key));
dest->set_key(dest, &key);
WT_ERR(src->get_value(src, &value));
dest->set_value(dest, &value);
WT_ERR(dest->insert(dest));
if (create_bloom)
WT_ERR(__wt_bloom_insert(bloom, &key));
}
WT_ERR_NOTFOUND_OK(ret);
WT_STAT_FAST_CONN_INCRV(session,
lsm_rows_merged, insert_count % LSM_MERGE_CHECK_INTERVAL);
++lsm_tree->merge_progressing;
WT_ERR(__wt_verbose(session, WT_VERB_LSM,
"Bloom size for %" PRIu64 " has %" PRIu64 " items inserted.",
record_count, insert_count));
/*
* Closing and syncing the files can take a while. Set the
* merge_syncing field so that compact knows it is still in
* progress.
*/
(void)__wt_atomic_add32(&lsm_tree->merge_syncing, 1);
in_sync = true;
/*
* We've successfully created the new chunk. Now install it. We need
* to ensure that the NO_CACHE flag is cleared and the bloom filter
* is closed (even if a step fails), so track errors but don't return
* until we've cleaned up.
*/
WT_TRET(src->close(src));
WT_TRET(dest->close(dest));
src = dest = NULL;
F_CLR(session, WT_SESSION_NO_CACHE);
/*
* We're doing advisory reads to fault the new trees into cache.
* Don't block if the cache is full: our next unit of work may be to
* discard some trees to free space.
*/
F_SET(session, WT_SESSION_NO_EVICTION);
if (create_bloom) {
if (ret == 0)
WT_TRET(__wt_bloom_finalize(bloom));
/*
* Read in a key to make sure the Bloom filters btree handle is
* open before it becomes visible to application threads.
* Otherwise application threads will stall while it is opened
* and internal pages are read into cache.
*/
if (ret == 0) {
WT_CLEAR(key);
WT_TRET_NOTFOUND_OK(__wt_bloom_get(bloom, &key));
}
WT_TRET(__wt_bloom_close(bloom));
bloom = NULL;
}
WT_ERR(ret);
/*
* Open a handle on the new chunk before application threads attempt
* to access it, opening it pre-loads internal pages into the file
* system cache.
*/
cfg[1] = "checkpoint=" WT_CHECKPOINT;
WT_ERR(__wt_open_cursor(session, chunk->uri, NULL, cfg, &dest));
WT_TRET(dest->close(dest));
dest = NULL;
++lsm_tree->merge_progressing;
(void)__wt_atomic_sub32(&lsm_tree->merge_syncing, 1);
in_sync = false;
WT_ERR_NOTFOUND_OK(ret);
WT_ERR(__wt_lsm_tree_set_chunk_size(session, chunk));
WT_ERR(__wt_lsm_tree_writelock(session, lsm_tree));
locked = true;
/*
* Check whether we raced with another merge, and adjust the chunk
* array offset as necessary.
*/
if (start_chunk >= lsm_tree->nchunks ||
lsm_tree->chunk[start_chunk]->id != start_id)
for (start_chunk = 0;
start_chunk < lsm_tree->nchunks;
start_chunk++)
if (lsm_tree->chunk[start_chunk]->id == start_id)
break;
/*
* It is safe to error out here - since the update can only fail
* prior to making updates to the tree.
*/
WT_ERR(__wt_lsm_merge_update_tree(
session, lsm_tree, start_chunk, nchunks, chunk));
if (create_bloom)
F_SET(chunk, WT_LSM_CHUNK_BLOOM);
chunk->count = insert_count;
chunk->generation = generation;
F_SET(chunk, WT_LSM_CHUNK_ONDISK);
/*
* We have no current way of continuing if the metadata update fails,
* so we will panic in that case. Put some effort into cleaning up
* after ourselves here - so things have a chance of shutting down.
*
* Any errors that happened after the tree was locked are
* fatal - we can't guarantee the state of the tree.
*/
if ((ret = __wt_lsm_meta_write(session, lsm_tree)) != 0)
WT_PANIC_ERR(session, ret, "Failed finalizing LSM merge");
lsm_tree->dsk_gen++;
/* Update the throttling while holding the tree lock. */
__wt_lsm_tree_throttle(session, lsm_tree, true);
/* Schedule a pass to discard old chunks */
WT_ERR(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_DROP, 0, lsm_tree));
err: if (locked)
WT_TRET(__wt_lsm_tree_writeunlock(session, lsm_tree));
if (in_sync)
(void)__wt_atomic_sub32(&lsm_tree->merge_syncing, 1);
if (src != NULL)
WT_TRET(src->close(src));
if (dest != NULL)
WT_TRET(dest->close(dest));
if (bloom != NULL)
WT_TRET(__wt_bloom_close(bloom));
if (ret != 0 && created_chunk) {
/* Drop the newly-created files on error. */
if (chunk->uri != NULL) {
WT_WITH_SCHEMA_LOCK(session, tret =
__wt_schema_drop(session, chunk->uri, drop_cfg));
WT_TRET(tret);
}
if (create_bloom && chunk->bloom_uri != NULL) {
WT_WITH_SCHEMA_LOCK(session,
tret = __wt_schema_drop(
session, chunk->bloom_uri, drop_cfg));
WT_TRET(tret);
}
__wt_free(session, chunk->bloom_uri);
__wt_free(session, chunk->uri);
__wt_free(session, chunk);
if (ret == EINTR)
WT_TRET(__wt_verbose(session, WT_VERB_LSM,
"Merge aborted due to close"));
else
WT_TRET(__wt_verbose(session, WT_VERB_LSM,
"Merge failed with %s",
__wt_strerror(session, ret, NULL, 0)));
}
F_CLR(session, WT_SESSION_NO_CACHE | WT_SESSION_NO_EVICTION);
return (ret);
}
/*
* __drop_table --
* WT_SESSION::drop for a table.
*/
static int
__drop_table(
WT_SESSION_IMPL *session, const char *uri, const char *cfg[])
{
WT_COLGROUP *colgroup;
WT_DECL_RET;
WT_INDEX *idx;
WT_TABLE *table;
u_int i;
const char *name;
bool tracked;
WT_ASSERT(session, F_ISSET(session, WT_SESSION_LOCKED_TABLE_WRITE));
name = uri;
WT_PREFIX_SKIP_REQUIRED(session, name, "table:");
table = NULL;
tracked = false;
/*
* Open the table so we can drop its column groups and indexes.
*
* Ideally we would keep the table locked exclusive across the drop,
* but for now we rely on the global table lock to prevent the table
* being reopened while it is being dropped. One issue is that the
* WT_WITHOUT_LOCKS macro can drop and reacquire the global table lock,
* avoiding deadlocks while waiting for LSM operation to quiesce.
*
* Temporarily getting the table exclusively serves the purpose
* of ensuring that cursors on the table that are already open
* must at least be closed before this call proceeds.
*/
WT_ERR(__wt_schema_get_table_uri(session, uri, true,
WT_DHANDLE_EXCLUSIVE, &table));
WT_ERR(__wt_schema_release_table(session, table));
WT_ERR(__wt_schema_get_table_uri(session, uri, true, 0, &table));
/* Drop the column groups. */
for (i = 0; i < WT_COLGROUPS(table); i++) {
if ((colgroup = table->cgroups[i]) == NULL)
continue;
/*
* Drop the column group before updating the metadata to avoid
* the metadata for the table becoming inconsistent if we can't
* get exclusive access.
*/
WT_ERR(__wt_schema_drop(session, colgroup->source, cfg));
WT_ERR(__wt_metadata_remove(session, colgroup->name));
}
/* Drop the indices. */
WT_ERR(__wt_schema_open_indices(session, table));
for (i = 0; i < table->nindices; i++) {
if ((idx = table->indices[i]) == NULL)
continue;
/*
* Drop the index before updating the metadata to avoid
* the metadata for the table becoming inconsistent if we can't
* get exclusive access.
*/
WT_ERR(__wt_schema_drop(session, idx->source, cfg));
WT_ERR(__wt_metadata_remove(session, idx->name));
}
/* Make sure the table data handle is closed. */
WT_TRET(__wt_schema_release_table(session, table));
WT_ERR(__wt_schema_get_table_uri(
session, uri, true, WT_DHANDLE_EXCLUSIVE, &table));
F_SET(&table->iface, WT_DHANDLE_DISCARD);
if (WT_META_TRACKING(session)) {
WT_WITH_DHANDLE(session, &table->iface,
ret = __wt_meta_track_handle_lock(session, false));
WT_ERR(ret);
tracked = true;
}
/* Remove the metadata entry (ignore missing items). */
WT_ERR(__wt_metadata_remove(session, uri));
err: if (table != NULL && !tracked)
WT_TRET(__wt_schema_release_table(session, table));
return (ret);
}
