/*
* __wt_schema_colgroup_source --
* Get the URI of the data source for a column group.
*/
int
__wt_schema_colgroup_source(WT_SESSION_IMPL *session,
WT_TABLE *table, const char *cgname, const char *config, WT_ITEM *buf)
{
WT_CONFIG_ITEM cval;
WT_DECL_RET;
size_t len;
const char *prefix, *suffix, *tablename;
tablename = table->name + strlen("table:");
if ((ret = __wt_config_getones(session, config, "type", &cval)) == 0 &&
!WT_STRING_MATCH("file", cval.str, cval.len)) {
prefix = cval.str;
len = cval.len;
suffix = "";
} else {
prefix = "file";
len = strlen(prefix);
suffix = ".wt";
}
WT_RET_NOTFOUND_OK(ret);
if (cgname == NULL)
WT_RET(__wt_buf_fmt(session, buf, "%.*s:%s%s",
(int)len, prefix, tablename, suffix));
else
WT_RET(__wt_buf_fmt(session, buf, "%.*s:%s_%s%s",
(int)len, prefix, tablename, cgname, suffix));
return (0);
}
/*
* __wt_strerror --
* Windows implementation of WT_SESSION.strerror and wiredtiger_strerror.
*/
const char *
__wt_strerror(WT_SESSION_IMPL *session, int error, char *errbuf, size_t errlen)
{
DWORD lasterror;
const char *p;
char buf[512];
/*
* Check for a WiredTiger or POSIX constant string, no buffer needed.
*/
if ((p = __wt_wiredtiger_error(error)) != NULL)
return (p);
/*
* When called from wiredtiger_strerror, write a passed-in buffer.
* When called from WT_SESSION.strerror, write the session's buffer.
*
* Check for Windows errors.
*/
if (error < 0) {
error = __wt_map_error_to_windows_error(error);
lasterror = FormatMessageA(
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
error,
0, /* let system choose the correct LANGID */
buf,
sizeof(buf),
NULL);
if (lasterror != 0 && session == NULL &&
snprintf(errbuf, errlen, "%s", buf) > 0)
return (errbuf);
if (lasterror != 0 && session != NULL &&
__wt_buf_fmt(session, &session->err, "%s", buf) == 0)
return (session->err.data);
}
/* Fallback to a generic message. */
if (session == NULL &&
snprintf(errbuf, errlen, "error return: %d", error) > 0)
return (errbuf);
if (session != NULL && __wt_buf_fmt(
session, &session->err, "error return: %d", error) == 0)
return (session->err.data);
/* Defeated. */
return ("Unable to return error string");
}
/*
* __wt_schema_colgroup_name --
* Get the URI for a column group. This is used for metadata lookups.
* The only complexity here is that simple tables (with a single column
* group) use a simpler naming scheme.
*/
int
__wt_schema_colgroup_name(WT_SESSION_IMPL *session,
WT_TABLE *table, const char *cgname, size_t len, WT_ITEM *buf)
{
const char *tablename;
tablename = table->name;
(void)WT_PREFIX_SKIP(tablename, "table:");
return ((table->ncolgroups == 0) ?
__wt_buf_fmt(session, buf, "colgroup:%s", tablename) :
__wt_buf_fmt(session, buf, "colgroup:%s:%.*s",
tablename, (int)len, cgname));
}
/*
* __curstat_print_value --
* Convert statistics cursor value to printable format.
*/
static int
__curstat_print_value(WT_SESSION_IMPL *session, uint64_t v, WT_ITEM *buf)
{
if (v >= WT_BILLION)
WT_RET(__wt_buf_fmt(session, buf,
"%" PRIu64 "B (%" PRIu64 ")", v / WT_BILLION, v));
else if (v >= WT_MILLION)
WT_RET(__wt_buf_fmt(session, buf,
"%" PRIu64 "M (%" PRIu64 ")", v / WT_MILLION, v));
else
WT_RET(__wt_buf_fmt(session, buf, "%" PRIu64, v));
return (0);
}
/*
* __drop_tree --
* Drop an index or colgroup reference.
*/
static int
__drop_tree(WT_SESSION_IMPL *session, WT_BTREE *btree, int force)
{
WT_ITEM *buf;
int ret;
ret = 0;
/* Remove the schema table entry (ignore missing items). */
WT_TRET(__wt_schema_table_remove(session, btree->name));
if (force && ret == WT_NOTFOUND)
ret = 0;
/*
* Drop the file.
* __drop_file closes the WT_BTREE handle, so we copy the
* WT_BTREE->filename field to make a URI.
*/
WT_ERR(__wt_scr_alloc(session, 0, &buf));
WT_ERR(__wt_buf_fmt(session, buf, "file:%s", btree->filename));
WT_ERR(__drop_file(session, buf->data, force));
err: __wt_scr_free(&buf);
return (ret);
}
/*
* __ckpt_string --
* Return a printable string representation of a checkpoint address cookie.
*/
static int
__ckpt_string(WT_SESSION_IMPL *session,
WT_BLOCK *block, const uint8_t *addr, WT_ITEM *buf)
{
WT_BLOCK_CKPT *ci, _ci;
/* Initialize the checkpoint, crack the cookie. */
ci = &_ci;
WT_RET(__wt_block_ckpt_init(session, block, ci, "string", 0));
WT_RET(__wt_block_buffer_to_ckpt(session, block, addr, ci));
WT_RET(__wt_buf_fmt(session, buf,
"version=%d",
ci->version));
if (ci->root_offset == WT_BLOCK_INVALID_OFFSET)
WT_RET(__wt_buf_catfmt(session, buf, ", root=[Empty]"));
else
WT_RET(__wt_buf_catfmt(session, buf,
", root=[%"
PRIuMAX "-%" PRIuMAX ", %" PRIu32 ", %" PRIu32 "]",
(uintmax_t)ci->root_offset,
(uintmax_t)(ci->root_offset + ci->root_size),
ci->root_size, ci->root_cksum));
if (ci->alloc.offset == WT_BLOCK_INVALID_OFFSET)
WT_RET(__wt_buf_catfmt(session, buf, ", alloc=[Empty]"));
else
WT_RET(__wt_buf_catfmt(session, buf,
", alloc=[%"
PRIuMAX "-%" PRIuMAX ", %" PRIu32 ", %" PRIu32 "]",
(uintmax_t)ci->alloc.offset,
(uintmax_t)(ci->alloc.offset + ci->alloc.size),
ci->alloc.size, ci->alloc.cksum));
if (ci->avail.offset == WT_BLOCK_INVALID_OFFSET)
WT_RET(__wt_buf_catfmt(session, buf, ", avail=[Empty]"));
else
WT_RET(__wt_buf_catfmt(session, buf,
", avail=[%"
PRIuMAX "-%" PRIuMAX ", %" PRIu32 ", %" PRIu32 "]",
(uintmax_t)ci->avail.offset,
(uintmax_t)(ci->avail.offset + ci->avail.size),
ci->avail.size, ci->avail.cksum));
if (ci->discard.offset == WT_BLOCK_INVALID_OFFSET)
WT_RET(__wt_buf_catfmt(session, buf, ", discard=[Empty]"));
else
WT_RET(__wt_buf_catfmt(session, buf,
", discard=[%"
PRIuMAX "-%" PRIuMAX ", %" PRIu32 ", %" PRIu32 "]",
(uintmax_t)ci->discard.offset,
(uintmax_t)(ci->discard.offset + ci->discard.size),
ci->discard.size, ci->discard.cksum));
WT_RET(__wt_buf_catfmt(session, buf,
", file size=%" PRIuMAX
", write generation=%" PRIu64,
(uintmax_t)ci->file_size,
ci->write_gen));
__wt_block_ckpt_destroy(session, ci);
return (0);
}
/*
* __curdump_get_key --
* WT_CURSOR->get_key for dump cursors.
*/
static int
__curdump_get_key(WT_CURSOR *cursor, ...)
{
WT_CURSOR *child;
WT_CURSOR_DUMP *cdump;
WT_DECL_RET;
WT_ITEM item, *itemp;
WT_SESSION_IMPL *session;
uint64_t recno;
va_list ap;
cdump = (WT_CURSOR_DUMP *)cursor;
child = cdump->child;
CURSOR_API_CALL(cursor, session, get_key, NULL);
if (WT_CURSOR_RECNO(cursor) && !F_ISSET(cursor, WT_CURSTD_RAW)) {
WT_ERR(child->get_key(child, &recno));
WT_ERR(__wt_buf_fmt(session, &cursor->key, "%" PRIu64, recno));
} else {
WT_ERR(child->get_key(child, &item));
WT_ERR(__raw_to_dump(session, &item,
&cursor->key, F_ISSET(cursor, WT_CURSTD_DUMP_HEX) ? 1 : 0));
}
va_start(ap, cursor);
if (F_ISSET(cursor, WT_CURSTD_RAW)) {
itemp = va_arg(ap, WT_ITEM *);
itemp->data = cursor->key.data;
itemp->size = cursor->key.size;
} else
/*
* __wt_strerror --
* WT_SESSION.strerror and wiredtiger_strerror.
*/
const char *
__wt_strerror(WT_SESSION_IMPL *session, int error, char *errbuf, size_t errlen)
{
const char *p;
/*
* Check for a WiredTiger or POSIX constant string, no buffer needed.
*/
if ((p = __wt_wiredtiger_error(error)) != NULL)
return (p);
/*
* When called from wiredtiger_strerror, write a passed-in buffer.
* When called from WT_SESSION.strerror, write the session's buffer.
*
* Fallback to a generic message.
*/
if (session == NULL &&
__wt_snprintf(errbuf, errlen, "error return: %d", error) == 0)
return (errbuf);
if (session != NULL && __wt_buf_fmt(
session, &session->err, "error return: %d", error) == 0)
return (session->err.data);
/* Defeated. */
return ("Unable to return error string");
}
/*
* __metadata_config --
* Return the default configuration information for the metadata file.
*/
static int
__metadata_config(WT_SESSION_IMPL *session, char **metaconfp)
{
WT_DECL_ITEM(buf);
WT_DECL_RET;
const char *cfg[] = { WT_CONFIG_BASE(session, file_meta), NULL, NULL };
char *metaconf;
*metaconfp = NULL;
metaconf = NULL;
/* Create a turtle file with default values. */
WT_RET(__wt_scr_alloc(session, 0, &buf));
WT_ERR(__wt_buf_fmt(session, buf,
"key_format=S,value_format=S,id=%d,version=(major=%d,minor=%d)",
WT_METAFILE_ID,
WT_BTREE_MAJOR_VERSION_MAX, WT_BTREE_MINOR_VERSION_MAX));
cfg[1] = buf->data;
WT_ERR(__wt_config_collapse(session, cfg, &metaconf));
*metaconfp = metaconf;
if (0) {
err: __wt_free(session, metaconf);
}
__wt_scr_free(&buf);
return (ret);
}
/*
* __wt_log_filename --
* Given a log number, return a WT_ITEM of a generated log file name.
*/
int
__wt_log_filename(WT_SESSION_IMPL *session, uint32_t id, WT_ITEM *buf)
{
const char *log_path;
log_path = S2C(session)->log_path;
if (log_path != NULL && log_path[0] != '\0')
WT_RET(__wt_buf_fmt(session, buf, "%s/%s.%010" PRIu32,
log_path, WT_LOG_FILENAME, id));
else
WT_RET(__wt_buf_fmt(session, buf, "%s.%010" PRIu32,
WT_LOG_FILENAME, id));
return (0);
}
/*
* __wt_lsm_tree_chunk_name --
* Get the URI of the file for a given chunk.
*/
int
__wt_lsm_tree_chunk_name(
WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree, uint32_t id, WT_ITEM *buf)
{
WT_RET(__wt_buf_fmt(session, buf, "file:%s-%06" PRIu32 ".lsm",
lsm_tree->filename, id));
return (0);
}
/*
* __wt_meta_snaplist_set --
* Set a file's snapshot value from the WT_SNAPSHOT list.
*/
int
__wt_meta_snaplist_set(
WT_SESSION_IMPL *session, const char *name, WT_SNAPSHOT *snapbase)
{
WT_DECL_RET;
WT_ITEM *buf;
WT_SNAPSHOT *snap;
int64_t order;
const char *sep;
buf = NULL;
WT_ERR(__wt_scr_alloc(session, 0, &buf));
order = 0;
sep = "";
WT_ERR(__wt_buf_fmt(session, buf, "snapshot=("));
WT_SNAPSHOT_FOREACH(snapbase, snap) {
/* Skip deleted snapshots. */
if (F_ISSET(snap, WT_SNAP_DELETE))
continue;
/*
* Track the largest active snapshot counter: it's not really
* a generational number or an ID because we reset it to 1 if
* the snapshot we're writing is the only snapshot the file has.
* The problem we're solving is when two snapshots are taken
* quickly, the timer may not be unique and/or we can even see
* time travel on the second snapshot if we read the time
* in-between nanoseconds rolling over. All we need to know
* is the real snapshot order so we don't accidentally take the
* wrong "last" snapshot.
*/
if (snap->order > order)
order = snap->order;
if (F_ISSET(snap, WT_SNAP_ADD | WT_SNAP_UPDATE)) {
/* Convert the raw cookie to a hex string. */
WT_ERR(__wt_raw_to_hex(session,
snap->raw.data, snap->raw.size, &snap->addr));
if (F_ISSET(snap, WT_SNAP_ADD))
snap->order = order + 1;
}
WT_ERR(__wt_buf_catfmt(session, buf,
"%s%s=(addr=\"%.*s\",order=%" PRIu64
",time=%" PRIuMAX ",size=%" PRIu64 ")",
sep, snap->name,
(int)snap->addr.size, (char *)snap->addr.data,
snap->order, snap->sec, snap->snapshot_size));
sep = ",";
}
WT_ERR(__wt_buf_catfmt(session, buf, ")"));
WT_ERR(__snap_set(session, name, buf->mem));
err: __wt_scr_free(&buf);
return (ret);
}
/*
* __snapshot_string --
* Return a printable string representation of a snapshot address cookie.
*/
static int
__snapshot_string(WT_SESSION_IMPL *session,
WT_BLOCK *block, const uint8_t *addr, WT_ITEM *buf)
{
WT_BLOCK_SNAPSHOT *si, _si;
/* Initialize the snapshot, crack the cookie. */
si = &_si;
WT_RET(__wt_block_snap_init(session, block, si, "string", 0));
WT_RET(__wt_block_buffer_to_snapshot(session, block, addr, si));
WT_RET(__wt_buf_fmt(session, buf,
"version=%d",
si->version));
if (si->root_offset == WT_BLOCK_INVALID_OFFSET)
WT_RET(__wt_buf_catfmt(session, buf, ", root=[Empty]"));
else
WT_RET(__wt_buf_catfmt(session, buf,
", root=[%"
PRIuMAX "-%" PRIuMAX ", %" PRIu32 ", %" PRIu32 "]",
(uintmax_t)si->root_offset,
(uintmax_t)(si->root_offset + si->root_size),
si->root_size, si->root_cksum));
if (si->alloc.offset == WT_BLOCK_INVALID_OFFSET)
WT_RET(__wt_buf_catfmt(session, buf, ", alloc=[Empty]"));
else
WT_RET(__wt_buf_catfmt(session, buf,
", alloc=[%"
PRIuMAX "-%" PRIuMAX ", %" PRIu32 ", %" PRIu32 "]",
(uintmax_t)si->alloc.offset,
(uintmax_t)(si->alloc.offset + si->alloc.size),
si->alloc.size, si->alloc.cksum));
if (si->avail.offset == WT_BLOCK_INVALID_OFFSET)
WT_RET(__wt_buf_catfmt(session, buf, ", avail=[Empty]"));
else
WT_RET(__wt_buf_catfmt(session, buf,
", avail=[%"
PRIuMAX "-%" PRIuMAX ", %" PRIu32 ", %" PRIu32 "]",
(uintmax_t)si->avail.offset,
(uintmax_t)(si->avail.offset + si->avail.size),
si->avail.size, si->avail.cksum));
if (si->discard.offset == WT_BLOCK_INVALID_OFFSET)
WT_RET(__wt_buf_catfmt(session, buf, ", discard=[Empty]"));
else
WT_RET(__wt_buf_catfmt(session, buf,
", discard=[%"
PRIuMAX "-%" PRIuMAX ", %" PRIu32 ", %" PRIu32 "]",
(uintmax_t)si->discard.offset,
(uintmax_t)(si->discard.offset + si->discard.size),
si->discard.size, si->discard.cksum));
WT_RET(__wt_buf_catfmt(session, buf,
", file size=%" PRIuMAX
", write generation=%" PRIu64,
(uintmax_t)si->file_size,
si->write_gen));
return (0);
}
/*
* __backup_uri --
* Backup a list of objects.
*/
static int
__backup_uri(WT_SESSION_IMPL *session,
WT_CURSOR_BACKUP *cb, const char *cfg[], int *foundp, int *log_only)
{
WT_CONFIG targetconf;
WT_CONFIG_ITEM cval, k, v;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
int target_list;
const char *uri;
*foundp = 0;
*log_only = 0;
/*
* If we find a non-empty target configuration string, we have a job,
* otherwise it's not our problem.
*/
WT_RET(__wt_config_gets(session, cfg, "target", &cval));
WT_RET(__wt_config_subinit(session, &targetconf, &cval));
for (cb->list_next = 0, target_list = 0;
(ret = __wt_config_next(&targetconf, &k, &v)) == 0; ++target_list) {
/* If it is our first time through, allocate. */
if (target_list == 0) {
*foundp = 1;
WT_ERR(__wt_scr_alloc(session, 512, &tmp));
}
WT_ERR(__wt_buf_fmt(session, tmp, "%.*s", (int)k.len, k.str));
uri = tmp->data;
if (v.len != 0)
WT_ERR_MSG(session, EINVAL,
"%s: invalid backup target: URIs may need quoting",
uri);
/*
* Handle log targets. We do not need to go through the
* schema worker, just call the function to append them.
* Set log_only only if it is our only URI target.
*/
if (WT_PREFIX_MATCH(uri, "log:")) {
if (target_list == 0)
*log_only = 1;
else
*log_only = 0;
WT_ERR(__wt_backup_list_uri_append(
session, uri, NULL));
} else
WT_ERR(__wt_schema_worker(session,
uri, NULL, __wt_backup_list_uri_append, cfg, 0));
}
WT_ERR_NOTFOUND_OK(ret);
err:
__wt_scr_free(session, &tmp);
return (ret);
}
/*btree file的compact操作*/
static int __compact_file(WT_SESSION_IMPL* session, const char* uri, const char* cfg[])
{
WT_DECL_RET;
WT_DECL_ITEM(t);
WT_SESSION *wt_session;
WT_TXN *txn;
int i;
struct timespec start_time;
txn = &session->txn;
wt_session = &session->iface;
/*
* File compaction requires checkpoints, which will fail in a
* transactional context. Check now so the error message isn't
* confusing.
*/
if(session->compact->file_count != 0 && F_ISSET(txn, TXN_RUNNING))
WT_ERR_MSG(session, EINVAL, " File compaction not permitted in a transaction");
/*
* Force the checkpoint: we don't want to skip it because the work we
* need to have done is done in the underlying block manager.
*/
WT_ERR(__wt_scr_alloc(session, 128, &t));
WT_ERR(__wt_buf_fmt(session, t, "target=(\"%s\"),force=1", uri));
WT_ERR(__wt_epoch(session, &start_time));
/*
* We compact 10% of the file on each pass (but the overall size of the
* file is decreasing each time, so we're not compacting 10% of the
* original file each time). Try 100 times (which is clearly more than
* we need); quit if we make no progress and check for a timeout each
* time through the loop.
*/
for (i = 0; i < 100; ++i) {
WT_ERR(wt_session->checkpoint(wt_session, t->data));
session->compaction = 0;
WT_WITH_SCHEMA_LOCK(session, ret = __wt_schema_worker(session, uri, __wt_compact, NULL, cfg, 0));
WT_ERR(ret);
if (!session->compaction)
break;
WT_ERR(wt_session->checkpoint(wt_session, t->data));
WT_ERR(wt_session->checkpoint(wt_session, t->data));
WT_ERR(__session_compact_check_timeout(session, start_time));
}
err:
__wt_scr_free(session, &t);
}
/*
* __ckpt_server_config --
* Parse and setup the checkpoint server options.
*/
static int
__ckpt_server_config(WT_SESSION_IMPL *session, const char **cfg, int *startp)
{
WT_CONFIG_ITEM cval;
WT_CONNECTION_IMPL *conn;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
char *p;
conn = S2C(session);
/*
* The checkpoint configuration requires a wait time and/or a log
* size -- if one is not set, we're not running at all.
* Checkpoints based on log size also require logging be enabled.
*/
WT_RET(__wt_config_gets(session, cfg, "checkpoint.wait", &cval));
conn->ckpt_usecs = (long)cval.val * 1000000;
WT_RET(__wt_config_gets(session, cfg, "checkpoint.log_size", &cval));
conn->ckpt_logsize = (wt_off_t)cval.val;
__wt_log_written_reset(session);
if ((conn->ckpt_usecs == 0 && conn->ckpt_logsize == 0) ||
(conn->ckpt_logsize && conn->ckpt_usecs == 0 &&
!FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED))) {
*startp = 0;
return (0);
}
*startp = 1;
/*
* The application can specify a checkpoint name, which we ignore if
* it's our default.
*/
WT_RET(__wt_config_gets(session, cfg, "checkpoint.name", &cval));
if (cval.len != 0 &&
!WT_STRING_MATCH(WT_CHECKPOINT, cval.str, cval.len)) {
WT_RET(__wt_checkpoint_name_ok(session, cval.str, cval.len));
WT_RET(__wt_scr_alloc(session, cval.len + 20, &tmp));
WT_ERR(__wt_buf_fmt(
session, tmp, "name=%.*s", (int)cval.len, cval.str));
WT_ERR(__wt_strdup(session, tmp->data, &p));
__wt_free(session, conn->ckpt_config);
conn->ckpt_config = p;
}
err: __wt_scr_free(session, &tmp);
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_lsm_tree_chunk_name --
* Get the URI of the file for a given chunk.
*/
int
__wt_lsm_tree_chunk_name(WT_SESSION_IMPL *session,
WT_LSM_TREE *lsm_tree, uint32_t id, const char **retp)
{
WT_DECL_ITEM(tmp);
WT_DECL_RET;
WT_RET(__wt_scr_alloc(session, 0, &tmp));
WT_ERR(__wt_buf_fmt(
session, tmp, "file:%s-%06" PRIu32 ".lsm", lsm_tree->filename, id));
WT_ERR(__wt_strndup(session, tmp->data, tmp->size, retp));
err: __wt_scr_free(&tmp);
return (ret);
}
/*
* __wt_schema_get_table --
* Get the table handle for the named table.
*/
int
__wt_schema_get_table(WT_SESSION_IMPL *session,
const char *name, size_t namelen, bool ok_incomplete, uint32_t flags,
WT_TABLE **tablep)
{
WT_DECL_ITEM(namebuf);
WT_DECL_RET;
WT_RET(__wt_scr_alloc(session, namelen + 1, &namebuf));
WT_ERR(__wt_buf_fmt(
session, namebuf, "table:%.*s", (int)namelen, name));
WT_ERR(__wt_schema_get_table_uri(
session, namebuf->data, ok_incomplete, flags, tablep));
err: __wt_scr_free(session, &namebuf);
return (ret);
}
/*
* __wt_block_addr_string --
* Return a printable string representation of an address cookie.
*/
int
__wt_block_addr_string(WT_SESSION_IMPL *session,
WT_BLOCK *block, WT_ITEM *buf, const uint8_t *addr, size_t addr_size)
{
off_t offset;
uint32_t cksum, size;
WT_UNUSED(addr_size);
/* Crack the cookie. */
WT_RET(__wt_block_buffer_to_addr(block, addr, &offset, &size, &cksum));
/* Printable representation. */
WT_RET(__wt_buf_fmt(session, buf,
"[%" PRIuMAX "-%" PRIuMAX ", %" PRIu32 ", %" PRIu32 "]",
(uintmax_t)offset, (uintmax_t)offset + size, size, cksum));
return (0);
}
/*
* __backup_uri --
* Backup a list of objects.
*/
static int
__backup_uri(WT_SESSION_IMPL *session,
WT_CURSOR_BACKUP *cb, const char *cfg[], int *foundp)
{
WT_CONFIG targetconf;
WT_CONFIG_ITEM cval, k, v;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
int target_list;
const char *uri;
*foundp = target_list = 0;
/*
* If we find a non-empty target configuration string, we have a job,
* otherwise it's not our problem.
*/
WT_RET(__wt_config_gets(session, cfg, "target", &cval));
WT_RET(__wt_config_subinit(session, &targetconf, &cval));
for (cb->list_next = 0;
(ret = __wt_config_next(&targetconf, &k, &v)) == 0;) {
if (!target_list) {
target_list = *foundp = 1;
WT_ERR(__wt_scr_alloc(session, 512, &tmp));
}
WT_ERR(__wt_buf_fmt(session, tmp, "%.*s", (int)k.len, k.str));
uri = tmp->data;
if (v.len != 0)
WT_ERR_MSG(session, EINVAL,
"%s: invalid backup target: URIs may need quoting",
uri);
WT_ERR(__wt_schema_worker(
session, uri, NULL, __wt_backup_list_uri_append, cfg, 0));
}
WT_ERR_NOTFOUND_OK(ret);
err: __wt_scr_free(&tmp);
return (ret);
}
/*
* __wt_turtle_update --
* Update the turtle file.
*/
int
__wt_turtle_update(
WT_SESSION_IMPL *session, const char *key, const char *value)
{
WT_FH *fh;
WT_DECL_ITEM(buf);
WT_DECL_RET;
int vmajor, vminor, vpatch;
const char *version;
fh = NULL;
/*
* Create the turtle setup file: we currently re-write it from scratch
* every time.
*/
WT_RET(__wt_open(
session, WT_METADATA_TURTLE_SET, 1, 1, WT_FILE_TYPE_TURTLE, &fh));
version = wiredtiger_version(&vmajor, &vminor, &vpatch);
WT_ERR(__wt_scr_alloc(session, 2 * 1024, &buf));
WT_ERR(__wt_buf_fmt(session, buf,
"%s\n%s\n%s\n" "major=%d,minor=%d,patch=%d\n%s\n%s\n",
WT_METADATA_VERSION_STR, version,
WT_METADATA_VERSION, vmajor, vminor, vpatch,
key, value));
WT_ERR(__wt_write(session, fh, 0, buf->size, buf->data));
/* Flush the handle and rename the file into place. */
ret = __wt_sync_and_rename_fh(
session, &fh, WT_METADATA_TURTLE_SET, WT_METADATA_TURTLE);
/* Close any file handle left open, remove any temporary file. */
err: WT_TRET(__wt_close(session, &fh));
WT_TRET(__wt_remove_if_exists(session, WT_METADATA_TURTLE_SET));
__wt_scr_free(session, &buf);
return (ret);
}
/*
* __wt_meta_turtle_init --
* Check the turtle file and create if necessary.
*/
int
__wt_meta_turtle_init(WT_SESSION_IMPL *session, int *existp)
{
WT_DECL_RET;
WT_ITEM *buf;
int exist;
const char *metaconf;
const char *cfg[] = API_CONF_DEFAULTS(file, meta, NULL);
buf = NULL;
metaconf = NULL;
*existp = 0;
/* Discard any turtle setup file left-over from previous runs. */
WT_RET(__wt_exist(session, WT_METADATA_TURTLE_SET, &exist));
if (exist)
WT_RET(__wt_remove(session, WT_METADATA_TURTLE_SET));
/* If there's already a turtle file, we're done. */
WT_RET(__wt_exist(session, WT_METADATA_TURTLE, &exist));
if (exist) {
*existp = 1;
return (0);
}
/* Create a turtle file with default values. */
WT_ERR(__wt_scr_alloc(session, 0, &buf));
WT_ERR(__wt_buf_fmt(session, buf,
"key_format=S,value_format=S,version=(major=%d,minor=%d)",
WT_BTREE_MAJOR_VERSION, WT_BTREE_MINOR_VERSION));
cfg[1] = buf->data;
WT_ERR(__wt_config_collapse(session, cfg, &metaconf));
WT_ERR(__wt_meta_turtle_update(session, WT_METADATA_URI, metaconf));
err: __wt_free(session, metaconf);
__wt_scr_free(&buf);
return (ret);
}
/*
* __wt_optrack_record_funcid --
* Allocate and record optrack function ID.
*/
void
__wt_optrack_record_funcid(
WT_SESSION_IMPL *session, const char *func, uint16_t *func_idp)
{
static uint16_t optrack_uid = 0; /* Unique for the process lifetime. */
WT_CONNECTION_IMPL *conn;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
wt_off_t fsize;
bool locked;
conn = S2C(session);
locked = false;
WT_ERR(__wt_scr_alloc(session, strlen(func) + 32, &tmp));
__wt_spin_lock(session, &conn->optrack_map_spinlock);
locked = true;
if (*func_idp == 0) {
*func_idp = ++optrack_uid;
WT_ERR(__wt_buf_fmt(
session, tmp, "%" PRIu16 " %s\n", *func_idp, func));
WT_ERR(__wt_filesize(session, conn->optrack_map_fh, &fsize));
WT_ERR(__wt_write(session,
conn->optrack_map_fh, fsize, tmp->size, tmp->data));
}
if (0) {
err: WT_PANIC_MSG(session, ret,
"operation tracking initialization failure");
}
if (locked)
__wt_spin_unlock(session, &conn->optrack_map_spinlock);
__wt_scr_free(session, &tmp);
}
/*
* __schema_open_table --
* Open a named table (internal version).
*/
static int
__schema_open_table(WT_SESSION_IMPL *session,
const char *name, size_t namelen, bool ok_incomplete, WT_TABLE **tablep)
{
WT_CONFIG cparser;
WT_CONFIG_ITEM ckey, cval;
WT_CURSOR *cursor;
WT_DECL_ITEM(buf);
WT_DECL_RET;
WT_TABLE *table;
const char *tconfig;
char *tablename;
cursor = NULL;
table = NULL;
tablename = NULL;
WT_ASSERT(session, F_ISSET(session, WT_SESSION_LOCKED_TABLE));
WT_ERR(__wt_scr_alloc(session, 0, &buf));
WT_ERR(__wt_buf_fmt(session, buf, "table:%.*s", (int)namelen, name));
WT_ERR(__wt_strndup(session, buf->data, buf->size, &tablename));
WT_ERR(__wt_metadata_cursor(session, &cursor));
cursor->set_key(cursor, tablename);
WT_ERR(cursor->search(cursor));
WT_ERR(cursor->get_value(cursor, &tconfig));
WT_ERR(__wt_calloc_one(session, &table));
table->name = tablename;
tablename = NULL;
table->name_hash = __wt_hash_city64(name, namelen);
WT_ERR(__wt_config_getones(session, tconfig, "columns", &cval));
WT_ERR(__wt_config_getones(session, tconfig, "key_format", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len, &table->key_format));
WT_ERR(__wt_config_getones(session, tconfig, "value_format", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len, &table->value_format));
WT_ERR(__wt_strdup(session, tconfig, &table->config));
/* Point to some items in the copy to save re-parsing. */
WT_ERR(__wt_config_getones(session, table->config,
"columns", &table->colconf));
/*
* Count the number of columns: tables are "simple" if the columns
* are not named.
*/
WT_ERR(__wt_config_subinit(session, &cparser, &table->colconf));
table->is_simple = true;
while ((ret = __wt_config_next(&cparser, &ckey, &cval)) == 0)
table->is_simple = false;
if (ret != WT_NOTFOUND)
goto err;
/* Check that the columns match the key and value formats. */
if (!table->is_simple)
WT_ERR(__wt_schema_colcheck(session,
table->key_format, table->value_format, &table->colconf,
&table->nkey_columns, NULL));
WT_ERR(__wt_config_getones(session, table->config,
"colgroups", &table->cgconf));
/* Count the number of column groups. */
WT_ERR(__wt_config_subinit(session, &cparser, &table->cgconf));
table->ncolgroups = 0;
while ((ret = __wt_config_next(&cparser, &ckey, &cval)) == 0)
++table->ncolgroups;
if (ret != WT_NOTFOUND)
goto err;
if (table->ncolgroups > 0 && table->is_simple)
WT_ERR_MSG(session, EINVAL,
"%s requires a table with named columns", tablename);
WT_ERR(__wt_calloc_def(session, WT_COLGROUPS(table), &table->cgroups));
WT_ERR(__wt_schema_open_colgroups(session, table));
if (!ok_incomplete && !table->cg_complete)
WT_ERR_MSG(session, EINVAL, "'%s' cannot be used "
"until all column groups are created",
table->name);
/* Copy the schema generation into the new table. */
table->schema_gen = S2C(session)->schema_gen;
*tablep = table;
if (0) {
err: WT_TRET(__wt_schema_destroy_table(session, &table));
}
WT_TRET(__wt_metadata_cursor_release(session, &cursor));
__wt_free(session, tablename);
__wt_scr_free(session, &buf);
return (ret);
}
/*
* __schema_open_index --
* Open one or more indices for a table (internal version).
*/
static int
__schema_open_index(WT_SESSION_IMPL *session,
WT_TABLE *table, const char *idxname, size_t len, WT_INDEX **indexp)
{
WT_CURSOR *cursor;
WT_DECL_ITEM(tmp);
WT_DECL_RET;
WT_INDEX *idx;
u_int i;
int cmp;
bool match;
const char *idxconf, *name, *tablename, *uri;
/* Check if we've already done the work. */
if (idxname == NULL && table->idx_complete)
return (0);
cursor = NULL;
idx = NULL;
match = false;
/* Build a search key. */
tablename = table->name;
(void)WT_PREFIX_SKIP(tablename, "table:");
WT_ERR(__wt_scr_alloc(session, 512, &tmp));
WT_ERR(__wt_buf_fmt(session, tmp, "index:%s:", tablename));
/* Find matching indices. */
WT_ERR(__wt_metadata_cursor(session, &cursor));
cursor->set_key(cursor, tmp->data);
if ((ret = cursor->search_near(cursor, &cmp)) == 0 && cmp < 0)
ret = cursor->next(cursor);
for (i = 0; ret == 0; i++, ret = cursor->next(cursor)) {
WT_ERR(cursor->get_key(cursor, &uri));
name = uri;
if (!WT_PREFIX_SKIP(name, tmp->data))
break;
/* Is this the index we are looking for? */
match = idxname == NULL || WT_STRING_MATCH(name, idxname, len);
/*
* Ensure there is space, including if we have to make room for
* a new entry in the middle of the list.
*/
WT_ERR(__wt_realloc_def(session, &table->idx_alloc,
WT_MAX(i, table->nindices) + 1, &table->indices));
/* Keep the in-memory list in sync with the metadata. */
cmp = 0;
while (table->indices[i] != NULL &&
(cmp = strcmp(uri, table->indices[i]->name)) > 0) {
/* Index no longer exists, remove it. */
__wt_free(session, table->indices[i]);
memmove(&table->indices[i], &table->indices[i + 1],
(table->nindices - i) * sizeof(WT_INDEX *));
table->indices[--table->nindices] = NULL;
}
if (cmp < 0) {
/* Make room for a new index. */
memmove(&table->indices[i + 1], &table->indices[i],
(table->nindices - i) * sizeof(WT_INDEX *));
table->indices[i] = NULL;
++table->nindices;
}
if (!match)
continue;
if (table->indices[i] == NULL) {
WT_ERR(cursor->get_value(cursor, &idxconf));
WT_ERR(__wt_calloc_one(session, &idx));
WT_ERR(__wt_strdup(session, uri, &idx->name));
WT_ERR(__wt_strdup(session, idxconf, &idx->config));
WT_ERR(__open_index(session, table, idx));
/*
* If we're checking the creation of an index before a
* table is fully created, don't save the index: it
* will need to be reopened once the table is complete.
*/
if (!table->cg_complete) {
WT_ERR(
__wt_schema_destroy_index(session, &idx));
if (idxname != NULL)
break;
continue;
}
table->indices[i] = idx;
idx = NULL;
/*
* If the slot is bigger than anything else we've seen,
* bump the number of indices.
*/
if (i >= table->nindices)
table->nindices = i + 1;
}
/* If we were looking for a single index, we're done. */
if (indexp != NULL)
*indexp = table->indices[i];
if (idxname != NULL)
break;
}
WT_ERR_NOTFOUND_OK(ret);
if (idxname != NULL && !match)
ret = WT_NOTFOUND;
/* If we did a full pass, we won't need to do it again. */
if (idxname == NULL) {
table->nindices = i;
table->idx_complete = true;
}
err: WT_TRET(__wt_metadata_cursor_release(session, &cursor));
WT_TRET(__wt_schema_destroy_index(session, &idx));
__wt_scr_free(session, &tmp);
return (ret);
}
/*
* __rename_tree --
* Rename an index or colgroup reference.
*/
static int
__rename_tree(WT_SESSION_IMPL *session,
WT_TABLE *table, const char *newuri, const char *name, const char *cfg[])
{
WT_CONFIG_ITEM cval;
WT_DECL_ITEM(nn);
WT_DECL_ITEM(ns);
WT_DECL_ITEM(nv);
WT_DECL_ITEM(os);
WT_DECL_RET;
bool is_colgroup;
const char *newname, *olduri, *suffix;
char *value;
olduri = table->name;
value = NULL;
newname = newuri;
(void)WT_PREFIX_SKIP(newname, "table:");
/*
* Create the new data source URI and update the schema value.
*
* 'name' has the format (colgroup|index):<tablename>[:<suffix>];
* we need the suffix.
*/
is_colgroup = WT_PREFIX_MATCH(name, "colgroup:");
if (!is_colgroup && !WT_PREFIX_MATCH(name, "index:"))
WT_ERR_MSG(session, EINVAL,
"expected a 'colgroup:' or 'index:' source: '%s'", name);
suffix = strchr(name, ':');
/* An existing table should have a well formed name. */
WT_ASSERT(session, suffix != NULL);
suffix = strchr(suffix + 1, ':');
WT_ERR(__wt_scr_alloc(session, 0, &nn));
WT_ERR(__wt_buf_fmt(session, nn, "%s%s%s",
is_colgroup ? "colgroup:" : "index:",
newname,
(suffix == NULL) ? "" : suffix));
/* Skip the colon, if any. */
if (suffix != NULL)
++suffix;
/* Read the old schema value. */
WT_ERR(__wt_metadata_search(session, name, &value));
/*
* Calculate the new data source URI. Use the existing table structure
* and substitute the new name temporarily.
*/
WT_ERR(__wt_scr_alloc(session, 0, &ns));
table->name = newuri;
if (is_colgroup)
WT_ERR(__wt_schema_colgroup_source(
session, table, suffix, value, ns));
else
WT_ERR(__wt_schema_index_source(
session, table, suffix, value, ns));
if ((ret = __wt_config_getones(session, value, "source", &cval)) != 0)
WT_ERR_MSG(session, EINVAL,
"index or column group has no data source: %s", value);
/* Take a copy of the old data source. */
WT_ERR(__wt_scr_alloc(session, 0, &os));
WT_ERR(__wt_buf_fmt(session, os, "%.*s", (int)cval.len, cval.str));
/* Overwrite it with the new data source. */
WT_ERR(__wt_scr_alloc(session, 0, &nv));
WT_ERR(__wt_buf_fmt(session, nv, "%.*s%s%s",
(int)WT_PTRDIFF(cval.str, value), value,
(const char *)ns->data, cval.str + cval.len));
/*
* Do the rename before updating the metadata to avoid leaving the
* metadata inconsistent if the rename fails.
*/
WT_ERR(__wt_schema_rename(session, os->data, ns->data, cfg));
/*
* Remove the old metadata entry.
* Insert the new metadata entry.
*/
WT_ERR(__wt_metadata_remove(session, name));
WT_ERR(__wt_metadata_insert(session, nn->data, nv->data));
err: __wt_scr_free(session, &nn);
__wt_scr_free(session, &ns);
__wt_scr_free(session, &nv);
__wt_scr_free(session, &os);
__wt_free(session, value);
table->name = olduri;
return (ret);
}
/*
* __wt_meta_ckptlist_set --
* Set a file's checkpoint value from the WT_CKPT list.
*/
int
__wt_meta_ckptlist_set(WT_SESSION_IMPL *session,
const char *fname, WT_CKPT *ckptbase, WT_LSN *ckptlsn)
{
WT_CKPT *ckpt;
WT_DECL_ITEM(buf);
WT_DECL_RET;
time_t secs;
int64_t maxorder;
const char *sep;
WT_ERR(__wt_scr_alloc(session, 0, &buf));
maxorder = 0;
sep = "";
WT_ERR(__wt_buf_fmt(session, buf, "checkpoint=("));
WT_CKPT_FOREACH(ckptbase, ckpt) {
/*
* Each internal checkpoint name is appended with a generation
* to make it a unique name. We're solving two problems: when
* two checkpoints are taken quickly, the timer may not be
* unique and/or we can even see time travel on the second
* checkpoint if we snapshot the time in-between nanoseconds
* rolling over. Second, if we reset the generational counter
* when new checkpoints arrive, we could logically re-create
* specific checkpoints, racing with cursors open on those
* checkpoints. I can't think of any way to return incorrect
* results by racing with those cursors, but it's simpler not
* to worry about it.
*/
if (ckpt->order > maxorder)
maxorder = ckpt->order;
/* Skip deleted checkpoints. */
if (F_ISSET(ckpt, WT_CKPT_DELETE))
continue;
if (F_ISSET(ckpt, WT_CKPT_ADD | WT_CKPT_UPDATE)) {
/*
* We fake checkpoints for handles in the middle of a
* bulk load. If there is a checkpoint, convert the
* raw cookie to a hex string.
*/
if (ckpt->raw.size == 0)
ckpt->addr.size = 0;
else
WT_ERR(__wt_raw_to_hex(session,
ckpt->raw.data,
ckpt->raw.size, &ckpt->addr));
/* Set the order and timestamp. */
if (F_ISSET(ckpt, WT_CKPT_ADD))
ckpt->order = ++maxorder;
/*
* XXX
* Assumes a time_t fits into a uintmax_t, which isn't
* guaranteed, a time_t has to be an arithmetic type,
* but not an integral type.
*/
WT_ERR(__wt_seconds(session, &secs));
ckpt->sec = (uintmax_t)secs;
}
if (strcmp(ckpt->name, WT_CHECKPOINT) == 0)
WT_ERR(__wt_buf_catfmt(session, buf,
"%s%s.%" PRId64 "=(addr=\"%.*s\",order=%" PRIu64
",time=%" PRIuMAX ",size=%" PRIu64
",write_gen=%" PRIu64 ")",
sep, ckpt->name, ckpt->order,
(int)ckpt->addr.size, (char *)ckpt->addr.data,
ckpt->order, ckpt->sec, ckpt->ckpt_size,
ckpt->write_gen));
else
WT_ERR(__wt_buf_catfmt(session, buf,
"%s%s=(addr=\"%.*s\",order=%" PRIu64
",time=%" PRIuMAX ",size=%" PRIu64
",write_gen=%" PRIu64 ")",
sep, ckpt->name,
(int)ckpt->addr.size, (char *)ckpt->addr.data,
ckpt->order, ckpt->sec, ckpt->ckpt_size,
ckpt->write_gen));
sep = ",";
}
WT_ERR(__wt_buf_catfmt(session, buf, ")"));
if (ckptlsn != NULL)
WT_ERR(__wt_buf_catfmt(session, buf,
",checkpoint_lsn=(%" PRIu32 ",%" PRIuMAX ")",
ckptlsn->file, (uintmax_t)ckptlsn->offset));
WT_ERR(__ckpt_set(session, fname, buf->mem));
err: __wt_scr_free(&buf);
return (ret);
}
/*
* __wt_lsm_tree_create --
* Create an LSM tree structure for the given name.
*/
int
__wt_lsm_tree_create(WT_SESSION_IMPL *session,
const char *uri, int exclusive, const char *config)
{
WT_CONFIG_ITEM cval;
WT_DECL_ITEM(buf);
WT_DECL_RET;
WT_LSM_TREE *lsm_tree;
const char *cfg[] = API_CONF_DEFAULTS(session, create, config);
const char *tmpconfig;
/* If the tree is open, it already exists. */
if ((ret = __wt_lsm_tree_get(session, uri, 0, &lsm_tree)) == 0) {
__wt_lsm_tree_release(session, lsm_tree);
return (exclusive ? EEXIST : 0);
}
WT_RET_NOTFOUND_OK(ret);
/*
* If the tree has metadata, it already exists.
*
* !!!
* Use a local variable: we don't care what the existing configuration
* is, but we don't want to overwrite the real config.
*/
if (__wt_metadata_read(session, uri, &tmpconfig) == 0) {
__wt_free(session, tmpconfig);
return (exclusive ? EEXIST : 0);
}
WT_RET_NOTFOUND_OK(ret);
WT_RET(__wt_config_gets(session, cfg, "key_format", &cval));
if (WT_STRING_MATCH("r", cval.str, cval.len))
WT_RET_MSG(session, EINVAL,
"LSM trees cannot be configured as column stores");
WT_RET(__wt_calloc_def(session, 1, &lsm_tree));
WT_RET(__lsm_tree_set_name(session, lsm_tree, uri));
WT_ERR(__wt_config_gets(session, cfg, "key_format", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len,
&lsm_tree->key_format));
WT_ERR(__wt_config_gets(session, cfg, "value_format", &cval));
WT_ERR(__wt_strndup(session, cval.str, cval.len,
&lsm_tree->value_format));
WT_ERR(__wt_config_gets(session, cfg, "lsm_bloom", &cval));
FLD_SET(lsm_tree->bloom,
(cval.val == 0 ? WT_LSM_BLOOM_OFF : WT_LSM_BLOOM_MERGED));
WT_ERR(__wt_config_gets(session, cfg, "lsm_bloom_newest", &cval));
if (cval.val != 0)
FLD_SET(lsm_tree->bloom, WT_LSM_BLOOM_NEWEST);
WT_ERR(__wt_config_gets(session, cfg, "lsm_bloom_oldest", &cval));
if (cval.val != 0)
FLD_SET(lsm_tree->bloom, WT_LSM_BLOOM_OLDEST);
if (FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_OFF) &&
(FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_NEWEST) ||
FLD_ISSET(lsm_tree->bloom, WT_LSM_BLOOM_OLDEST)))
WT_ERR_MSG(session, EINVAL,
"Bloom filters can only be created on newest and oldest "
"chunks if bloom filters are enabled");
WT_ERR(__wt_config_gets(session, cfg, "lsm_bloom_config", &cval));
if (cval.type == ITEM_STRUCT) {
cval.str++;
cval.len -= 2;
}
WT_ERR(__wt_strndup(session, cval.str, cval.len,
&lsm_tree->bloom_config));
WT_ERR(__wt_config_gets(session, cfg, "lsm_bloom_bit_count", &cval));
lsm_tree->bloom_bit_count = (uint32_t)cval.val;
WT_ERR(__wt_config_gets(session, cfg, "lsm_bloom_hash_count", &cval));
lsm_tree->bloom_hash_count = (uint32_t)cval.val;
WT_ERR(__wt_config_gets(session, cfg, "lsm_chunk_size", &cval));
lsm_tree->chunk_size = (uint32_t)cval.val;
WT_ERR(__wt_config_gets(session, cfg, "lsm_merge_max", &cval));
lsm_tree->merge_max = (uint32_t)cval.val;
WT_ERR(__wt_config_gets(session, cfg, "lsm_merge_threads", &cval));
lsm_tree->merge_threads = (uint32_t)cval.val;
/* Sanity check that api_data.py is in sync with lsm.h */
WT_ASSERT(session, lsm_tree->merge_threads <= WT_LSM_MAX_WORKERS);
WT_ERR(__wt_scr_alloc(session, 0, &buf));
WT_ERR(__wt_buf_fmt(session, buf,
"%s,key_format=u,value_format=u", config));
lsm_tree->file_config = __wt_buf_steal(session, buf, NULL);
/* Create the first chunk and flush the metadata. */
WT_ERR(__wt_lsm_meta_write(session, lsm_tree));
/* Discard our partially populated handle. */
ret = __lsm_tree_discard(session, lsm_tree);
lsm_tree = NULL;
/*
* Open our new tree and add it to the handle cache. Don't discard on
* error: the returned handle is NULL on error, and the metadata
* tracking macros handle cleaning up on failure.
*/
if (ret == 0)
ret = __lsm_tree_open(session, uri, &lsm_tree);
if (ret == 0)
__wt_lsm_tree_release(session, lsm_tree);
if (0) {
err: WT_TRET(__lsm_tree_discard(session, lsm_tree));
}
__wt_scr_free(&buf);
return (ret);
}
/*
* __config_merge_scan --
* Walk a configuration string, inserting entries into the merged array.
*/
static int
__config_merge_scan(WT_SESSION_IMPL *session,
const char *key, const char *value, WT_CONFIG_MERGE *cp)
{
WT_CONFIG cparser;
WT_CONFIG_ITEM k, v;
WT_DECL_ITEM(kb);
WT_DECL_ITEM(vb);
WT_DECL_RET;
size_t len;
WT_ERR(__wt_scr_alloc(session, 0, &kb));
WT_ERR(__wt_scr_alloc(session, 0, &vb));
WT_ERR(__wt_config_init(session, &cparser, value));
while ((ret = __wt_config_next(&cparser, &k, &v)) == 0) {
if (k.type != WT_CONFIG_ITEM_STRING &&
k.type != WT_CONFIG_ITEM_ID)
WT_ERR_MSG(session, EINVAL,
"Invalid configuration key found: '%s'\n", k.str);
/* Include the quotes around string keys/values. */
if (k.type == WT_CONFIG_ITEM_STRING) {
--k.str;
k.len += 2;
}
if (v.type == WT_CONFIG_ITEM_STRING) {
--v.str;
v.len += 2;
}
/*
* !!!
* We're using a JSON quote character to separate the names we
* create for nested structures. That's not completely safe as
* it's possible to quote characters in JSON such that a quote
* character appears as a literal character in a key name. In
* a few cases, applications can create their own key namespace
* (for example, shared library extension names), and therefore
* it's possible for an application to confuse us. Error if we
* we ever see a key with a magic character.
*/
for (len = 0; len < k.len; ++len)
if (k.str[len] == SEPC)
WT_ERR_MSG(session, EINVAL,
"key %.*s contains a '%c' separator "
"character",
(int)k.len, (char *)k.str, SEPC);
/* Build the key/value strings. */
WT_ERR(__wt_buf_fmt(session,
kb, "%s%s%.*s",
key == NULL ? "" : key,
key == NULL ? "" : SEP,
(int)k.len, k.str));
WT_ERR(__wt_buf_fmt(session,
vb, "%.*s", (int)v.len, v.str));
/*
* If the value is a structure, recursively parse it.
*
* !!!
* Don't merge unless the structure has field names. WiredTiger
* stores checkpoint LSNs in the metadata file using nested
* structures without field names: "checkpoint_lsn=(1,0)", not
* "checkpoint_lsn=(file=1,offset=0)". The value type is still
* WT_CONFIG_ITEM_STRUCT, so we check for a field name in the
* value.
*/
if (v.type == WT_CONFIG_ITEM_STRUCT &&
strchr(vb->data, '=') != NULL) {
WT_ERR(__config_merge_scan(
session, kb->data, vb->data, cp));
continue;
}
/* Insert the value into the array. */
WT_ERR(__wt_realloc_def(session,
&cp->entries_allocated,
cp->entries_next + 1, &cp->entries));
WT_ERR(__wt_strndup(session,
kb->data, kb->size, &cp->entries[cp->entries_next].k));
WT_ERR(__wt_strndup(session,
vb->data, vb->size, &cp->entries[cp->entries_next].v));
cp->entries[cp->entries_next].gen = cp->entries_next;
++cp->entries_next;
}
WT_ERR_NOTFOUND_OK(ret);
err: __wt_scr_free(session, &kb);
__wt_scr_free(session, &vb);
return (ret);
}
