*
 * <p>Temporary files created by this stream may live in the local filesystem until either:
 *
 * <ul>
 *   <li>{@link #reset} is called (removing the data in this stream and deleting the file), or...
 *   <li>this stream (or, more precisely, its {@link #asByteSource} view) is garbage collected,
 *       <strong>AND</strong> this stream was constructed with {@linkplain

 - ... Standard Events...
 - ResponseBodyEnd _(0 bytes)_
 - **CacheHit**
 - ConnectionReleased
 - CallEnd

## Cache directory

The cache directory must be exclusively owned by a single instance.

Deleting the cache when it is no longer needed can be done.  However this may delete the purpose of the cache
which is designed to persist between app restarts.

```kotlin
cache.delete()
```

## Pruning the Cache

    @Test
    public void test_deleteNonExistentId() throws Exception {
        SuggestDeleteResponse response = suggester.indexer().delete("non-existent-id");

        assertNotNull(response);
        // Deleting non-existent ID should not cause error
        assertFalse(response.hasError());
    }

    @Test
    public void test_deleteByInvalidQueryString() throws Exception {
        try {

// This interface provides methods for creating new statements, retrieving all cache keys,
// getting cached statements, setting cached statements, and deleting cached statements.
type Store interface {
	// New creates a new Stmt object and caches it.
	// Parameters:
	//   ctx: The context for the request, which can carry deadlines, cancellation signals, etc.

        } finally {
            Files.deleteIfExists(noImageFile);
        }
    }

    @Test
    public void test_atomicDeleteIfExists_alreadyDeleted() throws Exception {
        // Test that deleting already deleted file doesn't throw
        Path tempFile = Files.createTempFile("already_deleted", ".tmp");
        Files.delete(tempFile);
        assertFalse(Files.exists(tempFile));

            logger.warn("Failed to check existing operation: operation={}", operationName, e);
        }
        return false;
    }

    /**
     * Releases the operation lock by deleting the operation document.
     * Safe to call multiple times; does nothing if the document is already deleted.
     *
     * @param operationName the operation name whose lock should be released.
     */

success.reindex_started=Started re-indexing.
success.bulk_process_started=Started a bulk process.
success.print_thread_dump=Printed a thread dump to a log file.
success.install_plugin=Installing plugin {0}.
success.delete_plugin=Deleting plugin {0}.
success.upload_file_to_storage=Uploaded {0}.
success.sso_logout=You have been logged out.
success.update_storage_tags=Updated tags of {0}.

success.crud_create_crud_table = Created the data.

success.reindex_started=Started re-indexing.
success.bulk_process_started=Started a bulk process.
success.print_thread_dump=Printed a thread dump to a log file.
success.install_plugin=Installing plugin {0}.
success.delete_plugin=Deleting plugin {0}.
success.upload_file_to_storage=Uploaded {0}.
success.sso_logout=You have been logged out.
success.update_storage_tags=Updated tags of {0}.

success.crud_create_crud_table = Created the data.

			return value, false
		}
		c.evictList.MoveToFront(ent)
		return ent.Value, true
	}
	return
}

// Contains checks if a key is in the cache, without updating the recent-ness
// or deleting it for being stale.
func (c *LRU[K, V]) Contains(key K) (ok bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	_, ok = c.items[key]
	return ok
}

{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[83:93] hl[83:84,88:89] *}

### Delete a Hero Again { #delete-a-hero-again }

**Deleting** a hero stays pretty much the same.

We won't satisfy the desire to refactor everything in this one. 😅

{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[96:103] hl[101] *}