Speed up database evictor by using chunking

Author: Vectorial1024

src/Database/DatabaseEvictStrategy.php

@@ -21,6 +21,10 @@ class DatabaseEvictStrategy extends AbstractEvictStrategy
     protected DatabaseStore $cacheStore;
 
     protected int $deletedRecords = 0;
+    /**
+     * @var int
+     * @deprecated Because this tool does not actually free table spaces, there is no need to track the amount of space freed from eviction.
+     */
     protected int $deletedRecordSizes = 0;
 
     protected float $elapsedTime = 0;
@@ -46,7 +50,6 @@ public function execute(): void
     {
         // read the cache config and set up targets
         $this->deletedRecords = 0;
-        $this->deletedRecordSizes = 0;
         $this->elapsedTime = 0;
 
         // we use a memory-efficient way of deleting items.
@@ -62,32 +65,34 @@ public function execute(): void
         Partyline::info("Found $itemCount records; processing...");
 
         // create a progress bar to display our progress
-        /** @var ProgressBar $progressBar */
-        $progressBar = $this->output->createProgressBar();
-        $progressBar->setMaxSteps($itemCount);
-        foreach ($this->yieldCacheTableItems() as $cacheItem) {
-            // read record details
-            $currentActualKey = $cacheItem->key;
-            $currentExpiration = $cacheItem->expiration;
-            // currently timestamps are 32-bit, so are 4 bytes
-            $estimatedBytes = (int) ($cacheItem->key_bytes + $cacheItem->value_bytes + 4);
-            $progressBar->advance();
-
-            if (time() < $currentExpiration) {
-                // not expired yet
-                continue;
+        $progressBar = $this->output->createProgressBar($itemCount);
+        foreach ($this->yieldCacheTableChunks() as $chunk) {
+            $progressBar->advance(count($chunk));
+
+            // identify the keys of the records that are potentially expired
+            $currentTimestamp = time();
+            $possibleExpiredKeys = [];
+            foreach ($chunk as $cacheItem) {
+                $currentActualKey = $cacheItem->key;
+                $currentExpiration = $cacheItem->expiration;
+                if ($currentTimestamp < $currentExpiration) {
+                    // not expired yet
+                    continue;
+                }
+                // item expired; put to the deletion queue
+                $possibleExpiredKeys[] = $currentActualKey;
             }
-            // item expired; try to issue a delete command to it
+
+            // try to issue a delete command to the database
             // this respects any potential new value written to the db while we were checking other things
             $rowsAffected = $this->dbConn
                 ->table($this->dbTable)
-                ->where('key', '=', $currentActualKey)
-                ->where('expiration', '=', $currentExpiration)
+                ->whereIn('key', $possibleExpiredKeys)
+                ->where('expiration', '<=', $currentTimestamp)
                 ->delete();
             if ($rowsAffected) {
-                // item really expired with no new updates
-                $this->deletedRecords += 1;
-                $this->deletedRecordSizes += $estimatedBytes;
+                // items really expired with no new updates
+                $this->deletedRecords += $rowsAffected;
             }
         }
 
@@ -98,47 +103,65 @@ public function execute(): void
         // all is done; print some stats
         $endUnix = microtime(true);
         $this->elapsedTime = $endUnix - $startUnix;
-        // generate a human readable file size
-        $readableFileSize = $this->bytesToHuman($this->deletedRecordSizes);
+        // note: the database evictor does not help reclaim free table spaces, so no need to print file size information
         Partyline::info("Took {$this->elapsedTime} seconds.");
-        Partyline::info("Removed {$this->deletedRecords} expired cache records. Estimated total size: $readableFileSize");
+        Partyline::info("Removed {$this->deletedRecords} expired cache records.");
         Partyline::info("Note: no free space reclaimed; reclaiming free space should be done manually!");
     }
 
     /**
      * Yields the next item from the cache table that belongs to this cache.
      * 
      * This method will return the actual key (with the cache prefix if exists) of the entry.
+     * @deprecated This method is deprecated in favor of chunked deletion. Currently, it fetches and yields nothing.
      * @return \Generator<mixed, object, mixed, void>
      */
     protected function yieldCacheTableItems(): \Generator
+    {
+        yield new \stdClass();
+    }
+
+    /**
+     * Yields the next chunk of many items from the cache table that belongs to this cache.
+     *
+     * This method will return the actual keys (with the cache prefix if exists) of the entries.
+     * @return \Generator<mixed, array, mixed, void>
+     */
+    protected function yieldCacheTableChunks(): \Generator
     {
         // there might be a prefix for the cache store!
         $cachePrefix = $this->cachePrefix;
         // initialize the key to be just the cache prefix as the "zero string".
         $currentActualKey = $cachePrefix;
         $prefixLength = strlen($cachePrefix);
+        // the cache table uses (MySQL) utf8mb4 collation (4 bytes) for its key column with max length 256
+        // we estimate this should result in max allocation of about $chunkCount * 4 * 256 bytes throughout the eviction
+        // remember to avoid excessive chunk sizes so that full-table locking is less likely to occur
+        $chunkCount = 100;
         // loop until no more items
         while (true) {
             // find the next key
             // note: different SQL flavors have different interpretations of LIKE, so we use SUBSTRING instead.
             // with SUBSTRING, we are clear we want a case-sensitive match, and we might potentially get collation-correct matching
-            $record = $this->dbConn
+            $recordsList = $this->dbConn
                 ->table($this->dbTable)
-                ->select(['key', 'expiration', DB::raw('LENGTH(`key`) AS key_bytes'), DB::raw('LENGTH(value) AS value_bytes')])
+                ->select(['key', 'expiration'])
                 ->where('key', '>', $currentActualKey)
                 ->where(DB::raw("SUBSTRING(`key`, 1, $prefixLength)"), '=', $cachePrefix)
                 // PostgreSQL: if no sorting specified, then will ignore primary key index/ordering, which breaks the intended workflow
                 ->orderBy('key')
-                ->limit(1)
-                ->first();
-            if (!$record) {
+                ->limit($chunkCount)
+                ->get();
+            if ($recordsList->isEmpty()) {
                 // nothing more to get
                 break;
             }
 
-            yield $record;
-            $currentActualKey = $record->key;
+            $theChunk = $recordsList->all();
+            yield $theChunk;
+            // find the last element, and set it to be the current key to continue table-walking
+            $lastItem = end($theChunk);
+            $currentActualKey = $lastItem->key;
         }
         // loop exit handled inside while loop
     }