summaryrefslogtreecommitdiff
path: root/src/cursor
diff options
context:
space:
mode:
Diffstat (limited to 'src/cursor')
-rw-r--r--src/cursor/cur_backup.c4
-rw-r--r--src/cursor/cur_file.c2
-rw-r--r--src/cursor/cur_index.c29
-rw-r--r--src/cursor/cur_join.c2
-rw-r--r--src/cursor/cur_json.c16
-rw-r--r--src/cursor/cur_log.c62
-rw-r--r--src/cursor/cur_table.c7
7 files changed, 55 insertions, 67 deletions
diff --git a/src/cursor/cur_backup.c b/src/cursor/cur_backup.c
index 3585082644f..456aa2e0f02 100644
--- a/src/cursor/cur_backup.c
+++ b/src/cursor/cur_backup.c
@@ -144,8 +144,8 @@ __wt_curbackup_open(WT_SESSION_IMPL *session,
* Start the backup and fill in the cursor's list. Acquire the schema
* lock, we need a consistent view when creating a copy.
*/
- WT_WITH_CHECKPOINT_LOCK(session, ret,
- WT_WITH_SCHEMA_LOCK(session, ret,
+ WT_WITH_CHECKPOINT_LOCK(session,
+ WT_WITH_SCHEMA_LOCK(session,
ret = __backup_start(session, cb, cfg)));
WT_ERR(ret);
diff --git a/src/cursor/cur_file.c b/src/cursor/cur_file.c
index 9fc466f4c76..0ec917fbf95 100644
--- a/src/cursor/cur_file.c
+++ b/src/cursor/cur_file.c
@@ -559,7 +559,7 @@ __wt_curfile_open(WT_SESSION_IMPL *session, const char *uri,
* get the handle while holding the checkpoint lock.
*/
if (LF_ISSET(WT_DHANDLE_EXCLUSIVE) && checkpoint_wait)
- WT_WITH_CHECKPOINT_LOCK(session, ret,
+ WT_WITH_CHECKPOINT_LOCK(session,
ret = __wt_session_get_btree_ckpt(
session, uri, cfg, flags));
else
diff --git a/src/cursor/cur_index.c b/src/cursor/cur_index.c
index eb5e15ae5c3..0ab992bc88c 100644
--- a/src/cursor/cur_index.c
+++ b/src/cursor/cur_index.c
@@ -281,33 +281,38 @@ __curindex_search_near(WT_CURSOR *cursor, int *exact)
* (usually) doesn't contain the primary key, so it is just a prefix of
* any matching index key. That said, if there is an exact match, we
* want to find the first matching index entry and set exact equal to
- * zero. Do a search_near, step to the next entry if we land on one
- * that is too small, then check that the prefix matches.
+ * zero.
+ *
+ * Do a search_near, and if we find an entry that is too small, step to
+ * the next one. In the unlikely event of a search past the end of the
+ * tree, go back to the last key.
*/
__wt_cursor_set_raw_key(child, &cursor->key);
WT_ERR(child->search_near(child, &cmp));
- if (cmp < 0)
- WT_ERR(child->next(child));
+ if (cmp < 0) {
+ if ((ret = child->next(child)) == WT_NOTFOUND)
+ ret = child->prev(child);
+ WT_ERR(ret);
+ }
/*
* We expect partial matches, and want the smallest record with a key
* greater than or equal to the search key.
*
- * If the key we find is shorter than the search key, it can't possibly
- * match.
+ * If the found key starts with the search key, we indicate a match by
+ * setting exact equal to zero.
*
- * The only way for the key to be exactly equal is if there is an index
- * on the primary key, because otherwise the primary key columns will
- * be appended to the index key, but we don't disallow that (odd) case.
+ * The compare function expects application-supplied keys to come first
+ * so we flip the sign of the result to match what callers expect.
*/
found_key = child->key;
- if (found_key.size < cursor->key.size)
- WT_ERR(WT_NOTFOUND);
- found_key.size = cursor->key.size;
+ if (found_key.size > cursor->key.size)
+ found_key.size = cursor->key.size;
WT_ERR(__wt_compare(
session, cindex->index->collator, &cursor->key, &found_key, exact));
+ *exact = -*exact;
WT_ERR(__curindex_move(cindex));
diff --git a/src/cursor/cur_join.c b/src/cursor/cur_join.c
index 2fa2a207c8a..013a64ef2d5 100644
--- a/src/cursor/cur_join.c
+++ b/src/cursor/cur_join.c
@@ -1333,7 +1333,7 @@ __wt_curjoin_open(WT_SESSION_IMPL *session,
WT_ERR(__wt_scr_alloc(session, 0, &tmp));
if (columns != NULL) {
WT_ERR(__wt_struct_reformat(session, table,
- columns, strlen(columns), NULL, 1, tmp));
+ columns, strlen(columns), NULL, false, tmp));
WT_ERR(__wt_strndup(
session, tmp->data, tmp->size, &cursor->value_format));
WT_ERR(__wt_strdup(session, columns, &cjoin->projection));
diff --git a/src/cursor/cur_json.c b/src/cursor/cur_json.c
index 4ba10ddabb0..a0a3ffdd974 100644
--- a/src/cursor/cur_json.c
+++ b/src/cursor/cur_json.c
@@ -270,7 +270,6 @@ __wt_json_alloc_unpack(WT_SESSION_IMPL *session, const void *buffer,
bool iskey, va_list ap)
{
WT_CONFIG_ITEM *names;
- WT_DECL_RET;
size_t needed;
char **json_bufp;
@@ -288,7 +287,7 @@ __wt_json_alloc_unpack(WT_SESSION_IMPL *session, const void *buffer,
WT_RET(__json_struct_unpackv(session, buffer, size, fmt,
names, (u_char *)*json_bufp, needed + 1, iskey, ap));
- return (ret);
+ return (0);
}
/*
@@ -315,6 +314,7 @@ __wt_json_close(WT_SESSION_IMPL *session, WT_CURSOR *cursor)
*/
size_t
__wt_json_unpack_char(u_char ch, u_char *buf, size_t bufsz, bool force_unicode)
+ WT_GCC_FUNC_ATTRIBUTE((visibility("default")))
{
u_char abbrev;
@@ -357,8 +357,8 @@ __wt_json_unpack_char(u_char ch, u_char *buf, size_t bufsz, bool force_unicode)
*buf++ = 'u';
*buf++ = '0';
*buf++ = '0';
- *buf++ = __wt_hex[(ch & 0xf0) >> 4];
- *buf++ = __wt_hex[ch & 0x0f];
+ *buf++ = __wt_hex((ch & 0xf0) >> 4);
+ *buf++ = __wt_hex(ch & 0x0f);
}
return (6);
}
@@ -452,6 +452,7 @@ __wt_json_column_init(WT_CURSOR *cursor, const char *keyformat,
int
__wt_json_token(WT_SESSION *wt_session, const char *src, int *toktype,
const char **tokstart, size_t *toklen)
+ WT_GCC_FUNC_ATTRIBUTE((visibility("default")))
{
WT_SESSION_IMPL *session;
int result;
@@ -580,6 +581,7 @@ __wt_json_token(WT_SESSION *wt_session, const char *src, int *toktype,
*/
const char *
__wt_json_tokname(int toktype)
+ WT_GCC_FUNC_ATTRIBUTE((visibility("default")))
{
switch (toktype) {
case 0: return ("<EOF>");
@@ -817,6 +819,7 @@ __wt_json_to_item(WT_SESSION_IMPL *session, const char *jstr,
*/
ssize_t
__wt_json_strlen(const char *src, size_t srclen)
+ WT_GCC_FUNC_ATTRIBUTE((visibility("default")))
{
const char *srcend;
size_t dstlen;
@@ -857,8 +860,9 @@ __wt_json_strlen(const char *src, size_t srclen)
* bytes. If dstlen is greater than the needed size, the result if zero padded.
*/
int
-__wt_json_strncpy(WT_SESSION *wt_session, char **pdst, size_t dstlen,
- const char *src, size_t srclen)
+__wt_json_strncpy(WT_SESSION *wt_session,
+ char **pdst, size_t dstlen, const char *src, size_t srclen)
+ WT_GCC_FUNC_ATTRIBUTE((visibility("default")))
{
WT_SESSION_IMPL *session;
char ch, *dst;
diff --git a/src/cursor/cur_log.c b/src/cursor/cur_log.c
index 21a7f674c68..3ee6554b3c0 100644
--- a/src/cursor/cur_log.c
+++ b/src/cursor/cur_log.c
@@ -150,18 +150,22 @@ static int
__curlog_kv(WT_SESSION_IMPL *session, WT_CURSOR *cursor)
{
WT_CURSOR_LOG *cl;
- WT_ITEM item;
- uint32_t fileid, key_count, opsize, optype;
+ WT_DECL_RET;
+ uint32_t fileid, key_count, opsize, optype, raw;
cl = (WT_CURSOR_LOG *)cursor;
+ /* Temporarily turn off raw so we can do direct cursor operations. */
+ raw = F_MASK(cursor, WT_CURSTD_RAW);
+ F_CLR(cursor, WT_CURSTD_RAW);
+
/*
* If it is a commit and we have stepped over the header, peek to get
* the size and optype and read out any key/value from this operation.
*/
if ((key_count = cl->step_count++) > 0) {
- WT_RET(__wt_logop_read(session,
+ WT_ERR(__wt_logop_read(session,
&cl->stepp, cl->stepp_end, &optype, &opsize));
- WT_RET(__curlog_op_read(session, cl, optype, opsize, &fileid));
+ WT_ERR(__curlog_op_read(session, cl, optype, opsize, &fileid));
/* Position on the beginning of the next record part. */
cl->stepp += opsize;
} else {
@@ -181,39 +185,14 @@ __curlog_kv(WT_SESSION_IMPL *session, WT_CURSOR *cursor)
* The log cursor sets the LSN and step count as the cursor key and
* and log record related data in the value. The data in the value
* contains any operation key/value that was in the log record.
- * For the special case that the caller needs the result in raw form,
- * we create packed versions of the key/value.
*/
- if (FLD_ISSET(cursor->flags, WT_CURSTD_RAW)) {
- memset(&item, 0, sizeof(item));
- WT_RET(wiredtiger_struct_size((WT_SESSION *)session,
- &item.size, WT_LOGC_KEY_FORMAT, cl->cur_lsn->l.file,
- cl->cur_lsn->l.offset, key_count));
- WT_RET(__wt_realloc(session, NULL, item.size, &cl->packed_key));
- item.data = cl->packed_key;
- WT_RET(wiredtiger_struct_pack((WT_SESSION *)session,
- cl->packed_key, item.size, WT_LOGC_KEY_FORMAT,
- cl->cur_lsn->l.file, cl->cur_lsn->l.offset, key_count));
- __wt_cursor_set_key(cursor, &item);
-
- WT_RET(wiredtiger_struct_size((WT_SESSION *)session,
- &item.size, WT_LOGC_VALUE_FORMAT, cl->txnid, cl->rectype,
- optype, fileid, cl->opkey, cl->opvalue));
- WT_RET(__wt_realloc(session, NULL, item.size,
- &cl->packed_value));
- item.data = cl->packed_value;
- WT_RET(wiredtiger_struct_pack((WT_SESSION *)session,
- cl->packed_value, item.size, WT_LOGC_VALUE_FORMAT,
- cl->txnid, cl->rectype, optype, fileid, cl->opkey,
- cl->opvalue));
- __wt_cursor_set_value(cursor, &item);
- } else {
- __wt_cursor_set_key(cursor, cl->cur_lsn->l.file,
- cl->cur_lsn->l.offset, key_count);
- __wt_cursor_set_value(cursor, cl->txnid, cl->rectype, optype,
- fileid, cl->opkey, cl->opvalue);
- }
- return (0);
+ __wt_cursor_set_key(cursor, cl->cur_lsn->l.file, cl->cur_lsn->l.offset,
+ key_count);
+ __wt_cursor_set_value(cursor, cl->txnid, cl->rectype, optype, fileid,
+ cl->opkey, cl->opvalue);
+
+err: F_SET(cursor, raw);
+ return (ret);
}
/*
@@ -264,17 +243,19 @@ __curlog_search(WT_CURSOR *cursor)
WT_DECL_RET;
WT_LSN key;
WT_SESSION_IMPL *session;
- uint32_t counter, key_file, key_offset;
+ uint32_t counter, key_file, key_offset, raw;
cl = (WT_CURSOR_LOG *)cursor;
+ /* Temporarily turn off raw so we can do direct cursor operations. */
+ raw = F_MASK(cursor, WT_CURSTD_RAW);
+ F_CLR(cursor, WT_CURSTD_RAW);
CURSOR_API_CALL(cursor, session, search, NULL);
/*
* !!! We are ignoring the counter and only searching based on the LSN.
*/
- WT_ERR(__wt_cursor_get_key((WT_CURSOR *)cl,
- &key_file, &key_offset, &counter));
+ WT_ERR(__wt_cursor_get_key(cursor, &key_file, &key_offset, &counter));
WT_SET_LSN(&key, key_file, key_offset);
ret = __wt_log_scan(session, &key, WT_LOGSCAN_ONE,
__curlog_logrec, cl);
@@ -285,7 +266,8 @@ __curlog_search(WT_CURSOR *cursor)
WT_STAT_CONN_INCR(session, cursor_search);
WT_STAT_DATA_INCR(session, cursor_search);
-err: API_END_RET(session, ret);
+err: F_SET(cursor, raw);
+ API_END_RET(session, ret);
}
/*
diff --git a/src/cursor/cur_table.c b/src/cursor/cur_table.c
index 502d93639a8..fae7667e44f 100644
--- a/src/cursor/cur_table.c
+++ b/src/cursor/cur_table.c
@@ -763,16 +763,13 @@ err: API_END_RET(session, ret);
static int
__curtable_complete(WT_SESSION_IMPL *session, WT_TABLE *table)
{
- WT_DECL_RET;
bool complete;
if (table->cg_complete)
return (0);
/* If the table is incomplete, wait on the table lock and recheck. */
- complete = false;
- WT_WITH_TABLE_LOCK(session, ret, complete = table->cg_complete);
- WT_RET(ret);
+ WT_WITH_TABLE_LOCK(session, complete = table->cg_complete);
if (!complete)
WT_RET_MSG(session, EINVAL,
"'%s' not available until all column groups are created",
@@ -927,7 +924,7 @@ __wt_curtable_open(WT_SESSION_IMPL *session,
WT_ERR(__wt_scr_alloc(session, 0, &tmp));
if (columns != NULL) {
WT_ERR(__wt_struct_reformat(session, table,
- columns, strlen(columns), NULL, true, tmp));
+ columns, strlen(columns), NULL, false, tmp));
WT_ERR(__wt_strndup(
session, tmp->data, tmp->size, &cursor->value_format));
generated by cgit v1.2.3 (git 2.39.1) at 2026-09-11 12:07:22 +0000