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

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. }