1. Go to this page and download the library: Download megaads/laravel-query-cache library. Choose the download type require.
2. Extract the ZIP file and open the index.php.
3. Add this code to the index.php.
<?php
require_once('vendor/autoload.php');
/* Start to develop here. Best regards https://php-download.com/ */
megaads / laravel-query-cache example snippets
use Rennokki\QueryCache\Traits\QueryCacheable;
class Podcast extends Model
{
use QueryCacheable;
...
}
use Rennokki\QueryCache\Traits\QueryCacheable;
class Article extends Model
{
use QueryCacheable;
public $cacheFor = 3600; // cache time, in seconds
...
}
// SELECT * FROM articles ORDER BY created_at DESC LIMIT 1;
$latestArticle = Article::latest()->first();
// SELECT * FROM articles WHERE published = 1;
$publishedArticles = Article::wherePublished(true)->get();
$postsCount = Post::cacheFor(60 * 60)->count();
// Using a DateTime instance like Carbon works perfectly fine!
$postsCount = Post::cacheFor(now()->addDays(1))->count();
$shelfOneBooks = Book::whereShelf(1)
->cacheFor(60)
->cacheTags(['shelf:1'])
->get();
$shelfTwoBooks = Book::whereShelf(2)
->cacheFor(60)
->cacheTags(['shelf:2'])
->get();
// After flushing the cache for shelf:1, the query of$shelfTwoBooks will still hit the cache if re-called again.
Book::flushQueryCache(['shelf:1']);
// Flushing also works for both tags, invalidating them both, not just the one tagged with shelf:1
Book::flushQueryCache(['shelf:1', 'shelf:2']);
class Kid extends Model
{
use QueryCacheable;
/**
* Set the base cache tags that will be present
* on all queries.
*
* @return array
*/
protected function getCacheBaseTags(): array
{
return [
'custom_tag',
];
}
}
// Automatically works with `custom_tag`
Kid::flushQueryCache();
class Page extends Model
{
use QueryCacheable;
/**
* Invalidate the cache automatically
* upon update in the database.
*
* @var bool
*/
protected static $flushCacheOnUpdate = true;
}
class Page extends Model
{
use QueryCacheable;
/**
* Invalidate the cache automatically
* upon update in the database.
*
* @var bool
*/
protected static $flushCacheOnUpdate = true;
/**
* When invalidating automatically on update, you can specify
* which tags to invalidate.
*
* @return array
*/
public function getCacheTagsToInvalidateOnUpdate(): array
{
return [
'query1',
];
}
}
$query1 = Page::cacheFor(60)
->cacheTags(['query1'])
->get();
$query2 = Page::cacheFor(60)
->cacheTags(['query2'])
->get();
// The $query1 gets invalidated
// but $query2 will still hit from cache if re-called.
$page = Page::first();
$page->update([
'name' => 'Reddit',
]);
$user = User::with(['orders' => function ($query) {
return $query
->cacheFor(60 * 60)
->cacheTags(['my:orders']);
}])->get();
// This comes from the cache if existed.
$orders = $user->orders;
$uncachedBooks = Book::dontCache()->get();
$uncachedBooks = Book::doNotCache()->get(); // same thing
class Book extends Model
{
public $cacheFor = 3600; // equivalent of ->cacheFor(3600)
public $cacheTags = ['books']; // equivalent of ->cacheTags(['books'])
public $cachePrefix = 'books_' // equivalent of ->cachePrefix('books_');
public $cacheDriver = 'dynamodb'; // equivalent of ->cacheDriver('dynamodb');
}
use Rennokki\QueryCache\Traits\QueryCacheModule;
use Illuminate\Database\Query\Builder as BaseBuilder; // the base laravel builder
use Rennokki\QueryCache\Contracts\QueryCacheModuleInterface;
// MyCustomBuilder.php
class MyCustomBuilder implements QueryCacheModuleInterface
{
use QueryCacheModule;
// the rest of the logic here.
}
// MyBuilderTrait.php
trait MyBuilderTrait
{
protected function newBaseQueryBuilder()
{
return new MyCustomBuilder(
//
);
}
}
// app/CustomModel.php
class CustomModel extends Model
{
use MyBuilderTrait;
}
CustomModel::cacheFor(30)->customGetMethod();
public function generatePlainCacheKey(string $method = 'get', $id = null, $appends = null): string
{
$name = $this->connection->getName();
// Count has no Sql, that's why it can't be used ->toSql()
if ($method === 'count') {
return $name.$method.$id.serialize($this->getBindings()).$appends;
}
return $name.$method.$id.$this->toSql().serialize($this->getBindings()).$appends;
}
class MyCustomBuilder implements QueryCacheModuleInterface
{
use QueryCacheModule;
public function generatePlainCacheKey(string $method = 'get', $id = null, $appends = null): string
{
$name = $this->connection->getName();
// Using ->myCustomSqlString() instead of ->toSql()
return $name.$method.$id.$this->myCustomSqlString().serialize($this->getBindings()).$appends;
}
}
class Builder
{
public function get($columns = ['*'])
{
if (! $this->shouldAvoidCache()) {
return $this->getFromQueryCache('get', $columns);
}
return parent::get($columns);
}
}
class MyCustomBuilder
{
public function count()
{
if (! $this->shouldAvoidCache()) {
return $this->getFromQueryCache('count');
}
return parent::count();
}
}
class MyCustomBuilder
{
public function getQueryCacheCallback(string $method = 'get', $columns = ['*'], $id = null)
{
return function () use ($method, $columns, $id) {
$this->avoidCache = true;
// the function for find() caching
// accepts different params
if ($method === 'find') {
return $this->find($id, $columns);
}
return $this->{$method}($columns);
};
}
public function find($id, $columns = ['*'])
{
// implementing the same logic
if (! $this->shouldAvoidCache()) {
return $this->getFromQueryCache('find', $columns, $id);
}
return parent::find($id, $columns);
}
}
Loading please wait ...
Before you can download the PHP files, the dependencies should be resolved. This can take some minutes. Please be patient.