Integration with Laravel

This guide covers integration with Laravel 11.x+ using the community-supported Laravel Doctrine package (laravel-doctrine/orm v3.x).

Installation

First, install Laravel Doctrine ORM:

composer require laravel-doctrine/orm

Then publish the configuration:

php artisan vendor:publish --tag="config" --provider="LaravelDoctrine\ORM\DoctrineServiceProvider"

Register DBAL Types

Register the DBAL types you plan to use. The full set of available types can be found in AVAILABLE-TYPES.md.

The per-manager mapping_types block maps PostgreSQL’s own type names (like _text or jsonb) to the registered Doctrine types, and is the Laravel equivalent of calling registerDoctrineTypeMapping() on the platform.

<?php
// config/doctrine.php

return [
    // ... other configuration

    'managers' => [
        'default' => [
            // ... other configuration

            'mapping_types' => [
                // Binary type mappings
                'bytea' => 'bytea',
                'bytea[]' => 'bytea[]',
                '_bytea' => 'bytea[]',

                // Bit type mappings
                'bit' => 'bit',
                'bit[]' => 'bit[]',
                '_bit' => 'bit[]',
                'bit varying' => 'bit varying',
                'varbit' => 'bit varying',
                'bit varying[]' => 'bit varying[]',
                '_varbit' => 'bit varying[]',

                // Array type mappings
                '_bool' => 'bool[]',
                'bool[]' => 'bool[]',
                'smallint[]' => 'smallint[]',
                '_int2' => 'smallint[]',
                'integer[]' => 'integer[]',
                '_int4' => 'integer[]',
                'bigint[]' => 'bigint[]',
                '_int8' => 'bigint[]',
                'double precision[]' => 'double precision[]',
                '_float8' => 'double precision[]',
                'numeric[]' => 'numeric[]',
                '_numeric' => 'numeric[]',
                'real[]' => 'real[]',
                '_float4' => 'real[]',
                '_text' => 'text[]',
                'text[]' => 'text[]',
                'uuid[]' => 'uuid[]',
                '_uuid' => 'uuid[]',
                'varchar[]' => 'varchar[]',
                '_varchar' => 'varchar[]',

                // Case-insensitive text type mappings
                'citext' => 'citext',
                'citext[]' => 'citext[]',
                '_citext' => 'citext[]',

                // ULID type mappings
                'ulid' => 'ulid',
                'ulid[]' => 'ulid[]',
                '_ulid' => 'ulid[]',

                // Datetime array type mappings
                'date[]' => 'date[]',
                '_date' => 'date[]',
                'interval' => 'interval',
                'interval[]' => 'interval[]',
                '_interval' => 'interval[]',
                'time[]' => 'time[]',
                '_time' => 'time[]',
                'timestamp[]' => 'timestamp[]',
                '_timestamp' => 'timestamp[]',
                'timestamptz[]' => 'timestamptz[]',
                '_timestamptz' => 'timestamptz[]',
                'timetz' => 'timetz',
                'timetz[]' => 'timetz[]',
                '_timetz' => 'timetz[]',

                // JSON type mappings
                'json[]' => 'json[]',
                '_json' => 'json[]',
                'jsonb' => 'jsonb',
                '_jsonb' => 'jsonb[]',
                'jsonb[]' => 'jsonb[]',

                // Network type mappings
                'cidr' => 'cidr',
                'cidr[]' => 'cidr[]',
                '_cidr' => 'cidr[]',
                'inet' => 'inet',
                'inet[]' => 'inet[]',
                '_inet' => 'inet[]',
                'macaddr' => 'macaddr',
                'macaddr[]' => 'macaddr[]',
                '_macaddr' => 'macaddr[]',
                'macaddr8' => 'macaddr8',
                'macaddr8[]' => 'macaddr8[]',
                '_macaddr8' => 'macaddr8[]',

                // Geometric type mappings
                'box' => 'box',
                'box[]' => 'box[]',
                '_box' => 'box[]',
                'circle' => 'circle',
                'circle[]' => 'circle[]',
                '_circle' => 'circle[]',
                'line' => 'line',
                'line[]' => 'line[]',
                '_line' => 'line[]',
                'lseg' => 'lseg',
                'lseg[]' => 'lseg[]',
                '_lseg' => 'lseg[]',
                'path' => 'path',
                'path[]' => 'path[]',
                '_path' => 'path[]',
                'point' => 'point',
                'point[]' => 'point[]',
                '_point' => 'point[]',
                'polygon' => 'polygon',
                'polygon[]' => 'polygon[]',
                '_polygon' => 'polygon[]',

                // Cube type mappings
                'cube' => 'cube',
                'cube[]' => 'cube[]',
                '_cube' => 'cube[]',

                // PostGIS spatial type mappings
                'geometry' => 'geometry',
                'geometry[]' => 'geometry[]',
                '_geometry' => 'geometry[]',
                'geography' => 'geography',
                'geography[]' => 'geography[]',
                '_geography' => 'geography[]',

                // Range type mappings
                'daterange' => 'daterange',
                'daterange[]' => 'daterange[]',
                '_daterange' => 'daterange[]',
                'int4range' => 'int4range',
                'int4range[]' => 'int4range[]',
                '_int4range' => 'int4range[]',
                'int8range' => 'int8range',
                'int8range[]' => 'int8range[]',
                '_int8range' => 'int8range[]',
                'numrange' => 'numrange',
                'numrange[]' => 'numrange[]',
                '_numrange' => 'numrange[]',
                'tsrange' => 'tsrange',
                'tsrange[]' => 'tsrange[]',
                '_tsrange' => 'tsrange[]',
                'tstzrange' => 'tstzrange',
                'tstzrange[]' => 'tstzrange[]',
                '_tstzrange' => 'tstzrange[]',

                // Multirange type mappings
                'datemultirange' => 'datemultirange',
                'datemultirange[]' => 'datemultirange[]',
                '_datemultirange' => 'datemultirange[]',
                'int4multirange' => 'int4multirange',
                'int4multirange[]' => 'int4multirange[]',
                '_int4multirange' => 'int4multirange[]',
                'int8multirange' => 'int8multirange',
                'int8multirange[]' => 'int8multirange[]',
                '_int8multirange' => 'int8multirange[]',
                'nummultirange' => 'nummultirange',
                'nummultirange[]' => 'nummultirange[]',
                '_nummultirange' => 'nummultirange[]',
                'tsmultirange' => 'tsmultirange',
                'tsmultirange[]' => 'tsmultirange[]',
                '_tsmultirange' => 'tsmultirange[]',
                'tstzmultirange' => 'tstzmultirange',
                'tstzmultirange[]' => 'tstzmultirange[]',
                '_tstzmultirange' => 'tstzmultirange[]',

                // Text search type mappings
                'tsquery' => 'tsquery',
                'tsquery[]' => 'tsquery[]',
                '_tsquery' => 'tsquery[]',
                'tsvector' => 'tsvector',
                'tsvector[]' => 'tsvector[]',
                '_tsvector' => 'tsvector[]',

                // Monetary type mappings
                'money' => 'money',
                'money[]' => 'money[]',
                '_money' => 'money[]',

                // Key-value type mappings
                'hstore' => 'hstore',
                'hstore[]' => 'hstore[]',
                '_hstore' => 'hstore[]',

                // Hierarchical type mappings
                'lquery' => 'lquery',
                'lquery[]' => 'lquery[]',
                '_lquery' => 'lquery[]',
                'ltree' => 'ltree',
                'ltree[]' => 'ltree[]',
                '_ltree' => 'ltree[]',
                'ltxtquery' => 'ltxtquery',
                'ltxtquery[]' => 'ltxtquery[]',
                '_ltxtquery' => 'ltxtquery[]',

                // XML type mappings
                'xml' => 'xml',
                'xml[]' => 'xml[]',
                '_xml' => 'xml[]',

                // Vector type mappings
                'halfvec' => 'halfvec',
                'sparsevec' => 'sparsevec',
                'vector' => 'vector'
            ],
        ],
    ],

    'custom_types' => [
        // Binary types
        'bytea' => MartinGeorgiev\Doctrine\DBAL\Types\Bytea::class,
        'bytea[]' => MartinGeorgiev\Doctrine\DBAL\Types\ByteaArray::class,

        // Bit types
        'bit' => MartinGeorgiev\Doctrine\DBAL\Types\Bit::class,
        'bit[]' => MartinGeorgiev\Doctrine\DBAL\Types\BitArray::class,
        'bit varying' => MartinGeorgiev\Doctrine\DBAL\Types\BitVarying::class,
        'bit varying[]' => MartinGeorgiev\Doctrine\DBAL\Types\BitVaryingArray::class,

        // Array types
        'bool[]' => MartinGeorgiev\Doctrine\DBAL\Types\BooleanArray::class,
        'bigint[]' => MartinGeorgiev\Doctrine\DBAL\Types\BigIntArray::class,
        'integer[]' => MartinGeorgiev\Doctrine\DBAL\Types\IntegerArray::class,
        'smallint[]' => MartinGeorgiev\Doctrine\DBAL\Types\SmallIntArray::class,
        'double precision[]' => MartinGeorgiev\Doctrine\DBAL\Types\DoublePrecisionArray::class,
        'numeric[]' => MartinGeorgiev\Doctrine\DBAL\Types\NumericArray::class,
        'real[]' => MartinGeorgiev\Doctrine\DBAL\Types\RealArray::class,
        'text[]' => MartinGeorgiev\Doctrine\DBAL\Types\TextArray::class,
        'uuid[]' => MartinGeorgiev\Doctrine\DBAL\Types\UuidArray::class,
        'varchar[]' => MartinGeorgiev\Doctrine\DBAL\Types\VarcharArray::class,

        // Case-insensitive text types
        'citext' => MartinGeorgiev\Doctrine\DBAL\Types\Citext::class,
        'citext[]' => MartinGeorgiev\Doctrine\DBAL\Types\CitextArray::class,

        // ULID types
        'ulid' => MartinGeorgiev\Doctrine\DBAL\Types\Ulid::class,
        'ulid[]' => MartinGeorgiev\Doctrine\DBAL\Types\UlidArray::class,

        // Date and time types
        'date[]' => MartinGeorgiev\Doctrine\DBAL\Types\DateArray::class,
        'interval' => MartinGeorgiev\Doctrine\DBAL\Types\Interval::class,
        'interval[]' => MartinGeorgiev\Doctrine\DBAL\Types\IntervalArray::class,
        'time[]' => MartinGeorgiev\Doctrine\DBAL\Types\TimeArray::class,
        'timestamp[]' => MartinGeorgiev\Doctrine\DBAL\Types\TimestampArray::class,
        'timestamptz[]' => MartinGeorgiev\Doctrine\DBAL\Types\TimestampTzArray::class,
        'timetz' => MartinGeorgiev\Doctrine\DBAL\Types\Timetz::class,
        'timetz[]' => MartinGeorgiev\Doctrine\DBAL\Types\TimetzArray::class,

        // JSON types
        'json[]' => MartinGeorgiev\Doctrine\DBAL\Types\JsonArray::class,
        'jsonb' => MartinGeorgiev\Doctrine\DBAL\Types\Jsonb::class,
        'jsonb[]' => MartinGeorgiev\Doctrine\DBAL\Types\JsonbArray::class,

        // Network types
        'cidr' => MartinGeorgiev\Doctrine\DBAL\Types\Cidr::class,
        'cidr[]' => MartinGeorgiev\Doctrine\DBAL\Types\CidrArray::class,
        'inet' => MartinGeorgiev\Doctrine\DBAL\Types\Inet::class,
        'inet[]' => MartinGeorgiev\Doctrine\DBAL\Types\InetArray::class,
        'macaddr' => MartinGeorgiev\Doctrine\DBAL\Types\Macaddr::class,
        'macaddr[]' => MartinGeorgiev\Doctrine\DBAL\Types\MacaddrArray::class,
        'macaddr8' => MartinGeorgiev\Doctrine\DBAL\Types\Macaddr8::class,
        'macaddr8[]' => MartinGeorgiev\Doctrine\DBAL\Types\Macaddr8Array::class,

        // Geometric types
        'box' => MartinGeorgiev\Doctrine\DBAL\Types\Box::class,
        'box[]' => MartinGeorgiev\Doctrine\DBAL\Types\BoxArray::class,
        'circle' => MartinGeorgiev\Doctrine\DBAL\Types\Circle::class,
        'circle[]' => MartinGeorgiev\Doctrine\DBAL\Types\CircleArray::class,
        'line' => MartinGeorgiev\Doctrine\DBAL\Types\Line::class,
        'line[]' => MartinGeorgiev\Doctrine\DBAL\Types\LineArray::class,
        'lseg' => MartinGeorgiev\Doctrine\DBAL\Types\Lseg::class,
        'lseg[]' => MartinGeorgiev\Doctrine\DBAL\Types\LsegArray::class,
        'path' => MartinGeorgiev\Doctrine\DBAL\Types\Path::class,
        'path[]' => MartinGeorgiev\Doctrine\DBAL\Types\PathArray::class,
        'point' => MartinGeorgiev\Doctrine\DBAL\Types\Point::class,
        'point[]' => MartinGeorgiev\Doctrine\DBAL\Types\PointArray::class,
        'polygon' => MartinGeorgiev\Doctrine\DBAL\Types\Polygon::class,
        'polygon[]' => MartinGeorgiev\Doctrine\DBAL\Types\PolygonArray::class,

        // Cube types
        'cube' => MartinGeorgiev\Doctrine\DBAL\Types\Cube::class,
        'cube[]' => MartinGeorgiev\Doctrine\DBAL\Types\CubeArray::class,

        // PostGIS spatial types
        'geometry' => MartinGeorgiev\Doctrine\DBAL\Types\Geometry::class,
        'geometry[]' => MartinGeorgiev\Doctrine\DBAL\Types\GeometryArray::class,
        'geography' => MartinGeorgiev\Doctrine\DBAL\Types\Geography::class,
        'geography[]' => MartinGeorgiev\Doctrine\DBAL\Types\GeographyArray::class,

        // Range types
        'daterange' => MartinGeorgiev\Doctrine\DBAL\Types\DateRange::class,
        'int4range' => MartinGeorgiev\Doctrine\DBAL\Types\Int4Range::class,
        'int8range' => MartinGeorgiev\Doctrine\DBAL\Types\Int8Range::class,
        'numrange' => MartinGeorgiev\Doctrine\DBAL\Types\NumRange::class,
        'tsrange' => MartinGeorgiev\Doctrine\DBAL\Types\TsRange::class,
        'tstzrange' => MartinGeorgiev\Doctrine\DBAL\Types\TstzRange::class,

        // Range array types
        'daterange[]' => MartinGeorgiev\Doctrine\DBAL\Types\DateRangeArray::class,
        'int4range[]' => MartinGeorgiev\Doctrine\DBAL\Types\Int4RangeArray::class,
        'int8range[]' => MartinGeorgiev\Doctrine\DBAL\Types\Int8RangeArray::class,
        'numrange[]' => MartinGeorgiev\Doctrine\DBAL\Types\NumRangeArray::class,
        'tsrange[]' => MartinGeorgiev\Doctrine\DBAL\Types\TsRangeArray::class,
        'tstzrange[]' => MartinGeorgiev\Doctrine\DBAL\Types\TstzRangeArray::class,

        // Multirange types
        'datemultirange' => MartinGeorgiev\Doctrine\DBAL\Types\DateMultirange::class,
        'datemultirange[]' => MartinGeorgiev\Doctrine\DBAL\Types\DateMultirangeArray::class,
        'int4multirange' => MartinGeorgiev\Doctrine\DBAL\Types\Int4Multirange::class,
        'int4multirange[]' => MartinGeorgiev\Doctrine\DBAL\Types\Int4MultirangeArray::class,
        'int8multirange' => MartinGeorgiev\Doctrine\DBAL\Types\Int8Multirange::class,
        'int8multirange[]' => MartinGeorgiev\Doctrine\DBAL\Types\Int8MultirangeArray::class,
        'nummultirange' => MartinGeorgiev\Doctrine\DBAL\Types\NumMultirange::class,
        'nummultirange[]' => MartinGeorgiev\Doctrine\DBAL\Types\NumMultirangeArray::class,
        'tsmultirange' => MartinGeorgiev\Doctrine\DBAL\Types\TsMultirange::class,
        'tsmultirange[]' => MartinGeorgiev\Doctrine\DBAL\Types\TsMultirangeArray::class,
        'tstzmultirange' => MartinGeorgiev\Doctrine\DBAL\Types\TstzMultirange::class,
        'tstzmultirange[]' => MartinGeorgiev\Doctrine\DBAL\Types\TstzMultirangeArray::class,

        // Text search types
        'tsquery' => MartinGeorgiev\Doctrine\DBAL\Types\Tsquery::class,
        'tsquery[]' => MartinGeorgiev\Doctrine\DBAL\Types\TsqueryArray::class,
        'tsvector' => MartinGeorgiev\Doctrine\DBAL\Types\Tsvector::class,
        'tsvector[]' => MartinGeorgiev\Doctrine\DBAL\Types\TsvectorArray::class,

        // Monetary types
        'money' => MartinGeorgiev\Doctrine\DBAL\Types\Money::class,
        'money[]' => MartinGeorgiev\Doctrine\DBAL\Types\MoneyArray::class,

        // Key-value types
        'hstore' => MartinGeorgiev\Doctrine\DBAL\Types\Hstore::class,
        'hstore[]' => MartinGeorgiev\Doctrine\DBAL\Types\HstoreArray::class,

        // Hierarchical types
        'lquery' => MartinGeorgiev\Doctrine\DBAL\Types\Lquery::class,
        'lquery[]' => MartinGeorgiev\Doctrine\DBAL\Types\LqueryArray::class,
        'ltree' => MartinGeorgiev\Doctrine\DBAL\Types\Ltree::class,
        'ltree[]' => MartinGeorgiev\Doctrine\DBAL\Types\LtreeArray::class,
        'ltxtquery' => MartinGeorgiev\Doctrine\DBAL\Types\Ltxtquery::class,
        'ltxtquery[]' => MartinGeorgiev\Doctrine\DBAL\Types\LtxtqueryArray::class,

        // XML types
        'xml' => MartinGeorgiev\Doctrine\DBAL\Types\Xml::class,
        'xml[]' => MartinGeorgiev\Doctrine\DBAL\Types\XmlArray::class,

        // Vector types
        'halfvec' => MartinGeorgiev\Doctrine\DBAL\Types\Halfvec::class,
        'sparsevec' => MartinGeorgiev\Doctrine\DBAL\Types\Sparsevec::class,
        'vector' => MartinGeorgiev\Doctrine\DBAL\Types\Vector::class,
    ],

    // ... other configuration
];

User-defined enum types: For each PostgreSQL native ENUM type, create a concrete class extending MartinGeorgiev\Doctrine\DBAL\Types\Enum and register it like the examples above. Columns holding an array of that enum get a second concrete class extending MartinGeorgiev\Doctrine\DBAL\Types\EnumArray, registered alongside the scalar one:

'custom_types' => [
    'status' => App\Doctrine\Type\StatusType::class,
    'status[]' => App\Doctrine\Type\StatusArrayType::class,
],

See ENUM-TYPE.md for a full example.

User-defined composite types: For each PostgreSQL composite (row) type, create a concrete class extending MartinGeorgiev\Doctrine\DBAL\Types\Composite and register it like the examples above. Columns holding an array of that composite get a second concrete class extending MartinGeorgiev\Doctrine\DBAL\Types\CompositeArray, registered alongside the scalar one:

'custom_types' => [
    'inventory_item' => App\Doctrine\Type\InventoryItemType::class,
    'inventory_item[]' => App\Doctrine\Type\InventoryItemArrayType::class,
],

See COMPOSITE-TYPE.md for a full example.

Register DQL Functions

Register the functions you’ll use in your DQL queries. The full set of available functions and operators can be found in the Available Functions and Operators documentation and its specialized sub-pages:

• Array and JSON Functions
• PostGIS Spatial Functions
• Text and Pattern Functions
• Date and Range Functions
• Mathematical Functions
• Utility Functions

Add the function configuration to your config/doctrine.php:

<?php
// config/doctrine.php

return [
    // ... other configuration

    'custom_string_functions' => [
        # alternative implementation of ALL() and ANY() where subquery is not required, useful for arrays
        'ALL_OF' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\All::class,
        'ANY_OF' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Any::class,

        # operators for working with array and json(b) data
        'GREATEST' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Greatest::class,
        'LEAST' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Least::class,
        'CONTAINS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Contains::class, // @>
        'IS_CONTAINED_BY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\IsContainedBy::class, // <@
        'OVERLAPS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Overlaps::class, // &&
        'RIGHT_EXISTS_ON_LEFT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TheRightExistsOnTheLeft::class, // ?
        'ALL_ON_RIGHT_EXIST_ON_LEFT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\AllOnTheRightExistOnTheLeft::class, // ?&
        'ANY_ON_RIGHT_EXISTS_ON_LEFT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\AnyOnTheRightExistsOnTheLeft::class, // ?|
        'RETURNS_VALUE_FOR_JSON_VALUE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ReturnsValueForJsonValue::class, // @?
        'DELETE_AT_PATH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\DeleteAtPath::class, // #-

        # array and string specific functions
        'IN_ARRAY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\InArray::class,
        'ANY_VALUE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\AnyValue::class,
        'ARRAY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Arr::class,
        'ARRAY_APPEND' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayAppend::class,
        'ARRAY_CARDINALITY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayCardinality::class,
        'ARRAY_CAT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayCat::class,
        'ARRAY_DIMENSIONS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayDimensions::class,
        'ARRAY_FILL' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayFill::class,
        'ARRAY_LENGTH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayLength::class,
        'ARRAY_LOWER' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayLower::class,
        'ARRAY_NUMBER_OF_DIMENSIONS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayNumberOfDimensions::class,
        'ARRAY_POSITION' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayPosition::class,
        'ARRAY_POSITIONS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayPositions::class,
        'ARRAY_PREPEND' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayPrepend::class,
        'ARRAY_REMOVE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayRemove::class,
        'ARRAY_REPLACE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayReplace::class,
        'ARRAY_REVERSE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayReverse::class,
        'ARRAY_SAMPLE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArraySample::class,
        'ARRAY_SHUFFLE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayShuffle::class,
        'ARRAY_SORT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArraySort::class,
        'ARRAY_TO_JSON' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayToJson::class,
        'ARRAY_TO_STRING' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayToString::class,
        'ARRAY_UPPER' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayUpper::class,
        'ASCII' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ascii::class,
        'BTRIM' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Btrim::class,
        'CASEFOLD' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Casefold::class,
        'CHAR_LENGTH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\CharLength::class,
        'CHR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Chr::class,
        'CONCAT_WS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ConcatWs::class,
        'DECODE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Decode::class,
        'ENCODE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Encode::class,
        'FORMAT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Format::class,
        'INITCAP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Initcap::class,
        'LEFT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Left::class,
        'LPAD' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Lpad::class,
        'LTRIM' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ltrim::class,
        'OCTET_LENGTH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\OctetLength::class,
        'QUOTE_IDENT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\QuoteIdent::class,
        'QUOTE_LITERAL' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\QuoteLiteral::class,
        'QUOTE_NULLABLE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\QuoteNullable::class,
        'REPEAT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Repeat::class,
        'REVERSE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Reverse::class,
        'RIGHT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Right::class,
        'RPAD' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Rpad::class,
        'RTRIM' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Rtrim::class,
        'SPLIT_PART' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\SplitPart::class,
        'STARTS_WITH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\StartsWith::class,
        'ROW' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Row::class,
        'STRPOS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Strpos::class,
        'STRING_TO_ARRAY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\StringToArray::class,
        'TRANSLATE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Translate::class,
        'UNNEST' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Unnest::class,

        # json specific functions
        'JSON_ARRAY_LENGTH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonArrayLength::class,
        'JSON_BUILD_ARRAY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonBuildArray::class,
        'JSON_BUILD_OBJECT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonBuildObject::class,
        'JSON_EACH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonEach::class,
        'JSON_EACH_TEXT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonEachText::class,
        'JSON_EXISTS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonExists::class,
        'JSON_EXTRACT_PATH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonExtractPath::class,
        'JSON_EXTRACT_PATH_TEXT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonExtractPathText::class,
        'JSON_GET_FIELD' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonGetField::class,
        'JSON_GET_FIELD_AS_TEXT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonGetFieldAsText::class,
        'JSON_GET_FIELD_AS_INTEGER' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonGetFieldAsInteger::class,
        'JSON_GET_OBJECT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonGetObject::class,
        'JSON_GET_OBJECT_AS_TEXT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonGetObjectAsText::class,
        'JSON_OBJECT_KEYS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonObjectKeys::class,
        'JSON_QUERY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonQuery::class,
        'JSON_SCALAR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonScalar::class,
        'JSON_SERIALIZE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonSerialize::class,
        'JSON_STRIP_NULLS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonStripNulls::class,
        'JSON_TYPEOF' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonTypeof::class,
        'JSON_VALUE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonValue::class,
        'TO_JSON' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ToJson::class,
        'ROW_TO_JSON' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RowToJson::class,

        # jsonb specific functions
        'JSONB_ARRAY_ELEMENTS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbArrayElements::class,
        'JSONB_ARRAY_ELEMENTS_TEXT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbArrayElementsText::class,
        'JSONB_ARRAY_LENGTH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbArrayLength::class,
        'JSONB_BUILD_ARRAY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbBuildArray::class,
        'JSONB_BUILD_OBJECT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbBuildObject::class,
        'JSONB_EACH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbEach::class,
        'JSONB_EACH_TEXT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbEachText::class,
        'JSONB_EXISTS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbExists::class,
        'JSONB_EXTRACT_PATH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbExtractPath::class,
        'JSONB_EXTRACT_PATH_TEXT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbExtractPathText::class,
        'JSONB_INSERT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbInsert::class,
        'JSONB_OBJECT_KEYS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbObjectKeys::class,
        'JSONB_PATH_EXISTS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbPathExists::class,
        'JSONB_PATH_MATCH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbPathMatch::class,
        'JSONB_PATH_QUERY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbPathQuery::class,
        'JSONB_PATH_QUERY_ARRAY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbPathQueryArray::class,
        'JSONB_PATH_QUERY_FIRST' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbPathQueryFirst::class,
        'JSONB_PRETTY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbPretty::class,
        'JSONB_SET' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbSet::class,
        'JSONB_SET_LAX' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbSetLax::class,
        'JSONB_STRIP_NULLS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbStripNulls::class,
        'JSONB_TYPEOF' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbTypeof::class,
        'TO_JSONB' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ToJsonb::class,

        # text search specific
        'ARRAY_TO_TSVECTOR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayToTsvector::class,
        'JSON_TO_TSVECTOR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonToTsvector::class,
        'JSONB_TO_TSVECTOR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbToTsvector::class,
        'PHRASETO_TSQUERY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PhrasetoTsquery::class,
        'PLAINTO_TSQUERY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PlaintoTsquery::class,
        'SETWEIGHT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Setweight::class,
        'STRIP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Strip::class,
        'TO_TSQUERY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ToTsquery::class,
        'TO_TSVECTOR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ToTsvector::class,
        'TS_HEADLINE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TsHeadline::class,
        'TS_RANK' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TsRank::class,
        'TS_RANK_CD' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TsRankCd::class,
        'TSMATCH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Tsmatch::class,
        'TSQUERY_PHRASE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TsqueryPhrase::class,
        'TSVECTOR_TO_ARRAY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TsvectorToArray::class,
        'WEBSEARCH_TO_TSQUERY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\WebsearchToTsquery::class,

        # date specific functions
        'AGE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Age::class,
        'AT_TIME_ZONE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\AtTimeZone::class,
        'CLOCK_TIMESTAMP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ClockTimestamp::class,
        'DATE_ADD' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\DateAdd::class,
        'DATE_BIN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\DateBin::class,
        'DATE_EXTRACT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\DateExtract::class,
        'DATE_OVERLAPS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\DateOverlaps::class,
        'DATE_PART' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\DatePart::class,
        'DATE_SUBTRACT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\DateSubtract::class,
        'DATE_TRUNC' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\DateTrunc::class,
        'GENERATE_TIME_SERIES' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\GenerateTimeSeries::class,
        'ISFINITE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Isfinite::class,
        'JUSTIFY_DAYS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JustifyDays::class,
        'JUSTIFY_HOURS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JustifyHours::class,
        'JUSTIFY_INTERVAL' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JustifyInterval::class,
        'MAKE_DATE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\MakeDate::class,
        'MAKE_TIME' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\MakeTime::class,
        'MAKE_TIMESTAMP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\MakeTimestamp::class,
        'MAKE_TIMESTAMPTZ' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\MakeTimestamptz::class,
        'STATEMENT_TIMESTAMP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\StatementTimestamp::class,
        'TRANSACTION_TIMESTAMP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TransactionTimestamp::class,

        # range functions
        'DATERANGE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Daterange::class,
        'INT4RANGE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Int4range::class,
        'INT8RANGE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Int8range::class,
        'NUMRANGE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Numrange::class,
        'TSRANGE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Tsrange::class,
        'TSTZRANGE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Tstzrange::class,
        
        # Arithmetic functions
        'CBRT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Cbrt::class,
        'CEIL' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ceil::class,
        'DEGREES' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Degrees::class,
        'DIV' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Div::class,
        'ERF' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Erf::class,
        'ERFC' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Erfc::class,
        'EXP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Exp::class,
        'FACTORIAL' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Factorial::class,
        'FLOOR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Floor::class,
        'GAMMA' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Gamma::class,
        'GCD' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Gcd::class,
        'GENERATE_NUMERIC_SERIES' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\GenerateNumericSeries::class,
        'LCM' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Lcm::class,
        'LGAMMA' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Lgamma::class,
        'LN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ln::class,
        'LOG' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Log::class,
        'MIN_SCALE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\MinScale::class,
        'PI' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Pi::class,
        'POWER' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Power::class,
        'RADIANS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Radians::class,
        'RANDOM' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Random::class,
        'RANDOM_NORMAL' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RandomNormal::class,
        'ROUND' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Round::class,
        'SCALE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Scale::class,
        'SIGN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Sign::class,
        'TRIM_SCALE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\TrimScale::class,
        'TRUNC' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trunc::class,
        'WIDTH_BUCKET' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\WidthBucket::class,

        # Trigonometric functions
        'ACOS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Acos::class,
        'ACOSD' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Acosd::class,
        'ACOSH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Acosh::class,
        'ASIN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Asin::class,
        'ASIND' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Asind::class,
        'ASINH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Asinh::class,
        'ATAN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Atan::class,
        'ATAN2' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Atan2::class,
        'ATAN2D' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Atan2d::class,
        'ATAND' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Atand::class,
        'ATANH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Atanh::class,
        'COS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Cos::class,
        'COSD' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Cosd::class,
        'COSH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Cosh::class,
        'COT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Cot::class,
        'COTD' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Cotd::class,
        'SIN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Sin::class,
        'SIND' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Sind::class,
        'SINH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Sinh::class,
        'TAN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Tan::class,
        'TAND' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Tand::class,
        'TANH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Tanh::class,

        # other operators
        'COMPOSITE_FIELD' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\CompositeField::class,
        'ILIKE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ilike::class,
        'SIMILAR_TO' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\SimilarTo::class,
        'NOT_SIMILAR_TO' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\NotSimilarTo::class,
        'UNACCENT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Unaccent::class,
        'REGEXP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Regexp::class,
        'IREGEXP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\IRegexp::class,
        'NOT_REGEXP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\NotRegexp::class,
        'NOT_IREGEXP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\NotIRegexp::class,
        'REGEXP_COUNT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RegexpCount::class,
        'REGEXP_INSTR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RegexpInstr::class,
        'REGEXP_LIKE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RegexpLike::class,
        'REGEXP_MATCH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RegexpMatch::class,
        'REGEXP_REPLACE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RegexpReplace::class,
        'REGEXP_SUBSTR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RegexpSubstr::class,
        'STRCONCAT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\StrConcat::class, // the `||` operator
        'DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Distance::class,

        # vector distance functions
        'COSINE_DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Vector\CosineDistance::class,
        'INNER_PRODUCT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Vector\InnerProduct::class,
        'L2_DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Vector\L2Distance::class,

        # ltree functions
        'INDEX' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ltree\Index::class,
        'LCA' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ltree\Lca::class,
        'LTREE2TEXT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ltree\Ltree2text::class,
        'NLEVEL' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ltree\Nlevel::class,
        'SUBLTREE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ltree\Subltree::class,
        'SUBPATH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ltree\Subpath::class,
        'TEXT2LTREE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ltree\Text2ltree::class,

        # ltree match operators
        'MATCHES_LQUERY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ltree\MatchesLquery::class, # ~
        'MATCHES_LTXTQUERY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ltree\MatchesLtxtquery::class, # @
        'MATCHES_ANY_LQUERY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ltree\MatchesAnyLquery::class, # ?

        # hstore functions
        'HSTORE_AKEYS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Hstore\Akeys::class,
        'HSTORE_AVALS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Hstore\Avals::class,
        'HSTORE_DEFINED' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Hstore\Defined::class,
        'HSTORE_DELETE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Hstore\Delete::class,
        'HSTORE_SKEYS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Hstore\Skeys::class,
        'HSTORE_SVALS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Hstore\Svals::class,
        'HSTORE_TO_JSON' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Hstore\HstoreToJson::class,
        'HSTORE_TO_JSON_LOOSE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Hstore\HstoreToJsonLoose::class,

        # PostGIS functions
        'ST_3DDFULLYWITHIN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_3DDFullyWithin::class,
        'ST_3DDISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_3DDistance::class,
        'ST_3DDWITHIN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_3DDWithin::class,
        'ST_3DINTERSECTS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_3DIntersects::class,
        'ST_3DLENGTH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_3DLength::class,
        'ST_3DPERIMETER' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_3DPerimeter::class,
        'ST_AREA' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Area::class,
        'ST_ASEWKT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_AsEWKT::class,
        'ST_ASGEOJSON' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_AsGeoJSON::class,
        'ST_ASTEXT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_AsText::class,
        'ST_AZIMUTH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Azimuth::class,
        'ST_BOUNDARY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Boundary::class,
        'ST_BUFFER' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Buffer::class,
        'ST_CENTROID' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Centroid::class,
        'ST_CLIPBYBOX2D' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_ClipByBox2D::class,
        'ST_CLOSESTPOINT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_ClosestPoint::class,
        'ST_COLLECT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Collect::class,
        'ST_COLLECTIONEXTRACT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_CollectionExtract::class,
        'ST_COLLECTIONHOMOGENIZE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_CollectionHomogenize::class,
        'ST_CONCAVEHULL' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_ConcaveHull::class,
        'ST_CONTAINS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Contains::class,
        'ST_CONTAINSPROPERLY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_ContainsProperly::class,
        'ST_CONVEXHULL' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_ConvexHull::class,
        'ST_COORDDIM' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_CoordDim::class,
        'ST_COVERAGEUNION' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_CoverageUnion::class,
        'ST_COVEREDBY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_CoveredBy::class,
        'ST_COVERS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Covers::class,
        'ST_CROSSES' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Crosses::class,
        'ST_CURVEN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_CurveN::class,
        'ST_CURVETOLINE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_CurveToLine::class,
        'ST_DFULLYWITHIN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_DFullyWithin::class,
        'ST_DIFFERENCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Difference::class,
        'ST_DISJOINT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Disjoint::class,
        'ST_DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Distance::class,
        'ST_DWITHIN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_DWithin::class,
        'ST_ENDPOINT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_EndPoint::class,
        'ST_ENVELOPE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Envelope::class,
        'ST_EQUALS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Equals::class,
        'ST_EXTERIORRING' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_ExteriorRing::class,
        'ST_FLIPCOORDINATES' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_FlipCoordinates::class,
        'ST_FORCE2D' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Force2D::class,
        'ST_FORCE3D' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Force3D::class,
        'ST_FORCE4D' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Force4D::class,
        'ST_FRECHETDISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_FrechetDistance::class,
        'ST_GENERATEPOINTS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_GeneratePoints::class,
        'ST_GEOMETRYN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_GeometryN::class,
        'ST_GEOMETRYTYPE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_GeometryType::class,
        'ST_GEOMFROMEWKT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_GeomFromEWKT::class,
        'ST_GEOMFROMGEOJSON' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_GeomFromGeoJSON::class,
        'ST_GEOMFROMTEXT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_GeomFromText::class,
        'ST_HASM' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_HasM::class,
        'ST_HASZ' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_HasZ::class,
        'ST_HAUSDORFFDISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_HausdorffDistance::class,
        'ST_INTERIORRINGN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_InteriorRingN::class,
        'ST_INTERSECTION' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Intersection::class,
        'ST_INTERSECTS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Intersects::class,
        'ST_ISCLOSED' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_IsClosed::class,
        'ST_ISEMPTY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_IsEmpty::class,
        'ST_ISVALID' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_IsValid::class,
        'ST_ISVALIDREASON' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_IsValidReason::class,
        'ST_LENGTH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Length::class,
        'ST_LENGTH2D' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Length2D::class,
        'ST_LETTERS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Letters::class,
        'ST_LINECROSSINGDIRECTION' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_LineCrossingDirection::class,
        'ST_LINEEXTEND' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_LineExtend::class,
        'ST_LINEINTERPOLATEPOINT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_LineInterpolatePoint::class,
        'ST_LINELOCATEPOINT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_LineLocatePoint::class,
        'ST_LINESUBSTRING' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_LineSubstring::class,
        'ST_LINETOCURVE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_LineToCurve::class,
        'ST_MAKEENVELOPE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_MakeEnvelope::class,
        'ST_MAKELINE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_MakeLine::class,
        'ST_MAKEPOINT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_MakePoint::class,
        'ST_MAKEVALID' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_MakeValid::class,
        'ST_MAXDISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_MaxDistance::class,
        'ST_MINIMUMBOUNDINGCIRCLE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_MinimumBoundingCircle::class,
        'ST_NPOINTS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_NPoints::class,
        'ST_NUMCURVES' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_NumCurves::class,
        'ST_NUMGEOMETRIES' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_NumGeometries::class,
        'ST_NUMINTERIORRINGS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_NumInteriorRings::class,
        'ST_NUMPOINTS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_NumPoints::class,
        'ST_OFFSETCURVE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_OffsetCurve::class,
        'ST_ORDERINGEQUALS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_OrderingEquals::class,
        'ST_OVERLAPS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Overlaps::class,
        'ST_PERIMETER' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Perimeter::class,
        'ST_POINT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Point::class,
        'ST_POINTINSIDECIRCLE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_PointInsideCircle::class,
        'ST_POINTN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_PointN::class,
        'ST_POINTONSURFACE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_PointOnSurface::class,
        'ST_PROJECT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Project::class,
        'ST_RELATE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Relate::class,
        'ST_RELATEMATCH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_RelateMatch::class,
        'ST_REMOVEIRRELEVANTPOINTSFORVIEW' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_RemoveIrrelevantPointsForView::class,
        'ST_REMOVESMALLPARTS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_RemoveSmallParts::class,
        'ST_REVERSE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Reverse::class,
        'ST_ROTATE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Rotate::class,
        'ST_SCALE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Scale::class,
        'ST_SEGMENTIZE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Segmentize::class,
        'ST_SETSRID' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_SetSRID::class,
        'ST_SHORTESTLINE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_ShortestLine::class,
        'ST_SIMPLIFY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Simplify::class,
        'ST_SIMPLIFYPOLYGONHULL' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_SimplifyPolygonHull::class,
        'ST_SIMPLIFYPRESERVETOPOLOGY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_SimplifyPreserveTopology::class,
        'ST_SIMPLIFYVW' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_SimplifyVW::class,
        'ST_SNAP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Snap::class,
        'ST_SPLIT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Split::class,
        'ST_SRID' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_SRID::class,
        'ST_STARTPOINT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_StartPoint::class,
        'ST_SUBDIVIDE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Subdivide::class,
        'ST_SYMDIFFERENCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_SymDifference::class,
        'ST_TILEENVELOPE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_TileEnvelope::class,
        'ST_TOUCHES' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Touches::class,
        'ST_TRANSFORM' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Transform::class,
        'ST_TRANSLATE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Translate::class,
        'ST_TRIANGULATEPOLYGON' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_TriangulatePolygon::class,
        'ST_UNARYUNION' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_UnaryUnion::class,
        'ST_UNION' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Union::class,
        'ST_VORONOIPOLYGONS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_VoronoiPolygons::class,
        'ST_WITHIN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Within::class,
        'ST_X' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_X::class,
        'ST_Y' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Y::class,
        'ST_Z' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\ST_Z::class,

        # PostGIS operators
        'BOUNDING_BOX_DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\BoundingBoxDistance::class, // <#>
        'GEOMETRY_DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\GeometryDistance::class, // <->
        'ND_CENTROID_DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\NDimensionalCentroidDistance::class, // <<->>
        'ND_OVERLAPS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\NDimensionalOverlaps::class, // &&&
        'OVERLAPS_ABOVE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\OverlapsAbove::class, // |&>
        'OVERLAPS_BELOW' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\OverlapsBelow::class, // &<|
        'OVERLAPS_LEFT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\OverlapsLeft::class, // &<
        'OVERLAPS_RIGHT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\OverlapsRight::class, // &>
        'SPATIAL_CONTAINED_BY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\SpatialContainedBy::class, // @
        'SPATIAL_CONTAINS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\SpatialContains::class, // ~
        'SPATIAL_SAME' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\SpatialSame::class, // ~=
        'STRICTLY_ABOVE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\StrictlyAbove::class, // |>>
        'STRICTLY_BELOW' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\StrictlyBelow::class, // <<|
        'STRICTLY_LEFT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\StrictlyLeft::class, // <<
        'STRICTLY_RIGHT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\StrictlyRight::class, // >>
        'TRAJECTORY_DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PostGIS\TrajectoryDistance::class, // |=|

        # pg_trgm functions
        'SIMILARITY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\Similarity::class,
        'STRICT_WORD_SIMILARITY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\StrictWordSimilarity::class,
        'WORD_SIMILARITY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\WordSimilarity::class,

        # pg_trgm operators
        'ARE_SIMILAR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\AreSimilar::class, // %
        'CONTAINS_STRICT_WORD_SIMILAR_TO' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\ContainsStrictWordSimilarTo::class, // %>>
        'CONTAINS_WORD_SIMILAR_TO' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\ContainsWordSimilarTo::class, // %>
        'IS_STRICT_WORD_SIMILAR_TO' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\IsStrictWordSimilarTo::class, // <<%
        'IS_WORD_SIMILAR_TO' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\IsWordSimilarTo::class, // <%
        'REVERSE_STRICT_WORD_SIMILARITY_DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\ReverseStrictWordSimilarityDistance::class, // <->>>
        'REVERSE_WORD_SIMILARITY_DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\ReverseWordSimilarityDistance::class, // <->>
        'SIMILARITY_DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\SimilarityDistance::class, // <->
        'STRICT_WORD_SIMILARITY_DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\StrictWordSimilarityDistance::class, // <<<->
        'WORD_SIMILARITY_DISTANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Trgm\WordSimilarityDistance::class, // <<->

        # fuzzystrmatch functions
        'DAITCH_MOKOTOFF' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Fuzzystrmatch\DaitchMokotoff::class,
        'DIFFERENCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Fuzzystrmatch\Difference::class,
        'DMETAPHONE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Fuzzystrmatch\Dmetaphone::class,
        'DMETAPHONE_ALT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Fuzzystrmatch\DmetaphoneAlt::class,
        'LEVENSHTEIN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Fuzzystrmatch\Levenshtein::class,
        'LEVENSHTEIN_LESS_EQUAL' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Fuzzystrmatch\LevenshteinLessEqual::class,
        'METAPHONE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Fuzzystrmatch\Metaphone::class,
        'SOUNDEX' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Fuzzystrmatch\Soundex::class,

        # network address functions
        'ABBREV' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Network\Abbrev::class,
        'BROADCAST' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Network\Broadcast::class,
        'FAMILY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Network\Family::class,
        'HOST' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Network\Host::class,
        'HOSTMASK' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Network\Hostmask::class,
        'INET_MERGE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Network\InetMerge::class,
        'INET_SAME_FAMILY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Network\InetSameFamily::class,
        'MASKLEN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Network\Masklen::class,
        'NETMASK' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Network\Netmask::class,
        'NETWORK' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Network\Network::class,
        'SET_MASKLEN' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Network\SetMasklen::class,

        # aggregation functions
        'ARRAY_AGG' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ArrayAgg::class,
        'BIT_AND' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\BitAnd::class,
        'BIT_OR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\BitOr::class,
        'BIT_XOR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\BitXor::class,
        'BOOL_AND' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\BoolAnd::class,
        'BOOL_OR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\BoolOr::class,
        'CORR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Corr::class,
        'COVAR_POP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\CovarPop::class,
        'COVAR_SAMP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\CovarSamp::class,
        'EVERY' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Every::class,
        'FILTER' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Filter::class,
        'JSON_AGG' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonAgg::class,
        'JSON_OBJECT_AGG' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonObjectAgg::class,
        'JSONB_AGG' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbAgg::class,
        'JSONB_OBJECT_AGG' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\JsonbObjectAgg::class,
        'MODE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Mode::class,
        'PERCENTILE_CONT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PercentileCont::class,
        'PERCENTILE_DISC' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PercentileDisc::class,
        'RANGE_AGG' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RangeAgg::class,
        'RANGE_INTERSECT_AGG' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RangeIntersectAgg::class,
        'STDDEV' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Stddev::class,
        'STDDEV_POP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\StddevPop::class,
        'STRING_AGG' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\StringAgg::class,
        'VAR_POP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\VarPop::class,
        'VARIANCE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Variance::class,

        # Window functions
        'CUME_DIST' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\CumeDist::class,
        'DENSE_RANK' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\DenseRank::class,
        'FIRST_VALUE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\FirstValue::class,
        'LAG' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Lag::class,
        'LAST_VALUE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\LastValue::class,
        'LEAD' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Lead::class,
        'NTH_VALUE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\NthValue::class,
        'NTILE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Ntile::class,
        'OVER' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Over::class,
        'PERCENT_RANK' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\PercentRank::class,
        'RANK' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Rank::class,
        'ROW_NUMBER' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RowNumber::class,

        # XML functions
        'XML_IS_WELL_FORMED' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\XmlIsWellFormed::class,
        'XML_IS_WELL_FORMED_CONTENT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\XmlIsWellFormedContent::class,
        'XML_IS_WELL_FORMED_DOCUMENT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\XmlIsWellFormedDocument::class,
        'XMLAGG' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\XmlAgg::class,
        'XMLCOMMENT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\XmlComment::class,
        'XMLCONCAT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\XmlConcat::class,
        'XMLEXISTS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\XmlExists::class,
        'XMLPI' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\XmlPi::class,
        'XMLTEXT' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\XmlText::class,
        'XPATH' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Xpath::class,
        'XPATH_EXISTS' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\XpathExists::class,

        # hashing and checksum functions
        'CRC32' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Crc32::class,
        'CRC32C' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Crc32c::class,
        'MD5' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Md5::class,
        'REVERSE_BYTES' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ReverseBytes::class,
        'SHA224' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Sha224::class,
        'SHA256' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Sha256::class,
        'SHA384' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Sha384::class,
        'SHA512' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Sha512::class,

        # uuid functions
        'GEN_RANDOM_UUID' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\GenRandomUuid::class,
        'UUID_EXTRACT_TIMESTAMP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\UuidExtractTimestamp::class,
        'UUID_EXTRACT_VERSION' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\UuidExtractVersion::class,
        'UUIDV4' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Uuidv4::class,
        'UUIDV7' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Uuidv7::class,

        # type conversion and formatting functions
        'CAST' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Cast::class,
        'TO_CHAR' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ToChar::class,
        'TO_DATE' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ToDate::class,
        'TO_NUMBER' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ToNumber::class,
        'TO_TIMESTAMP' => MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\ToTimestamp::class,
    ],

    ...
];

Usage in Entities

Once configured, you can use PostgreSQL types in your Laravel entities:

<?php

namespace App\Entities;

use Doctrine\ORM\Mapping as ORM;
use MartinGeorgiev\Doctrine\DBAL\Types\ValueObject\DateRange;
use MartinGeorgiev\Doctrine\DBAL\Types\ValueObject\Interval;
use MartinGeorgiev\Doctrine\DBAL\Types\ValueObject\Ltree;
use MartinGeorgiev\Doctrine\DBAL\Types\ValueObject\NumericRange;
use MartinGeorgiev\Doctrine\DBAL\Types\ValueObject\Point;
use MartinGeorgiev\Doctrine\DBAL\Types\ValueObject\WktSpatialData;

#[ORM\Entity]
#[ORM\Table(name: 'products')]
class Product
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(type: 'jsonb')]
    private array $specifications = [];

    #[ORM\Column(type: 'text[]')]
    private array $categories = [];

    #[ORM\Column(type: 'point')]
    private Point $location;

    #[ORM\Column(type: 'geometry')]
    private WktSpatialData $shape;

    #[ORM\Column(type: 'numrange')]
    private NumericRange $priceRange;

    #[ORM\Column(type: 'daterange')]
    private DateRange $availabilityPeriod;

    #[ORM\Column(type: 'inet')]
    private string $originServerIp;

    #[ORM\Column(type: 'interval')]
    private Interval $duration;

    #[ORM\Column(type: 'money')]
    private string $price;

    #[ORM\Column(type: 'ltree')]
    private Ltree $pathFromRoot;

    #[ORM\Column(type: 'xml')]
    private string $configXml;
}