Using for instance:

$users = User::where("id", ">", "1")->remember(10)->take(5)->get();

Gives the expected result (no errors). But reloading the page, I see that mysql simply fires the 5 queries again and again....

Sometimes I want to force a refresh of the cache that has been set by rememberable. Something like: Cache::forget('key'); However I don't know the key and if this way is possible at all?

I am using the Repository pattern and want to test this trait out on just one problematic model for starters.

I have HotelSearchRepository.php which includes chainable methods. The top of the file looks like this:

namespace App\Repositories\Eloquent;

use Watson\Rememberable\Rememberable;
use App\Repositories\Contracts\EventLocationRepositoryInterface;
use App\Repositories\Contracts\HotelSearchRepositoryInterface;

class HotelSearchRepository extends Repository implements HotelSearchRepositoryInterface
{
    use Rememberable;
...

I am chaining methods for my search functionality like so:

    public function search($terms = [])
    {
        $this->terms = $terms;

        return $this
            ->withMinSleepingRooms($this->term('min_sleeping_rooms'))
            ->withMaxSleepingRooms($this->term('max_sleeping_rooms'))
            ->withMinMeetingRooms($this->term('min_meeting_rooms'))
            ->withMinLargestMeetingRoomSqFt($this->term('min_largest_meeting_room_sq_ft'))
            ->withStarsMatching($this->term('stars'))
            ->withBrands($this->term('brands'))
            ->nearLocations($this->term('locations'), $this->term('radius'), $this->term('radius_units'))
            ->withRelatedModels()
            ->complete();
    }

So the method I'm including the remember trait on is here:

    private function withRelatedModels()
    {
        $this->model = $this->model->with(['propertyType' => function ($q) {
            return $q->remember(10);
        }]);

        return $this;
    }

I am only attempting to cache the propertyType query at this point. However, I get the exception: Call to undefined method Illuminate\Database\Query\Builder::remember().

I have tried this as well, to no avail.

    private function withRelatedModels()
    {
        $this->model = $this->model->with(['propertyType' => function ($q) {
            return $q->remember(10);
        }])->remember(10);

        return $this;
    }

What am I doing wrong here?

Hi,

Is there a reason why Laravel 7 is no longer supported? Shouldn't the requirements be similar to "^7.0|^8.0"? Looks like this commit attempted to do it (c897403148cd011f2eec494e7914137efbde1ddc) but the syntax was wrong. This commit (bb5b31537b05f135c7afd7fad3d4a8a2cc0c1886) gets rid of Laravel 7 support

https://github.com/dwightwatson/rememberable/blob/master/src/Query/Builder.php#L81

In that line, the Builder checks if $minutes < 0 This is not an error BUT:

According to the Laravel documentation, the remember() method requires 3 types for the first argument:

• int
• float
• \DateTime

(See https://laravel.com/api/5.4/Illuminate/Cache/Repository.html#method_remember)

Is it possible to change this line so it checks for a DateTime instance?

What I want to achieve is the following:

Model::remember(Carbon::now()->addSeconds(30))->get();

This is just an example. Basically, in some cases it would be more practicable to have the possibilty to enter the expiration date as a DateTime, not in minutes (for example, if I want to use seconds instead or maybe one month as a DateTime instead of 43200 (minutes)).

Just asking, is there a way to disable all caching from just one point? Just came across a few issues that would've been solved had I remembered I was caching things.

There are far better alternatives to md5, which don't have surprisingly feasible collisions.

This will cause people who update to have to re-fetch their query data, and their existing md5'd data will go stale and may not be removed if it was remembered forever.

Except for that, this is reasonably backwards compatible (as in it will only break if a user is relying on the query cache entirely because all tables/data have been removed, and so on).

Love this package!

This PR adds a check for a $rememberFor property on the model, and if it is set, automatically adds a call to remember($this->rememberFor) to the Builder.

This way, one can set the $rememberFor property on the model, and all queries involving a SELECT for that model will back cached.

Cheers!

Is there a way to set multiple cache tags for a query? (Sorry, first time doing something like this.) If not, is there a way to flush tags using regular expressions? (e.g. flush all tags with "user:1") Thank you for this BTW! Was looking for remember() and was not disappointed.

This means that people on, say, Redis can drop all keys that match rememberable:*, and people with taggable stores can still identify rememberable cache entries.

Sticking this one in an issue so it's a little easier to keep track of.

There's a few things that would be really nice for this project that would require a new major version, and one of my PRs requires that anyway, so I thought I'd bring up discussion here.

• [x] Switch from md5 to sha256 for cache keys (#27)
• [x] Use a (configurable) cache prefix (#28)
• [ ] Add tests for the Query Builder
• [ ] Configure travis-ci

Hello, We have a problem where Redis key created by this package is using alot of memory. It's named like this : br-local:5f58eab33aae5665049267:standard_ref and contains values like this: Even when using flushCache() method, these records are not cleared... Is this normal behavior?

Project.php

class Project extends Model
{	
    use Rememberable;

    public $rememberCacheTag = 'project_queries';
    public $rememberFor = 60*60*24;
	
    public function users()
    {
        return $this->morphToMany(User::class, 'model','model_has_users');
    }

User.php

class User extends Authenticatable
    {
        use Rememberable;
    
        public $rememberCacheTag = 'user_queries';
        public $rememberFor = 60*60*24;
        
    public function projects()
    {
        return $this->hasMany(Project::class);
    }

Now this works:

Cache::flush();

And this does not:

Project::flushCache('project_queries');

Project::find(1)->name (refreshed) Project::find(1)->users (not refreshed)

help!?

If i query a realtion with withCount() the counting is never been refreshed, even after flushing the cache. The counting only works if I add dontRemember() to the query...

I tried to use the cache with nested eager loading, but didn't cache that part of the query:

$query->with(['feedback.profile' => function ($query) {
	//Cache
	$cacheTime = 60;
	$query->remember($cacheTime);
}]);

It does however work with a simple eager loading:

$query->with(['feedback' => function ($query) {
	//Cache
	$cacheTime = 60;
	$query->remember($cacheTime);
}]);

The setup is phpunit & array cache driver. And I've tapped in to the cache using:

$cache = \Cache::store();

The line below:

$paginator = SomeModel::paginate($perPage)->load('relation');

After that, I've found that there are two entries in the cache: the aggregate & relation. The main model (record) is missed.

While traced a bit, I was led to the line, which traced back to query builder (not eloquent builder) getCountForPagination()

public function getCountForPagination($columns = ['*'])
{
    $this->backupFieldsForCount();

    $this->aggregate = ['function' => 'count', 'columns' => $this->clearSelectAliases($columns)];

    $results = $this->get();    // <<<<<< THIS LINE

    $this->aggregate = null;

    $this->restoreFieldsForCount();

    if (isset($this->groups)) {
        return count($results);
    }

    return isset($results[0]) ? (int) array_change_key_case((array) $results[0])['aggregate'] : 0;
}

Then the subsequent call to forPage()->get() will not hit the cache. Because the $cacheMinutes property was set to null in the closure returned by getCacheCallback(). Which ends up failing the non-null test in get().

public function paginate($perPage = 15, $columns = ['*'], $pageName = 'page', $page = null)
{
    $page = $page ?: Paginator::resolveCurrentPage($pageName);

    $total = $this->getCountForPagination($columns);

    $results = $this->forPage($page, $perPage)->get($columns);   // <<<<<<< THIS WON'T HIT CACHE

    return new LengthAwarePaginator($results, $total, $perPage, $page, [
        'path' => Paginator::resolveCurrentPath(),
        'pageName' => $pageName,
    ]);
}