24. Локалізація в БД. Підходи до збереження локалізованих даних у базі даних. Кешування таблиць БД

Відео версія
(YouTube - для зворотнього зв'язку)

Окрема колонка для кожної мови

Для кожного локалізованого поля створюються окремі колонки в таблиці, наприклад, title_en, title_ua. Це дуже зрозумілий підхід і він працює.

Проте має низку недоліків:

При додаванні нової мови доведеться створювати численні міграції для кожної сутності та кожної локалізованої колонки.
Керувати таблицею з великою кількістю додаткових колонок для різних мов незручно.

Рекомендую використовувати цей підхід у дуже обмежених випадках, коли у вас мало сутностей і ви не плануєте масштабувати проект.

Окрема таблиця з текстами локалізації

Створюється окрема поліморфна таблиця з полем, яке визначає унікальний тип локалізації (title, description тощо), та полем, що вказує на локаль.

Далі, або за допомогою join, або with, отримуємо необхідні нам поля.

Цей варіант є практичнішим, проте:

Необхідно оптимізувати запити, як для звичайної вибірки, так і для пошуку за полями. Або ж використовувати кешування.
Таблиця з локалізацією повинна бути доступною у всіх моделях і сервісах, де може бути локалізоване поле. Або ж її можна винести в окремий сервіс, що ще більше підвищує необхідність оптимізації.
Є варіант створення окремої таблиці або таблиць для кожної сутності, що потребує перекладу. Це ізолює дані в модулі, але сортування та пошук все одно будуть здійснюватися за допомогою join, і питання оптимізації залишається актуальним.
Колонка з текстом зазвичай матиме тип Text, що покриє будь-які варіанти перекладу, але це впливає на оптимізацію.

Цей варіант виглядає набагато краще, ніж окремі колонки, як мінімум, він легше масштабується.

Будьте обережні з готовими рішеннями, особливо в проєктах з високим навантаженням.

JSON

Тут усе просто — зберігаємо локалізоване поле у вигляді JSON (jsonb для Postgres).

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

Це мій вибір. Він дозволяє зберігати будь-яку кількість мов, реалізовувати унікальну fallback логіку і, головне, ізолювати всі дані всередині сутності. Звісно, є й мінуси: оптимізація при сортуванні та пошуку за локалізованим полем.

Дуже раджу звертати увагу на функціонал готових рішень. Часто вони для кожної дії дістають усі варіанти локалізації, що не є оптимальним, якщо у вас багато мов.

Для надійної оптимізації я реалізував власний варіант для Laravel Eloquent.

Доступні локалі оформив у вигляді Enum. Це дозволяє легко маніпулювати мовами, а також зберігати обрану мову або мови у БД.

Моє рішення виглядає так:

<?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 у Laravel

Тут усе просто: або беремо локаль із заголовка, або встановлюємо локаль за замовчуванням.

<?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);
    }
}

І обовязково викликайте його на кожен api запит

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

Кешування всієї таблиці (словників)

Усі списки сутностей, що змінюються рідко (категорії, теги, групи тощо), можна назвати "словниками". Словники доцільно кешувати, це дає суттєвий приріст в оптимізації. Головне — не забувайте чистити кеш при оновленні, видаленні або додаванні записів до словника.

Що стосується eager loading, повноцінно використовувати кеш тут не вийде, запит до БД все одно доведеться робити, щоб отримати дані. Query builder не працює з кешем, і в цьому немає великого сенсу, якщо запит вже є.

 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);
    });
}

Будьте обережні з пакетами, що кешують кожен запит. Пам'ятайте, що кеш зазвичай зберігається в оперативній пам'яті. Однак це може бути доцільним у деяких ситуаціях.

Масив Enums

Laravel має готовий каст для масиву переліків. Проте, на жаль, він не працює з Postgres. Ось приклад касту для 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);
    }
}

Не зупиняймося!

Charity Foundation
Serhiy
Prytula

24. Локалізація в БД. Підходи до збереження локалізованих даних у базі даних. Кешування таблиць БД

Відео версія (YouTube - для зворотнього зв'язку)

Відео версія
(YouTube - для зворотнього зв'язку)