vendor/doctrine/dbal/src/Types/Type.php line 188

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL\Types;
  5. use Doctrine\DBAL\Exception;
  6. use Doctrine\DBAL\ParameterType;
  7. use Doctrine\DBAL\Platforms\AbstractPlatform;
  8. use Doctrine\Deprecations\Deprecation;
  10. use function array_map;
  11. use function get_class;
  13. /**
  14.  * The base class for so-called Doctrine mapping types.
  15.  *
  16.  * A Type object is obtained by calling the static {@see getType()} method.
  17.  */
  18. abstract class Type
  19. {
  20.     /**
  21.      * The map of supported doctrine mapping types.
  22.      */
  23.     private const BUILTIN_TYPES_MAP = [
  24.         Types::ARRAY                => ArrayType::class,
  25.         Types::ASCII_STRING         => AsciiStringType::class,
  26.         Types::BIGINT               => BigIntType::class,
  27.         Types::BINARY               => BinaryType::class,
  28.         Types::BLOB                 => BlobType::class,
  29.         Types::BOOLEAN              => BooleanType::class,
  30.         Types::DATE_MUTABLE         => DateType::class,
  31.         Types::DATE_IMMUTABLE       => DateImmutableType::class,
  32.         Types::DATEINTERVAL         => DateIntervalType::class,
  33.         Types::DATETIME_MUTABLE     => DateTimeType::class,
  34.         Types::DATETIME_IMMUTABLE   => DateTimeImmutableType::class,
  35.         Types::DATETIMETZ_MUTABLE   => DateTimeTzType::class,
  36.         Types::DATETIMETZ_IMMUTABLE => DateTimeTzImmutableType::class,
  37.         Types::DECIMAL              => DecimalType::class,
  38.         Types::FLOAT                => FloatType::class,
  39.         Types::GUID                 => GuidType::class,
  40.         Types::INTEGER              => IntegerType::class,
  41.         Types::JSON                 => JsonType::class,
  42.         Types::OBJECT               => ObjectType::class,
  43.         Types::SIMPLE_ARRAY         => SimpleArrayType::class,
  44.         Types::SMALLINT             => SmallIntType::class,
  45.         Types::STRING               => StringType::class,
  46.         Types::TEXT                 => TextType::class,
  47.         Types::TIME_MUTABLE         => TimeType::class,
  48.         Types::TIME_IMMUTABLE       => TimeImmutableType::class,
  49.     ];
  51.     private static ?TypeRegistry $typeRegistry = null;
  53.     /** @internal Do not instantiate directly - use {@see Type::addType()} method instead. */
  54.     final public function __construct()
  55.     {
  56.     }
  58.     /**
  59.      * Converts a value from its PHP representation to its database representation
  60.      * of this type.
  61.      *
  62.      * @param mixed            $value    The value to convert.
  63.      * @param AbstractPlatform $platform The currently used database platform.
  64.      *
  65.      * @return mixed The database representation of the value.
  66.      *
  67.      * @throws ConversionException
  68.      */
  69.     public function convertToDatabaseValue($value, AbstractPlatform $platform)
  70.     {
  71.         return $value;
  72.     }
  74.     /**
  75.      * Converts a value from its database representation to its PHP representation
  76.      * of this type.
  77.      *
  78.      * @param mixed            $value    The value to convert.
  79.      * @param AbstractPlatform $platform The currently used database platform.
  80.      *
  81.      * @return mixed The PHP representation of the value.
  82.      *
  83.      * @throws ConversionException
  84.      */
  85.     public function convertToPHPValue($value, AbstractPlatform $platform)
  86.     {
  87.         return $value;
  88.     }
  90.     /**
  91.      * Gets the SQL declaration snippet for a column of this type.
  92.      *
  93.      * @param mixed[]          $column   The column definition
  94.      * @param AbstractPlatform $platform The currently used database platform.
  95.      *
  96.      * @return string
  97.      */
  98.     abstract public function getSQLDeclaration(array $column, AbstractPlatform $platform);
  100.     /**
  101.      * Gets the name of this type.
  102.      *
  103.      * @deprecated this method will be removed in Doctrine DBAL 4.0,
  104.      *             use {@see TypeRegistry::lookupName()} instead.
  105.      *
  106.      * @return string
  107.      */
  108.     abstract public function getName();
  110.     final public static function getTypeRegistry(): TypeRegistry
  111.     {
  112.         return self::$typeRegistry ??= self::createTypeRegistry();
  113.     }
  115.     private static function createTypeRegistry(): TypeRegistry
  116.     {
  117.         $instances = [];
  119.         foreach (self::BUILTIN_TYPES_MAP as $name => $class) {
  120.             $instances[$name] = new $class();
  121.         }
  123.         return new TypeRegistry($instances);
  124.     }
  126.     /**
  127.      * Factory method to create type instances.
  128.      * Type instances are implemented as flyweights.
  129.      *
  130.      * @param string $name The name of the type (as returned by getName()).
  131.      *
  132.      * @return Type
  133.      *
  134.      * @throws Exception
  135.      */
  136.     public static function getType($name)
  137.     {
  138.         return self::getTypeRegistry()->get($name);
  139.     }
  141.     /**
  142.      * Finds a name for the given type.
  143.      *
  144.      * @throws Exception
  145.      */
  146.     public static function lookupName(self $type): string
  147.     {
  148.         return self::getTypeRegistry()->lookupName($type);
  149.     }
  151.     /**
  152.      * Adds a custom type to the type map.
  153.      *
  154.      * @param string             $name      The name of the type. This should correspond to what getName() returns.
  155.      * @param class-string<Type> $className The class name of the custom type.
  156.      *
  157.      * @return void
  158.      *
  159.      * @throws Exception
  160.      */
  161.     public static function addType($name, $className)
  162.     {
  163.         self::getTypeRegistry()->register($name, new $className());
  164.     }
  166.     /**
  167.      * Checks if exists support for a type.
  168.      *
  169.      * @param string $name The name of the type.
  170.      *
  171.      * @return bool TRUE if type is supported; FALSE otherwise.
  172.      */
  173.     public static function hasType($name)
  174.     {
  175.         return self::getTypeRegistry()->has($name);
  176.     }
  178.     /**
  179.      * Overrides an already defined type to use a different implementation.
  180.      *
  181.      * @param string             $name
  182.      * @param class-string<Type> $className
  183.      *
  184.      * @return void
  185.      *
  186.      * @throws Exception
  187.      */
  188.     public static function overrideType($name, $className)
  189.     {
  190.         self::getTypeRegistry()->override($name, new $className());
  191.     }
  193.     /**
  194.      * Gets the (preferred) binding type for values of this type that
  195.      * can be used when binding parameters to prepared statements.
  196.      *
  197.      * This method should return one of the {@see ParameterType} constants.
  198.      *
  199.      * @return int
  200.      */
  201.     public function getBindingType()
  202.     {
  203.         return ParameterType::STRING;
  204.     }
  206.     /**
  207.      * Gets the types array map which holds all registered types and the corresponding
  208.      * type class
  209.      *
  210.      * @return array<string, string>
  211.      */
  212.     public static function getTypesMap()
  213.     {
  214.         return array_map(
  215.             static function (Type $type): string {
  216.                 return get_class($type);
  217.             },
  218.             self::getTypeRegistry()->getMap(),
  219.         );
  220.     }
  222.     /**
  223.      * Does working with this column require SQL conversion functions?
  224.      *
  225.      * This is a metadata function that is required for example in the ORM.
  226.      * Usage of {@see convertToDatabaseValueSQL} and
  227.      * {@see convertToPHPValueSQL} works for any type and mostly
  228.      * does nothing. This method can additionally be used for optimization purposes.
  229.      *
  230.      * @deprecated Consumers should call {@see convertToDatabaseValueSQL} and {@see convertToPHPValueSQL}
  231.      * regardless of the type.
  232.      *
  233.      * @return bool
  234.      */
  235.     public function canRequireSQLConversion()
  236.     {
  237.         return false;
  238.     }
  240.     /**
  241.      * Modifies the SQL expression (identifier, parameter) to convert to a database value.
  242.      *
  243.      * @param string $sqlExpr
  244.      *
  245.      * @return string
  246.      */
  247.     public function convertToDatabaseValueSQL($sqlExpr, AbstractPlatform $platform)
  248.     {
  249.         return $sqlExpr;
  250.     }
  252.     /**
  253.      * Modifies the SQL expression (identifier, parameter) to convert to a PHP value.
  254.      *
  255.      * @param string           $sqlExpr
  256.      * @param AbstractPlatform $platform
  257.      *
  258.      * @return string
  259.      */
  260.     public function convertToPHPValueSQL($sqlExpr, $platform)
  261.     {
  262.         return $sqlExpr;
  263.     }
  265.     /**
  266.      * Gets an array of database types that map to this Doctrine type.
  267.      *
  268.      * @return string[]
  269.      */
  270.     public function getMappedDatabaseTypes(AbstractPlatform $platform)
  271.     {
  272.         return [];
  273.     }
  275.     /**
  276.      * If this Doctrine Type maps to an already mapped database type,
  277.      * reverse schema engineering can't tell them apart. You need to mark
  278.      * one of those types as commented, which will have Doctrine use an SQL
  279.      * comment to typehint the actual Doctrine Type.
  280.      *
  281.      * @deprecated
  282.      *
  283.      * @return bool
  284.      */
  285.     public function requiresSQLCommentHint(AbstractPlatform $platform)
  286.     {
  287.         Deprecation::triggerIfCalledFromOutside(
  288.             'doctrine/dbal',
  289.             'https://github.com/doctrine/dbal/pull/5509',
  290.             '%s is deprecated.',
  291.             __METHOD__,
  292.         );
  294.         return false;
  295.     }
  296. }