/*
* __wt_schema_drop --
* Process a WT_SESSION::drop operation for all supported types.
*/
int
__wt_schema_drop(WT_SESSION_IMPL *session, const char *uri, const char *cfg[])
{
WT_CONFIG_ITEM cval;
WT_DATA_SOURCE *dsrc;
WT_DECL_RET;
bool force;
WT_RET(__wt_config_gets_def(session, cfg, "force", 0, &cval));
force = cval.val != 0;
WT_RET(__wt_meta_track_on(session));
/* Paranoia: clear any handle from our caller. */
session->dhandle = NULL;
if (WT_PREFIX_MATCH(uri, "colgroup:"))
ret = __drop_colgroup(session, uri, force, cfg);
else if (WT_PREFIX_MATCH(uri, "file:"))
ret = __drop_file(session, uri, force, cfg);
else if (WT_PREFIX_MATCH(uri, "index:"))
ret = __drop_index(session, uri, force, cfg);
else if (WT_PREFIX_MATCH(uri, "lsm:"))
ret = __wt_lsm_tree_drop(session, uri, cfg);
else if (WT_PREFIX_MATCH(uri, "table:"))
ret = __drop_table(session, uri, cfg);
else if ((dsrc = __wt_schema_get_source(session, uri)) != NULL)
ret = dsrc->drop == NULL ?
__wt_object_unsupported(session, uri) :
dsrc->drop(
dsrc, &session->iface, uri, (WT_CONFIG_ARG *)cfg);
else
ret = __wt_bad_object_type(session, uri);
/*
* Map WT_NOTFOUND to ENOENT, based on the assumption WT_NOTFOUND means
* there was no metadata entry. Map ENOENT to zero if force is set.
*/
if (ret == WT_NOTFOUND || ret == ENOENT)
ret = force ? 0 : ENOENT;
/* Bump the schema generation so that stale data is ignored. */
++S2C(session)->schema_gen;
WT_TRET(__wt_meta_track_off(session, true, ret != 0));
return (ret);
}
int
__wt_schema_drop(WT_SESSION_IMPL *session, const char *uri, const char *cfg[])
{
WT_CONFIG_ITEM cval;
WT_DATA_SOURCE *dsrc;
WT_DECL_RET;
int force;
WT_RET(__wt_config_gets_defno(session, cfg, "force", &cval));
force = (cval.val != 0);
/* Disallow drops from the WiredTiger name space. */
WT_RET(__wt_schema_name_check(session, uri));
WT_RET(__wt_meta_track_on(session));
/* Be careful to ignore any btree handle in our caller. */
WT_CLEAR_BTREE_IN_SESSION(session);
if (WT_PREFIX_MATCH(uri, "colgroup:"))
ret = __drop_colgroup(session, uri, cfg);
else if (WT_PREFIX_MATCH(uri, "file:"))
ret = __drop_file(session, uri, force, cfg);
else if (WT_PREFIX_MATCH(uri, "index:"))
ret = __drop_index(session, uri, cfg);
else if (WT_PREFIX_MATCH(uri, "table:"))
ret = __drop_table(session, uri, force, cfg);
else if ((ret = __wt_schema_get_source(session, uri, &dsrc)) == 0)
ret = dsrc->drop(dsrc, &session->iface, uri, cfg);
/*
* Map WT_NOTFOUND to ENOENT (or to 0 if "force" is set), based on the
* assumption WT_NOTFOUND means there was no metadata entry. The
* underlying drop functions should handle this case (we passed them
* the "force" value), but better safe than sorry.
*/
if (ret == WT_NOTFOUND)
ret = force ? 0 : ENOENT;
/* Bump the schema generation so that stale data is ignored. */
++S2C(session)->schema_gen;
WT_TRET(__wt_meta_track_off(session, ret != 0));
return (ret);
}
/*
* __wt_schema_rename --
* WT_SESSION::rename.
*/
int
__wt_schema_rename(WT_SESSION_IMPL *session,
const char *uri, const char *newuri, const char *cfg[])
{
WT_DATA_SOURCE *dsrc;
WT_DECL_RET;
const char *p, *t;
/* Disallow renames to/from the WiredTiger name space. */
WT_RET(__wt_schema_name_check(session, uri));
WT_RET(__wt_schema_name_check(session, newuri));
/* The target type must match the source type. */
for (p = uri, t = newuri; *p == *t && *p != ':'; ++p, ++t)
;
if (*p != ':' || *t != ':')
WT_RET_MSG(session, EINVAL,
"rename target type must match URI: %s to %s", uri, newuri);
/*
* We track rename operations, if we fail in the middle, we want to
* back it all out.
*/
WT_RET(__wt_meta_track_on(session));
if (WT_PREFIX_MATCH(uri, "file:"))
ret = __rename_file(session, uri, newuri);
else if (WT_PREFIX_MATCH(uri, "lsm:"))
ret = __wt_lsm_tree_rename(session, uri, newuri, cfg);
else if (WT_PREFIX_MATCH(uri, "table:"))
ret = __rename_table(session, uri, newuri, cfg);
else if ((ret = __wt_schema_get_source(session, uri, &dsrc)) == 0)
ret = dsrc->rename == NULL ?
__wt_object_unsupported(session, uri) :
dsrc->rename(dsrc, &session->iface,
uri, newuri, (WT_CONFIG_ARG *)cfg);
/* Bump the schema generation so that stale data is ignored. */
++S2C(session)->schema_gen;
WT_TRET(__wt_meta_track_off(session, ret != 0));
/* If we didn't find a metadata entry, map that error to ENOENT. */
return (ret == WT_NOTFOUND ? ENOENT : ret);
}
/*
* __wt_schema_rename --
* WT_SESSION::rename.
*/
int
__wt_schema_rename(WT_SESSION_IMPL *session,
const char *uri, const char *newuri, const char *cfg[])
{
WT_DATA_SOURCE *dsrc;
WT_DECL_RET;
const char *oldname, *newname;
WT_UNUSED(cfg);
/* Disallow renames to/from the WiredTiger name space. */
WT_RET(__wt_schema_name_check(session, uri));
WT_RET(__wt_schema_name_check(session, newuri));
/*
* We track rename operations, if we fail in the middle, we want to
* back it all out.
*/
WT_RET(__wt_meta_track_on(session));
oldname = uri;
newname = newuri;
if (WT_PREFIX_SKIP(oldname, "file:")) {
if (!WT_PREFIX_SKIP(newname, "file:"))
WT_RET_MSG(session, EINVAL,
"rename target type must match URI: %s to %s",
uri, newuri);
ret = __rename_file(session, uri, newuri);
} else if (WT_PREFIX_SKIP(oldname, "table:")) {
if (!WT_PREFIX_SKIP(newname, "table:"))
WT_RET_MSG(session, EINVAL,
"rename target type must match URI: %s to %s",
uri, newuri);
ret = __rename_table(session, oldname, newname);
} else if ((ret = __wt_schema_get_source(session, oldname, &dsrc)) == 0)
ret = dsrc->rename(dsrc,
&session->iface, oldname, newname, cfg[1]);
WT_TRET(__wt_meta_track_off(session, ret != 0));
/* If we didn't find a metadata entry, map that error to ENOENT. */
return (ret == WT_NOTFOUND ? ENOENT : ret);
}
/*
* __wt_schema_create --
* Process a WT_SESSION::create operation for all supported types.
*/
int
__wt_schema_create(
WT_SESSION_IMPL *session, const char *uri, const char *config)
{
WT_CONFIG_ITEM cval;
WT_DATA_SOURCE *dsrc;
WT_DECL_RET;
int exclusive;
exclusive = (
__wt_config_getones(session, config, "exclusive", &cval) == 0 &&
cval.val != 0);
/*
* We track create operations: if we fail in the middle of creating a
* complex object, we want to back it all out.
*/
WT_RET(__wt_meta_track_on(session));
if (WT_PREFIX_MATCH(uri, "colgroup:"))
ret = __create_colgroup(session, uri, exclusive, config);
else if (WT_PREFIX_MATCH(uri, "file:"))
ret = __create_file(session, uri, exclusive, config);
else if (WT_PREFIX_MATCH(uri, "lsm:"))
ret = __wt_lsm_tree_create(session, uri, exclusive, config);
else if (WT_PREFIX_MATCH(uri, "index:"))
ret = __create_index(session, uri, exclusive, config);
else if (WT_PREFIX_MATCH(uri, "table:"))
ret = __create_table(session, uri, exclusive, config);
else if ((dsrc = __wt_schema_get_source(session, uri)) != NULL)
ret = dsrc->create == NULL ?
__wt_object_unsupported(session, uri) :
__create_data_source(session, uri, config, dsrc);
else
ret = __wt_bad_object_type(session, uri);
session->dhandle = NULL;
WT_TRET(__wt_meta_track_off(session, 1, ret != 0));
return (ret);
}
/*
* __wt_lsm_checkpoint_chunk --
* Flush a single LSM chunk to disk.
*/
int
__wt_lsm_checkpoint_chunk(WT_SESSION_IMPL *session,
WT_LSM_TREE *lsm_tree, WT_LSM_CHUNK *chunk)
{
WT_DECL_RET;
WT_TXN_ISOLATION saved_isolation;
bool flush_set;
flush_set = false;
/*
* If the chunk is already checkpointed, make sure it is also evicted.
* Either way, there is no point trying to checkpoint it again.
*/
if (F_ISSET(chunk, WT_LSM_CHUNK_ONDISK) &&
!F_ISSET(chunk, WT_LSM_CHUNK_STABLE) &&
!chunk->evicted) {
WT_WITH_HANDLE_LIST_LOCK(session,
ret = __lsm_discard_handle(session, chunk->uri, NULL));
if (ret == 0)
chunk->evicted = 1;
else if (ret == EBUSY)
ret = 0;
else
WT_RET_MSG(session, ret, "discard handle");
}
if (F_ISSET(chunk, WT_LSM_CHUNK_ONDISK)) {
WT_RET(__wt_verbose(session, WT_VERB_LSM,
"LSM worker %s already on disk",
chunk->uri));
return (0);
}
/* Stop if a running transaction needs the chunk. */
__wt_txn_update_oldest(session, true);
if (chunk->switch_txn == WT_TXN_NONE ||
!__wt_txn_visible_all(session, chunk->switch_txn)) {
WT_RET(__wt_verbose(session, WT_VERB_LSM,
"LSM worker %s: running transaction, return",
chunk->uri));
return (0);
}
if (!__wt_atomic_cas8(&chunk->flushing, 0, 1))
return (0);
flush_set = true;
WT_ERR(__wt_verbose(session, WT_VERB_LSM, "LSM worker flushing %s",
chunk->uri));
/*
* Flush the file before checkpointing: this is the expensive part in
* terms of I/O.
*
* !!!
* We can wait here for checkpoints and fsyncs to complete, which can
* take a long time.
*/
if ((ret = __wt_session_get_btree(
session, chunk->uri, NULL, NULL, 0)) == 0) {
/*
* Set read-uncommitted: we have already checked that all of the
* updates in this chunk are globally visible, use the cheapest
* possible check in reconciliation.
*/
saved_isolation = session->txn.isolation;
session->txn.isolation = WT_ISO_READ_UNCOMMITTED;
ret = __wt_cache_op(session, NULL, WT_SYNC_WRITE_LEAVES);
session->txn.isolation = saved_isolation;
WT_TRET(__wt_session_release_btree(session));
}
WT_ERR(ret);
WT_ERR(__wt_verbose(session, WT_VERB_LSM, "LSM worker checkpointing %s",
chunk->uri));
/*
* Turn on metadata tracking to ensure the checkpoint gets the
* necessary handle locks.
*
* Ensure that we don't race with a running checkpoint: the checkpoint
* lock protects against us racing with an application checkpoint in
* this chunk. Don't wait for it, though: checkpoints can take a long
* time, and our checkpoint operation should be very quick.
*/
WT_ERR(__wt_meta_track_on(session));
WT_WITH_CHECKPOINT_LOCK(session, ret,
WT_WITH_SCHEMA_LOCK(session, ret,
ret = __wt_schema_worker(
session, chunk->uri, __wt_checkpoint, NULL, NULL, 0)));
WT_TRET(__wt_meta_track_off(session, false, ret != 0));
if (ret != 0)
WT_ERR_MSG(session, ret, "LSM checkpoint");
/* Now the file is written, get the chunk size. */
WT_ERR(__wt_lsm_tree_set_chunk_size(session, chunk));
/* Update the flush timestamp to help track ongoing progress. */
WT_ERR(__wt_epoch(session, &lsm_tree->last_flush_ts));
++lsm_tree->chunks_flushed;
/* Lock the tree, mark the chunk as on disk and update the metadata. */
WT_ERR(__wt_lsm_tree_writelock(session, lsm_tree));
F_SET(chunk, WT_LSM_CHUNK_ONDISK);
ret = __wt_lsm_meta_write(session, lsm_tree);
++lsm_tree->dsk_gen;
/* Update the throttle time. */
__wt_lsm_tree_throttle(session, lsm_tree, true);
WT_TRET(__wt_lsm_tree_writeunlock(session, lsm_tree));
if (ret != 0)
WT_ERR_MSG(session, ret, "LSM metadata write");
WT_PUBLISH(chunk->flushing, 0);
flush_set = false;
/*
* Clear the no-eviction flag so the primary can be evicted and
* eventually closed. Only do this once the checkpoint has succeeded:
* otherwise, accessing the leaf page during the checkpoint can trigger
* forced eviction.
*/
WT_ERR(__wt_session_get_btree(session, chunk->uri, NULL, NULL, 0));
__wt_btree_evictable(session, true);
WT_ERR(__wt_session_release_btree(session));
/* Make sure we aren't pinning a transaction ID. */
__wt_txn_release_snapshot(session);
WT_ERR(__wt_verbose(session, WT_VERB_LSM, "LSM worker checkpointed %s",
chunk->uri));
/* Schedule a bloom filter create for our newly flushed chunk. */
if (!FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_OFF))
WT_ERR(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_BLOOM, 0, lsm_tree));
else
WT_ERR(__wt_lsm_manager_push_entry(
session, WT_LSM_WORK_MERGE, 0, lsm_tree));
err: if (flush_set)
WT_PUBLISH(chunk->flushing, 0);
return (ret);
}
