24. Localization in Databases. Approaches to Storing Localized Data in a Database. Caching Database Tables

Video version
(Leave your feedback on YouTube)

Separate Column for Each Language

For each localized field, separate columns are created in the table, for example, title_en, title_ua. This is a very straightforward approach, and it works.

However, it has several drawbacks:

When adding a new language, you will have to create numerous migrations for each entity and each localized column.
Managing a table with many additional columns for different languages is inconvenient.

I recommend using this approach in very limited cases, when you have few entities and do not plan to scale the project.

Separate Table with Localization Texts

A separate polymorphic table is created with a field that defines a unique type of localization (title, description, etc.) and a field that specifies the locale.

Then, either by using join or with, we retrieve the necessary fields.

This option is more practical, but:

It requires significant query optimization, both for regular selection and for searching fields. Or you can use caching.
The localization table should be accessible in all models and services where a localized field may exist. Alternatively, it can be moved to a separate service, which further increases the need for optimization.
There's an option to create a separate table or tables for each entity that requires translation. This isolates the data within the module, but sorting and searching will still be done via join, so optimization remains an issue.
The column with the text will usually have a Text type, which will cover any translation options, but it has an impact on optimization.

This option looks much better than separate columns. At the very least, it scales more easily.

Be cautious with ready-made solutions, especially in high-load projects.

JSON

This is straightforward — we store the localized field as JSON (jsonb for Postgres).

{
  "en": "Title in English",
  "ua": "Заголовок українською"
}

This is my choice. It allows you to store any number of languages, implement unique fallback logic, and most importantly, isolate all data within the entity. Of course, there are downsides, such as optimization when sorting and searching for a localized field.

I strongly recommend paying attention to the functionality of ready-made solutions. Often, they retrieve all localization variants for every action, which is not ideal if you have many languages.

For reliable optimization, I implemented my own solution for Laravel Eloquent.

I formatted the available locales in an Enum. This makes it easy to manipulate languages and store the selected language or languages in the database.

My solution:

<?php

namespace App\Enums;

use Illuminate\Support\Collection;
use Modules\Auth\Models\User;
use OpenApi\Attributes as OA;

#[OA\Schema(type: 'string', default: 'en')]
enum Locale: string
{
    case en = 'en';
    case uk = 'uk';
    case pt = 'pt';

    public static function dbType(): string
    {
        return 'locale';
    }

    public static function default(): string
    {
        return self::en->value;
    }

    /**
     * Priority can break SEO!
     */
    public static function priorities(): array
    {
        return [
            self::en->value,
            self::uk->value,
            self::pt->value,
        ];
    }

    public static function actualPriorities(): Collection
    {
        $locale = app()->getLocale();
        /** @var User|null $user */
        $user = auth()->user();
        $userPriorities = array_column($user?->locales ?? [], 'value');

        return collect([$locale, ...$userPriorities, ...self::priorities()])
            ->unique()
            ->values();
    }

    public static function isLocaleArray(array $value): bool
    {
        $keys = array_keys($value);
        $locales = array_column(self::cases(), 'value');

        foreach ($keys as $key) {
            if (! in_array($key, $locales)) {
                return false;
            }
        }

        return true;
    }
}

<?php

namespace Tests\Unit\Enums;

use App\Contracts\EnumDB;
use App\Enums\Locale;
use App\Traits\Tests\TestEnum;
use Tests\TestCase;

class LocaleTest extends TestCase
{
    use TestEnum;

    /**
     * @test
     */
    public function hasLocalesPriorities(): void
    {
        $this->assertEquals(
            [
                Locale::en->value, Locale::uk->value, Locale::pt->value,
            ],
            Locale::priorities()
        );
    }

    /**
     * @test
     */
    public function canGetActualPriorities(): void
    {
        $currentLocale = 'pl';
        $this->app->setLocale($currentLocale);
        $actualPriority = Locale::actualPriorities();
        $excepted = collect([$currentLocale, ...Locale::priorities()]);

        $this->assertEquals($excepted, $actualPriority);
    }

    /**
     * @test
     */
    public function canGetActualPrioritiesWithoutDuplication(): void
    {
        $defaultPriorities = Locale::priorities();
        $this->app->setLocale($defaultPriorities[0]);

        $actualPriority = Locale::actualPriorities();

        $this->assertSameSize($defaultPriorities, $actualPriority);
    }

    /**
     * @test
     */
    public function canGetActualPriorityWithUserPriority(): void
    {
        $user = \Modules\Auth\Models\User::factory()->create([
            'locales' => [Locale::pt, Locale::uk, Locale::en],
        ]);

        $this->actingAs($user);

        $this->app->setLocale(Locale::en->value);

        $excepted = collect(array_column([Locale::en, Locale::pt, Locale::uk], 'value'));

        $actualPriority = Locale::actualPriorities();

        $this->assertEquals($excepted, $actualPriority);
    }

    /**
     * @test
     */
    public function hasDefaultLocale(): void
    {
        $this->assertEquals(Locale::en->value, Locale::default());
    }

    /**
     * @test
     */
    public function canCheckLocaleArray(): void
    {
        $localeArray = [
            Locale::uk->value => 'text uk',
            Locale::en->value => null,
            Locale::pt->value => null,
        ];

        $this->assertTrue(Locale::isLocaleArray($localeArray));

        $wrongLocaleArray = [
            Locale::uk->value => 'text uk',
            'wrong' => 'someWrong',
            Locale::pt->value => null,
        ];

        $this->assertFalse(Locale::isLocaleArray($wrongLocaleArray));
    }

    private function testedEnum(): string|EnumDB
    {
        return Locale::class;
    }
}

<?php

namespace App\Traits;

use App\Casts\Translatable;
use App\Enums\Locale;
use Illuminate\Contracts\Database\Query\Expression;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\App;
use Illuminate\Support\Facades\DB;

/**
 * @mixin Model
 *
 * @method Builder|static selectTranslated(array $columns, bool $fallback = true)
 *
 * @see HasTranslations::scopeSelectTranslated
 */
trait HasTranslations
{
    public function initializeHasTranslations(): void
    {
        $translatable = $this->translatableColumns();

        $casts = array_fill_keys($translatable, Translatable::class);

        $this->mergeCasts($casts);
    }

    public function scopeSelectTranslated(
        Builder $query,
        array $columns,
        bool $fallback = true,
    ): void {
        $locale = App::getLocale();

        $translatableSelect = array_map(
            fn ($column) => $this->getTranslatableRaw($column, $locale, $fallback),
            $columns
        );

        $query->addSelect($translatableSelect);
    }

    public function getTranslated(
        string $column,
        bool $fallback = true,
    ) {
        $attribute = $this->getAttribute($column);

        if (! is_array($attribute) || ! Locale::isLocaleArray($attribute)) {
            return $attribute;
        }

        $locale = App::getLocale();

        if (! $fallback) {
            return $attribute[$locale];
        }

        $priorities = Locale::actualPriorities();
        foreach ($priorities as $priority) {
            if (! empty($attribute[$priority])) {
                return $attribute[$priority];
            }
        }

        return null;
    }

    abstract private function translatableColumns(): array;

    private function getTranslatableRaw(
        string $column,
        string $locale,
        bool $fallback,
    ): Expression {
        $spliceByAlias = explode(' as ', $column);

        $priorities = Locale::actualPriorities();

        $column = $spliceByAlias[0];

        $spliceByDot = explode('.', $column);

        $alias = $spliceByAlias[1] ?? $spliceByDot[1] ?? $spliceByDot[0];

        if (! $fallback) {
            return DB::raw("{$column}->>'{$locale}' as \"{$alias}\"");
        }

        $raw = $priorities->map(fn ($locale) => "{$column}->>'{$locale}'")->join(', ');
        return DB::raw("COALESCE({$raw}) as \"{$alias}\"");
    }
}

<?php

namespace App\Casts;

use App\Enums\Locale;
use Exception;
use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Str;

class Translatable implements CastsAttributes
{
    /**
     * @phpcsSuppress SlevomatCodingStandard.Functions.UnusedParameter
     */
    public function get(Model $model, string $key, mixed $value, array $attributes): mixed
    {
        if (Str::isJson($value)) {
            return json_decode($value, true);
        }

        return $value;
    }

    /**
     * @phpcsSuppress SlevomatCodingStandard.Functions.UnusedParameter
     *
     * @throws Exception
     */
    public function set(Model $model, string $key, mixed $value, array $attributes): mixed
    {
        if (! Locale::isLocaleArray($value)) {
            throw new Exception('Wrong Locale format');
        }
        if ($value) {
            return json_encode($value);
        }

        return $value;
    }
}

<?php

namespace Tests\Unit\Traits\HasTranslations;

use App\Enums\Locale;
use Exception;
use Tests\TestCase;
use Tests\Unit\Traits\HasTranslations\Resource\ModelForTestHasTranslations;

class HasTranslationTest extends TestCase
{
    /**
     * @test
     */
    public function canSetTranslatableField()
    {
        $model = new ModelForTestHasTranslations();

        $translatableValue = [
            Locale::en->value => 'text en',
            Locale::uk->value => 'text uk',
        ];

        $model->translatable = $translatableValue;

        $model->save();

        $this->assertDatabaseHas('model_for_test_has_translations', [
            'id' => $model->id,
            'translatable' => json_encode($translatableValue),
            'translatable_nullable' => null,
        ]);
    }

    /**
     * @test
     */
    public function canGetFullTranslation()
    {
        $translatableValue = [
            Locale::en->value => 'text en',
            Locale::uk->value => 'text uk',
        ];
        $model = ModelForTestHasTranslations::create([
            'translatable' => $translatableValue,
        ]);

        $result = ModelForTestHasTranslations::find($model->id);

        $this->assertEquals($translatableValue, $result->translatable);
    }

    /**
     * @test
     */
    public function canGetSingleTranslatedValue()
    {
        $translatableValue = [
            Locale::en->value => 'text en',
            Locale::uk->value => 'text uk',
        ];
        $model = ModelForTestHasTranslations::create([
            'translatable' => $translatableValue,
        ]);

        $result = ModelForTestHasTranslations::selectRaw("translatable->>'en' as translatable")
            ->whereId($model->id)
            ->first();

        $this->assertEquals($translatableValue[Locale::en->value], $result->translatable);
    }

    /**
     * @test
     */
    public function canUseTranslatedSafetyForCasts()
    {
        $collectionDate = ['aaa', 'bbb'];
        $model = ModelForTestHasTranslations::create([
            'translatable' => [Locale::en->value => 'text en'],
            'some_field' => $collectionDate,
        ]);

        $result = ModelForTestHasTranslations::find($model->id);

        $this->assertEquals(collect($collectionDate), $result->some_field);
    }

    /**
     * @test
     */
    public function canSelectTranslated()
    {
        $translatableValue = [
            Locale::en->value => 'text en',
            Locale::uk->value => 'text uk',
        ];

        $translatableControlValue = [
            Locale::en->value => 'text en 1',
            Locale::uk->value => null,
        ];

        $model = ModelForTestHasTranslations::create([
            'translatable' => $translatableValue,
            'translatable_control' => $translatableControlValue,
        ]);

        foreach (array_keys($translatableValue) as $locale) {
            app()->setLocale($locale);

            $result = ModelForTestHasTranslations::selectTranslated(
                columns: [
                    'translatable',
                    'translatable as translatable_alias',
                    'model_for_test_has_translations.translatable_control',
                    'model_for_test_has_translations.translatable_control as control_alias',
                    'translatable_nullable',
                    'translatable_nullable as translatable_nullable_alias',
                ],
                fallback: false
            )
                ->whereId($model->id)
                ->first();

            $this->assertEquals($translatableValue[$locale], $result->translatable);
            $this->assertEquals($translatableValue[$locale], $result->translatable_alias);
            $this->assertEquals($translatableControlValue[$locale], $result->translatable_control);
            $this->assertEquals($translatableControlValue[$locale], $result->control_alias);
            $this->assertNull($result->translatable_nullable);
            $this->assertNull($result->translatable_nullable_alias);
        }
    }

    /**
     * @test
     */
    public function canSelectTranslatableFallback()
    {
        $ukExistingText = 'text uk';
        $enExistingText = 'text en';

        $model = ModelForTestHasTranslations::create([
            'translatable' => [
                Locale::uk->value => $ukExistingText,
            ],
            'translatable_control' => [
                Locale::en->value => $enExistingText,
                Locale::uk->value => null,
            ],
        ]);

        app()->setLocale(Locale::en->value);

        $result = ModelForTestHasTranslations::selectTranslated(
            columns: [
                'translatable',
                'translatable as translatable_alias',
                'model_for_test_has_translations.translatable_control',
                'model_for_test_has_translations.translatable_control as control_alias',
            ]
        )
            ->whereId($model->id)
            ->first();

        $this->assertEquals($ukExistingText, $result->translatable);
        $this->assertEquals($ukExistingText, $result->translatable_alias);
        $this->assertEquals($enExistingText, $result->translatable_control);
        $this->assertEquals($enExistingText, $result->control_alias);
    }

    /**
     * @test
     */
    public function canUseCurrentLocaleAsHirePriority()
    {
        $translatableValue = [
            Locale::uk->value => 'text uk',
            Locale::en->value => 'text en',
            Locale::pt->value => 'text pt',
        ];
        $model = ModelForTestHasTranslations::create([
            'translatable' => $translatableValue,
        ]);
        foreach (array_keys($translatableValue) as $locale) {
            app()->setLocale($locale);

            $result = ModelForTestHasTranslations::selectTranslated(['translatable'])
                ->whereId($model->id)
                ->first();

            $this->assertEquals($translatableValue[$locale], $result->translatable);
        }
    }

    /**
     * @test
     */
    public function canGetTranslated()
    {
        $translatableValue = [
            Locale::uk->value => 'text uk',
            Locale::en->value => null,
            Locale::pt->value => 'text pt',
        ];
        $model = ModelForTestHasTranslations::create([
            'translatable' => $translatableValue,
        ]);

        foreach (array_keys($translatableValue) as $locale) {
            app()->setLocale($locale);

            $result = $model->getTranslated(
                column: 'translatable',
                fallback: false
            );

            $this->assertEquals($translatableValue[$locale], $result);
        }
    }

    /**
     * @test
     */
    public function canGetTranslatedFallback()
    {
        $translatableValue = [
            Locale::uk->value => 'text uk',
            Locale::en->value => null,
            Locale::pt->value => null,
        ];
        $model = ModelForTestHasTranslations::create([
            'translatable' => $translatableValue,
        ]);

        app()->setLocale(Locale::en->value);

        $result = $model->getTranslated('translatable');

        $this->assertEquals($translatableValue[Locale::uk->value], $result);
    }

    /**
     * @test
     */
    public function canGetTranslationIfAttributeString()
    {
        $translatableValue = [Locale::en->value => 'text en'];
        $model = ModelForTestHasTranslations::create([
            'translatable' => $translatableValue,
        ]);
        app()->setLocale(Locale::en->value);

        $result = ModelForTestHasTranslations::selectTranslated(['translatable'])
            ->whereId($model->id)
            ->first();

        $this->assertEquals($translatableValue[Locale::en->value], $result->getTranslated('translatable'));
    }

    /**
     * @test
     */
    public function canGetTranslatedArrayValue()
    {
        $translatableValue = [
            Locale::en->value => ['some' => 'some en'],
        ];
        $model = ModelForTestHasTranslations::create([
            'translatable' => $translatableValue,
        ]);

        app()->setLocale(Locale::en->value);

        $result = ModelForTestHasTranslations::selectTranslated(['translatable'])
            ->whereId($model->id)
            ->first();

        $this->assertEquals($translatableValue[Locale::en->value], $result->getTranslated('translatable'));
    }

    /**
     * @test
     */
    public function canGetExceptionOnSaveNotLocaleValue()
    {
        $this->expectException(Exception::class);
        $this->expectExceptionMessage('Wrong Locale format');
        ModelForTestHasTranslations::create([
            'translatable' => [
                'some_wrong' => 'wrong',
            ],
        ]);
    }
}

<?php

namespace Tests\Unit\Traits\HasTranslations\Resource;

use App\Traits\HasTranslations;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class ModelForTestHasTranslations extends Model
{
    use HasTranslations;

    public $guarded = ['id'];
    public $timestamps = false;

    protected $casts = [
        'some_field' => 'collection',
    ];

    public static function booted(): void
    {
        Schema::dropIfExists('model_for_test_has_translations');
        Schema::create('model_for_test_has_translations', function (Blueprint $table) {
            $table->id();
            $table->jsonb('translatable');
            $table->jsonb('translatable_nullable')->nullable();
            $table->jsonb('translatable_control')->nullable();

            $table->jsonb('some_field')->nullable();
        });
    }

    protected function translatableColumns(): array
    {
        return [
            'translatable',
            'translatable_nullable',
            'translatable_control',
        ];
    }
}

Locale Middleware in Laravel

This is straightforward: either take the locale from the header or set the default locale.

<?php

namespace App\Http\Middleware;

use App\Enums\Locale;
use Closure;
use Illuminate\Http\Request;

class Localize
{
    public function handle(Request $request, Closure $next): mixed
    {
        $locale = $request->header('X-Locale') ?? Locale::default();
        $locale = Locale::tryFrom($locale)?->value;
        if ($locale) {
            app()->setLocale($locale);
        }

        return $next($request);
    }
}

Mandatory add middleware to api calls

  protected $middlewareGroups = [
        'api' => [
            \App\Http\Middleware\Localize::class,
        ],
    ];

Caching the Entire Table (Dictionaries)

All entity lists that change infrequently (categories, tags, groups, etc.) can be considered "dictionaries". It's advisable to cache dictionaries, as this gives a significant optimization boost. The main thing is not to forget to clear the cache when updating, deleting, or adding records to the dictionary.

As for eager loading, fully utilizing the cache here won’t work; you'll still need to query the database to retrieve the data, and query builders don't work with caches, and there's not much sense in it if the query is already there.

 return Cache::rememberForever(Dictionary::LIST_CACHE_KEY, function () {
            return Dictionary::select([
                'id', 
                'name'
            ])
                ->get();
        });
    }

public const string LIST_CACHE_KEY = 'genre_list';

public static function boot(): void
{
    parent::boot();

    static::created(function () {
        Cache::forget(self::LIST_CACHE_KEY);
    });

    static::updated(function () {
        Cache::forget(self::LIST_CACHE_KEY);
    });

    static::deleted(function () {
        Cache::forget(self::LIST_CACHE_KEY);
    });
}

Be cautious with packages that cache every query. Remember, cache is usually stored in RAM. However, it can make sense in some situations.

Array Enums

Laravel has a built-in cast for an array of enumerations. Unfortunately, it doesn't work with Postgres. Here is an example of a cast for Postgres:

<?php

namespace App\Casts;

use App\Services\Database\PostgresAdapter;
use BackedEnum;
use Illuminate\Contracts\Database\Eloquent\Castable;
use Illuminate\Contracts\Database\Eloquent\CastsAttributes;

class EnumSet implements Castable
{
    public static function castUsing(array $arguments): CastsAttributes
    {
        return new class($arguments) implements CastsAttributes {
            protected array $arguments;

            public function __construct(array $arguments)
            {
                $this->arguments = $arguments;
            }
            /**
             * @phpcsSuppress SlevomatCodingStandard.Functions.UnusedParameter
             */
            public function get($model, $key, $value, $attributes): ?array
            {
                if (! $value) {
                    return null;
                }
                $data = PostgresAdapter::pgArrayStringToArray($value);

                $enumClass = $this->arguments[0];

                return array_map(
                    fn ($value) => is_subclass_of($enumClass, BackedEnum::class)
                        ? $enumClass::from($value)
                        : constant($enumClass.'::'.$value),
                    $data
                );
            }
            /**
             * @phpcsSuppress SlevomatCodingStandard.Functions.UnusedParameter
             */
            public function set($model, $key, $value, $attributes): ?string
            {
                if (! $value) {
                    return null;
                }
                $stringValues = array_map(
                    fn ($enum) => $enum instanceof BackedEnum ? $enum->value : $enum->name,
                    $value
                );

                return PostgresAdapter::arrayToPgArrayString($stringValues);
            }
        };
    }

    public static function of($class): string
    {
        return static::class.':'.$class;
    }
}

<?php

namespace Tests\Unit\Casts\EnumSet;

use App\Casts\EnumSet;
use Tests\TestCase;
use Tests\Unit\Casts\EnumSet\Resource\EnumSetTestBackendEnumeration;
use Tests\Unit\Casts\EnumSet\Resource\EnumSetTestEnumeration;

class EnumSetTest extends TestCase
{
    /**
     * @test
     */
    public function canSetRegularEnumeration(): void
    {
        $cast = EnumSet::castUsing([EnumSetTestEnumeration::class]);

        $result = $cast->set(
            model: new \stdClass(),
            key: 'some_key',
            value: [EnumSetTestEnumeration::AA, EnumSetTestEnumeration::CC],
            attributes: []
        );

        $this->assertEquals('{AA,CC}', $result);
    }

    /**
     * @test
     */
    public function canSetBackendEnumeration(): void
    {
        $cast = EnumSet::castUsing([EnumSetTestBackendEnumeration::class]);

        $result = $cast->set(
            model: new \stdClass(),
            key: 'some_key',
            value: [EnumSetTestBackendEnumeration::AA, EnumSetTestBackendEnumeration::CC],
            attributes: []
        );

        $this->assertEquals('{aa,cc}', $result);
    }

    /**
     * @test
     */
    public function canGetRegularEnumeration(): void
    {
        $cast = EnumSet::castUsing([EnumSetTestEnumeration::class]);

        $result = $cast->get(
            model: new \stdClass(),
            key: 'some_key',
            value: '{AA,CC}',
            attributes: []
        );

        $this->assertEquals([EnumSetTestEnumeration::AA, EnumSetTestEnumeration::CC], $result);
    }

    /**
     * @test
     */
    public function canGetNull(): void
    {
        $cast = EnumSet::castUsing([EnumSetTestEnumeration::class]);

        $result = $cast->get(
            model: new \stdClass(),
            key: 'some_key',
            value: null,
            attributes: []
        );

        $this->assertNull($result);
    }

    /**
     * @test
     */
    public function canSetNull(): void
    {
        $cast = EnumSet::castUsing([EnumSetTestEnumeration::class]);

        $result = $cast->set(
            model: new \stdClass(),
            key: 'some_key',
            value: null,
            attributes: []
        );

        $this->assertNull($result);
    }

    /**
     * @test
     */
    public function canGetBackendEnumeration(): void
    {
        $cast = EnumSet::castUsing([EnumSetTestBackendEnumeration::class]);

        $result = $cast->get(
            model: new \stdClass(),
            key: 'some_key',
            value: '{aa,cc}',
            attributes: []
        );

        $this->assertEquals([EnumSetTestBackendEnumeration::AA, EnumSetTestBackendEnumeration::CC], $result);
    }
}

<?php

namespace Tests\Unit\Casts\EnumSet\Resource;

enum EnumSetTestBackendEnumeration: string
{
    case AA = 'aa';
    case BB = 'bb';
    case CC = 'cc';
}

<?php

namespace Tests\Unit\Casts\EnumSet\Resource;

enum EnumSetTestEnumeration
{
    case AA;
    case BB;
    case CC;
}

<?php

namespace App\Services\Database;

class PostgresAdapter
{
    public static function pgArrayStringToArray(string $value): ?array
    {
        $trimmed = ltrim($value, '{');
        $trimmed = rtrim($trimmed, '}');

        return explode(',', $trimmed);
    }

    public static function arrayToPgArrayString(array $value): ?string
    {
        if (! $value) {
            return null;
        }
        $imploded = implode(',', $value);

        return '{'.$imploded.'}';
    }
}

<?php

namespace Tests\Unit\Service\Database;

use App\Services\Database\PostgresAdapter;
use Tests\TestCase;

class PostgresAdapterTest extends TestCase
{
    /**
     * @test
     */
    public function canConvertArrayToPGString(): void
    {
        $array = ['aa', 'bb', 'cc'];
        $result = PostgresAdapter::arrayToPgArrayString($array);
        $this->assertEquals('{aa,bb,cc}', $result);
    }

    /**
     * @test
     */
    public function canConvertPGStringToArray(): void
    {
        $result = PostgresAdapter::pgArrayStringToArray('{aa,bb,cc}');
        $this->assertEquals(['aa', 'bb', 'cc'], $result);
    }
}

Help to survive

Charity Foundation
Serhiy
Prytula

24. Localization in Databases. Approaches to Storing Localized Data in a Database. Caching Database Tables

Video version (Leave your feedback on YouTube)

Video version
(Leave your feedback on YouTube)