fix rebase issues

Signed-off-by: xbasel <103044017+xbasel@users.noreply.github.com>

Author: xbasel

src/db.c

@@ -1967,6 +1967,13 @@ static int objectIsExpired(robj *val) {
 static int keyIsExpiredWithDictIndexImpl(serverDb *db, robj *key, int dict_index) {
     /* Don't expire anything while loading. It will be done later. */
     if (server.loading) return 0;
+    mstime_t when = getExpireWithDictIndex(db, key, dict_index);
+    return timestampIsExpired(when);
+}
+
+/* Check if the key is expired. */
+static int keyIsExpiredWithDictIndex(serverDb *db, robj *key, int dict_index) {
+    if (!keyIsExpiredWithDictIndexImpl(db, key, dict_index)) return 0;
 
     /* See expireIfNeededWithDictIndex for more details. */
     if (server.primary_host == NULL && server.import_mode) {

src/expire.c

@@ -827,31 +827,6 @@ int convertExpireArgumentToUnixTime(client *c, robj *arg, long long basetime, in
     return C_OK;
 }
 
-int convertExpireArgumentToUnixTime(client *c, robj *arg, long long basetime, int unit, long long *unixtime) {
-    long long when;
-    if (getLongLongFromObjectOrReply(c, arg, &when, NULL) != C_OK) return C_ERR;
-
-    if (when < 0) {
-        addReplyErrorExpireTime(c);
-        return C_ERR;
-    }
-
-    if (unit == UNIT_SECONDS) {
-        if (when > LLONG_MAX / 1000 || when < LLONG_MIN / 1000) {
-            addReplyErrorExpireTime(c);
-            return C_ERR;
-        }
-        when *= 1000;
-    }
-    if (when > LLONG_MAX - basetime) {
-        addReplyErrorExpireTime(c);
-        return C_ERR;
-    }
-    when += basetime;
-    if (unixtime) *unixtime = when;
-    return C_OK;
-}
-
 /*-----------------------------------------------------------------------------
  * Expires Commands
  *----------------------------------------------------------------------------*/

src/hashtable.c

@@ -886,11 +886,6 @@ static void compactBucketChain(hashtable *ht, size_t bucket_index, int table_ind
     }
 }
 
-static inline hashtableElementAccessState accessElementIfNeeded(hashtable *ht, void *elem) {
-    if (ht->type->accessElement == NULL) return ELEMENT_VALID;
-    return ht->type->accessElement(ht, elem);
-}
-
 /* Find an empty position in the table for inserting an entry with the given hash. */
 static bucket *findBucketForInsert(hashtable *ht, uint64_t hash, int *pos_in_bucket, int *table_index) {
     int table = hashtableIsRehashing(ht) ? 1 : 0;
@@ -2045,9 +2040,6 @@ int hashtableNext(hashtableIterator *iterator, void **elemptr) {
             /* No entry here. */
             continue;
         }
-        if (!(iter->flags & HASHTABLE_ITER_AVOID_ACCESS) && accessElementIfNeeded(iter->hashtable, b->entries[iter->pos_in_bucket]) != ELEMENT_VALID) {
-            continue;
-        }
         if (!(iter->flags & HASHTABLE_ITER_SKIP_VALIDATION) && validateElementIfNeeded(iter->hashtable, b->entries[iter->pos_in_bucket]) != ENTRY_VALID) {
             continue;
         }

src/server.c

@@ -679,12 +679,6 @@ size_t hashHashtableTypeMetadataSize(void) {
 
 extern hashtableEntryValidationState hashHashtableTypeValidate(hashtable *ht, void *entry);
 
-size_t hashHashtableTypeMetadataSize(void) {
-    return sizeof(void *);
-}
-
-extern hashtableElementAccessState hashHashtableTypeAccess(hashtable *ht, void *entry);
-
 hashtableType hashHashtableType = {
     .hashFunction = dictSdsHash,
     .entryGetKey = hashHashtableTypeGetKey,
@@ -702,15 +696,6 @@ hashtableType hashWithVolatileItemsHashtableType = {
     .validateEntry = hashHashtableTypeValidate,
 };
 
-hashtableType hashWithVolatileItemsHashtableType = {
-    .hashFunction = dictSdsHash,
-    .entryGetKey = hashHashtableTypeGetKey,
-    .keyCompare = hashtableSdsKeyCompare,
-    .entryDestructor = hashHashtableTypeDestructor,
-    .getMetadataSize = hashHashtableTypeMetadataSize,
-    .accessElement = hashHashtableTypeAccess,
-};
-
 /* Hashtable type without destructor */
 hashtableType sdsReplyHashtableType = {
     .hashFunction = dictSdsCaseHash,

src/server.h

@@ -1700,7 +1700,6 @@ struct valkeyServer {
                                             * Value: RDB client object
                                             * This structure holds dual-channel sync replicas from the start of their
                                             * RDB transfer until their main channel establishes partial synchronization. */
-    keyAccessContext access_context;        /* The current key access context */
 
     client *current_client;                /* The client that triggered the command execution (External or AOF). */
     client *executing_client;              /* The client executing the current command (possibly script or module). */

src/t_hash.c

@@ -36,14 +36,12 @@
 #include "rax.h"
 #include "sds.h"
 #include "volatile_set.h"
-// #include "server.h"
+#include "server.h"
 #include "zmalloc.h"
 #include <math.h>
 #include <string.h>
 #include "entry.h"
 
-#include "server.h"
-
 
 int hashTypeExpireEntry(entry *entry);
 
@@ -110,129 +108,6 @@ static void hashTypeDeleteVolatileSet(robj *o) {
     hashTypeIgnoreTTL(o, true);
 }
 
-void hashTypeTrackEntry(robj *o, void *entry) {
-    volatile_set *set = hashTypeGetOrcreateVolatileSet(o);
-    serverAssert(volatileSetAddEntry(set, entry, entryGetExpiry(entry)));
-}
-
-void hashTypeUntrackEntry(robj *o, void *entry) {
-    if (!entryHasExpiry(entry)) return;
-    volatile_set *set = hashTypeGetVolatileSet(o);
-    debugServerAssert(set);
-    serverAssert(volatileSetRemoveEntry(set, entry, entryGetExpiry(entry)));
-    if (volatileSetNumEntries(set) == 0) {
-        hashTypeDeleteVolatileSet(o);
-    }
-}
-
-static void hashTypeTrackUpdateEntry(robj *o, void *old_entry, void *new_entry, long long old_expiry, long long new_expiry) {
-    int old_tracked = (old_entry && old_expiry != EXPIRY_NONE);
-    int new_tracked = (new_entry && new_expiry != EXPIRY_NONE);
-    /* If entry was not tracked before and not going to be tracked now, we can simply return */
-    if (!old_tracked && !new_tracked)
-        return;
-
-    volatile_set *set = hashTypeGetOrcreateVolatileSet(o);
-    debugServerAssert(set);
-    if (entryHasValuePtr(entry)) {
-        /* In case the value is not embedded we might not be able to sum all the allocation sizes since the field
-         * header could be too small for holding the real allocation size. */
-        mem += zmalloc_usable_size(hashTypeEntryAllocPtr(entry));
-    } else {
-        mem += sdsReqSize(sdslen(entry), sdsType(entry));
-        if (entryHasExpiry(entry)) mem += sizeof(long long);
-    }
-    mem += sdsAllocSize(hashTypeEntryGetValue(entry));
-    return mem;
-}
-
-    if (old_tracked && !new_tracked)
-        serverAssert(volatileSetRemoveEntry(set, old_entry, old_expiry));
-    else if (new_tracked && !old_tracked)
-        serverAssert(volatileSetAddEntry(set, new_entry, new_expiry));
-    else {
-        volatile_set *set = hashTypeGetVolatileSet(o);
-        debugServerAssert(set);
-        serverAssert(volatileSetUpdateEntry(set, old_entry, new_entry, old_expiry, new_expiry) == 1);
-    }
-    if (volatileSetNumEntries(set) == 0) {
-        hashTypeDeleteVolatileSet(o);
-    }
-}
-
-int hashTypeExpireEntry(void *entry) {
-    // TBD
-    UNUSED(entry);
-    return 1;
-}
-
-hashtableEntryValidationState hashHashtableTypeValidate(hashtable *ht, void *entry) {
-    UNUSED(ht);
-    expirationPolicy policy = getExpirationPolicyWithFlags(0);
-    if (policy == POLICY_IGNORE_EXPIRE) return ENTRY_VALID;
-
-    if (!entryIsExpired(entry)) return ENTRY_VALID;
-
-    return ENTRY_INVALID;
-}
-
-/*-----------------------------------------------------------------------------
- * Hash type Expiry API
- *----------------------------------------------------------------------------*/
-
-static volatile_set *hashTypeGetVolatileSet(robj *o) {
-    serverAssert(o->encoding == OBJ_ENCODING_HASHTABLE);
-    return *(volatile_set **)hashtableMetadata(o->ptr);
-}
-
-void hashTypeFreeVolatileSet(robj *o) {
-    volatile_set *set = hashTypeGetVolatileSet(o);
-    if (set)
-        freeVolatileSet(set);
-}
-
-int hashTypeHasVolatileElements(robj *o) {
-    return ((o->encoding == OBJ_ENCODING_HASHTABLE) && (hashTypeGetVolatileSet(o) != NULL));
-}
-
-size_t hashTypeNumVolatileElements(robj *o) {
-    if (hashTypeHasVolatileElements(o)) {
-        return volatileSetNumEntries(hashTypeGetVolatileSet(o));
-    }
-    return 0;
-}
-
-void hashTypeIgnoreTTL(robj *o, int ignore) {
-    if (o->encoding == OBJ_ENCODING_HASHTABLE) {
-        /* prevent placing access function if not needed */
-        if (!ignore && !hashTypeHasVolatileElements(o)) {
-            ignore = 0;
-        }
-        hashtableSetType(o->ptr, ignore ? &hashHashtableType : &hashWithVolatileItemsHashtableType);
-    }
-}
-
-static volatile_set *
-hashTypeGetOrcreateVolatileSet(robj *o) {
-    serverAssert(o->encoding == OBJ_ENCODING_HASHTABLE);
-    volatile_set **volatile_set_ref = hashtableMetadata(o->ptr);
-    if (*volatile_set_ref == NULL) {
-        *volatile_set_ref = createVolatileSet(&hashvolatileEntryType);
-        /* serves mainly for optimization. Use type which supports access function only when needed. */
-        hashTypeIgnoreTTL(o, 0);
-    }
-    return *volatile_set_ref;
-}
-
-
-static void hashTypeDeleteVolatileSet(robj *o) {
-    volatile_set **volatile_set_ref = hashtableMetadata(o->ptr);
-    freeVolatileSet(*volatile_set_ref);
-    *volatile_set_ref = NULL;
-    /* serves mainly for optimization. by changing the hashtable type we can avoid extra function call in hashtable access */
-    hashTypeIgnoreTTL(o, 1);
-}
-
 void hashTypeTrackEntry(serverDb* db, robj *o, void *entry) {
     volatile_set *set = hashTypeGetOrcreateVolatileSet(o);
     serverAssert(volatileSetAddEntry(set, entry, entryGetExpiry(entry)));
@@ -247,7 +122,7 @@ void hashTypeUntrackEntry(serverDb* db, robj *o, void *entry) {
     if (volatileSetNumEntries(set) == 0) {
         hashTypeDeleteVolatileSet(o);
     }
-    // kvstoreHashtableDelete(db->keys_with_volatile_items, 0, o);
+    // kvstoreHashtableDelete(db->keys_with_volatile_items, 0, o); // TODO
 }
 
 static void hashTypeTrackUpdateEntry(serverDb* db, robj *o, void *old_entry, void *new_entry, long long old_expiry, long long new_expiry) {
@@ -281,14 +156,14 @@ int hashTypeExpireEntry(void *entry) {
     return 1;
 }
 
-hashtableElementAccessState hashHashtableTypeAccess(hashtable *ht, void *entry) {
+hashtableEntryValidationState hashHashtableTypeValidate(hashtable *ht, void *entry) {
     UNUSED(ht);
+    expirationPolicy policy = getExpirationPolicyWithFlags(0);
+    if (policy == POLICY_IGNORE_EXPIRE) return ENTRY_VALID;
 
-    if (!canExpireWithFlags(0, NULL)) return ELEMENT_VALID;
-
-    if (!entryIsExpired(entry)) return ELEMENT_VALID;
+    if (!entryIsExpired(entry)) return ENTRY_VALID;
 
-    return ELEMENT_INVALID;
+    return ENTRY_INVALID;
 }
 
 /*-----------------------------------------------------------------------------
@@ -719,20 +594,6 @@ void hashTypeInitIterator(robj *subject, hashTypeIterator *hi) {
     }
 }
 
-void hashTypeInitVolatileIterator(robj *subject, hashTypeIterator *hi) {
-    hi->subject = subject;
-    hi->encoding = subject->encoding;
-    hi->volatile_items = 1;
-
-    if (hi->encoding == OBJ_ENCODING_LISTPACK) {
-        return;
-    } else if (hi->encoding == OBJ_ENCODING_HASHTABLE) {
-        volatileSetStart(hashTypeGetVolatileSet(subject), &hi->viter);
-    } else {
-        serverPanic("Unknown hash encoding");
-    }
-}
-
 void hashTypeInitVolatileIterator(robj *subject, hashTypeIterator *hi) {
     hi->subject = subject;
     hi->encoding = subject->encoding;
@@ -1298,8 +1159,6 @@ void hsetexCommand(client *c) {
 
         if (convertExpireArgumentToUnixTime(c, expire, basetime, unit, &when) == C_ERR)
             return;
-        }
-        when += commandTimeSnapshot();
 
         if (((flags & OBJ_PXAT) || (flags & OBJ_EXAT)) && checkAlreadyExpired(when)) {
             set_expired = 1;
@@ -1681,9 +1540,7 @@ void httlGenericCommand(client *c, long long basetime, int unit) {
         return;
     }
 
-    hashTypeSetAccessContext(hash, c->db);
-
-    if (checkType(c, hash, OBJ_HASH)) return;
+    robj *hash = lookupKeyRead(c->db, c->argv[1]);
 
     if (checkType(c, hash, OBJ_HASH)) return;