diff --git a/extension.neon b/extension.neon
index 79e73a3a..3c825c9b 100644
--- a/extension.neon
+++ b/extension.neon
@@ -25,6 +25,12 @@ conditionalTags:
 		phpstan.broker.methodsClassReflectionExtension: %doctrine.allCollectionsSelectable%
 
 services:
+	-
+		class: PHPStan\Type\Doctrine\DescriptorRegistryFactory
+	-
+		class: PHPStan\Type\Doctrine\DescriptorRegistry
+		factory: @PHPStan\Type\Doctrine\DescriptorRegistryFactory::createRegistry
+
 	-
 		class: PHPStan\Reflection\Doctrine\DoctrineSelectableClassReflectionExtension
 	-
@@ -177,3 +183,77 @@ services:
 		arguments:
 			class: Doctrine\ORM\Query\Expr
 			argumentsProcessor: @doctrineQueryBuilderArgumentsProcessor
+
+	# Type descriptors
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\ArrayType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\BigIntType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\BinaryType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\BlobType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateImmutableType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateIntervalType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateTimeImmutableType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateTimeType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateTimeTzImmutableType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateTimeTzType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DateType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\DecimalType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\FloatType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\GuidType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\IntegerType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\JsonArrayType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\JsonType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\ObjectType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\SimpleArrayType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\SmallIntType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\StringType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\TextType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\TimeImmutableType
+		tags: [phpstan.doctrine.typeDescriptor]
+	-
+		class: PHPStan\Type\Doctrine\Descriptors\TimeType
+		tags: [phpstan.doctrine.typeDescriptor]
diff --git a/rules.neon b/rules.neon
index 10f27997..63eaa60f 100644
--- a/rules.neon
+++ b/rules.neon
@@ -17,6 +17,7 @@ rules:
 	- PHPStan\Rules\Doctrine\ORM\DqlRule
 	- PHPStan\Rules\Doctrine\ORM\MagicRepositoryMethodCallRule
 	- PHPStan\Rules\Doctrine\ORM\RepositoryMethodCallRule
+	- PHPStan\Rules\Doctrine\ORM\EntityColumnRule
 
 services:
 	-
diff --git a/src/Rules/Doctrine/ORM/EntityColumnRule.php b/src/Rules/Doctrine/ORM/EntityColumnRule.php
new file mode 100644
index 00000000..d909b3c1
--- /dev/null
+++ b/src/Rules/Doctrine/ORM/EntityColumnRule.php
@@ -0,0 +1,100 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MissingPropertyFromReflectionException;
+use PHPStan\Rules\Rule;
+use PHPStan\Type\Doctrine\DescriptorNotRegisteredException;
+use PHPStan\Type\Doctrine\DescriptorRegistry;
+use PHPStan\Type\Doctrine\ObjectMetadataResolver;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\VerbosityLevel;
+use function sprintf;
+
+class EntityColumnRule implements Rule
+{
+
+	/** @var \PHPStan\Type\Doctrine\ObjectMetadataResolver */
+	private $objectMetadataResolver;
+
+	/** @var \PHPStan\Type\Doctrine\DescriptorRegistry */
+	private $descriptorRegistry;
+
+	public function __construct(ObjectMetadataResolver $objectMetadataResolver, DescriptorRegistry $descriptorRegistry)
+	{
+		$this->objectMetadataResolver = $objectMetadataResolver;
+		$this->descriptorRegistry = $descriptorRegistry;
+	}
+
+	public function getNodeType(): string
+	{
+		return Node\Stmt\PropertyProperty::class;
+	}
+
+	/**
+	 * @param \PhpParser\Node\Stmt\PropertyProperty $node
+	 * @param \PHPStan\Analyser\Scope $scope
+	 * @return string[]
+	 */
+	public function processNode(Node $node, Scope $scope): array
+	{
+		$class = $scope->getClassReflection();
+		if ($class === null) {
+			return [];
+		}
+
+		$objectManager = $this->objectMetadataResolver->getObjectManager();
+		if ($objectManager === null) {
+			return [];
+		}
+
+		$className = $class->getName();
+		if ($objectManager->getMetadataFactory()->isTransient($className)) {
+			return [];
+		}
+
+		/** @var \Doctrine\ORM\Mapping\ClassMetadataInfo $metadata */
+		$metadata = $objectManager->getClassMetadata($className);
+		$classMetadataInfo = 'Doctrine\ORM\Mapping\ClassMetadataInfo';
+		if (!$metadata instanceof $classMetadataInfo) {
+			return [];
+		}
+
+		$propertyName = (string) $node->name;
+		try {
+			$property = $class->getNativeProperty($propertyName);
+		} catch (MissingPropertyFromReflectionException $e) {
+			return [];
+		}
+
+		if (!isset($metadata->fieldMappings[$propertyName])) {
+			return [];
+		}
+		$fieldMapping = $metadata->fieldMappings[$propertyName];
+
+		$errors = [];
+		try {
+			$descriptor = $this->descriptorRegistry->get($fieldMapping['type']);
+		} catch (DescriptorNotRegisteredException $e) {
+			return [];
+		}
+
+		$writableToPropertyType = $descriptor->getWritableToPropertyType();
+		$writableToDatabaseType = $descriptor->getWritableToDatabaseType();
+		if ($fieldMapping['nullable'] === true) {
+			$writableToPropertyType = TypeCombinator::addNull($writableToPropertyType);
+			$writableToDatabaseType = TypeCombinator::addNull($writableToDatabaseType);
+		}
+
+		if (!$property->getWritableType()->isSuperTypeOf($writableToPropertyType)->yes()) {
+			$errors[] = sprintf('Database can contain %s but property expects %s.', $writableToPropertyType->describe(VerbosityLevel::typeOnly()), $property->getWritableType()->describe(VerbosityLevel::typeOnly()));
+		}
+		if (!$writableToDatabaseType->isSuperTypeOf($property->getReadableType())->yes()) {
+			$errors[] = sprintf('Property can contain %s but database expects %s.', $property->getReadableType()->describe(VerbosityLevel::typeOnly()), $writableToDatabaseType->describe(VerbosityLevel::typeOnly()));
+		}
+		return $errors;
+	}
+
+}
diff --git a/src/Type/Doctrine/DescriptorNotRegisteredException.php b/src/Type/Doctrine/DescriptorNotRegisteredException.php
new file mode 100644
index 00000000..5077fe1b
--- /dev/null
+++ b/src/Type/Doctrine/DescriptorNotRegisteredException.php
@@ -0,0 +1,8 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine;
+
+class DescriptorNotRegisteredException extends \RuntimeException
+{
+
+}
diff --git a/src/Type/Doctrine/DescriptorRegistry.php b/src/Type/Doctrine/DescriptorRegistry.php
new file mode 100644
index 00000000..dc0225ca
--- /dev/null
+++ b/src/Type/Doctrine/DescriptorRegistry.php
@@ -0,0 +1,31 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine;
+
+use PHPStan\Type\Doctrine\Descriptors\DoctrineTypeDescriptor;
+
+class DescriptorRegistry
+{
+
+	/** @var array<string, \PHPStan\Type\Doctrine\Descriptors\DoctrineTypeDescriptor> */
+	private $descriptors = [];
+
+	/**
+	 * @param \PHPStan\Type\Doctrine\Descriptors\DoctrineTypeDescriptor[] $descriptors
+	 */
+	public function __construct(array $descriptors)
+	{
+		foreach ($descriptors as $descriptor) {
+			$this->descriptors[$descriptor->getType()] = $descriptor;
+		}
+	}
+
+	public function get(string $type): DoctrineTypeDescriptor
+	{
+		if (!isset($this->descriptors[$type])) {
+			throw new \PHPStan\Type\Doctrine\DescriptorNotRegisteredException();
+		}
+		return $this->descriptors[$type];
+	}
+
+}
diff --git a/src/Type/Doctrine/DescriptorRegistryFactory.php b/src/Type/Doctrine/DescriptorRegistryFactory.php
new file mode 100644
index 00000000..5506d10c
--- /dev/null
+++ b/src/Type/Doctrine/DescriptorRegistryFactory.php
@@ -0,0 +1,25 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine;
+
+use PHPStan\DependencyInjection\Container;
+
+class DescriptorRegistryFactory
+{
+
+	public const TYPE_DESCRIPTOR_TAG = 'phpstan.doctrine.typeDescriptor';
+
+	/** @var \PHPStan\DependencyInjection\Container */
+	private $container;
+
+	public function __construct(Container $container)
+	{
+		$this->container = $container;
+	}
+
+	public function createRegistry(): DescriptorRegistry
+	{
+		return new DescriptorRegistry($this->container->getServicesByTag(self::TYPE_DESCRIPTOR_TAG));
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/ArrayType.php b/src/Type/Doctrine/Descriptors/ArrayType.php
new file mode 100644
index 00000000..0a8f0697
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/ArrayType.php
@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\MixedType;
+use PHPStan\Type\Type;
+
+class ArrayType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'array';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\ArrayType(new MixedType(), new MixedType());
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\ArrayType(new MixedType(), new MixedType());
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/BigIntType.php b/src/Type/Doctrine/Descriptors/BigIntType.php
new file mode 100644
index 00000000..c19f0d26
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/BigIntType.php
@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+
+class BigIntType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'bigint';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\StringType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return TypeCombinator::union(new \PHPStan\Type\StringType(), new \PHPStan\Type\IntegerType());
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/BinaryType.php b/src/Type/Doctrine/Descriptors/BinaryType.php
new file mode 100644
index 00000000..27e9053b
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/BinaryType.php
@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\MixedType;
+use PHPStan\Type\ResourceType;
+use PHPStan\Type\Type;
+
+class BinaryType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'binary';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new ResourceType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new MixedType();
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/BlobType.php b/src/Type/Doctrine/Descriptors/BlobType.php
new file mode 100644
index 00000000..4f36c998
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/BlobType.php
@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\MixedType;
+use PHPStan\Type\ResourceType;
+use PHPStan\Type\Type;
+
+class BlobType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'blob';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new ResourceType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new MixedType();
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/BooleanType.php b/src/Type/Doctrine/Descriptors/BooleanType.php
new file mode 100644
index 00000000..0b165abe
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/BooleanType.php
@@ -0,0 +1,25 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\Type;
+
+class BooleanType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'boolean';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\BooleanType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\BooleanType();
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/DateImmutableType.php b/src/Type/Doctrine/Descriptors/DateImmutableType.php
new file mode 100644
index 00000000..24fc84fd
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/DateImmutableType.php
@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use DateTimeImmutable;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+
+class DateImmutableType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'date_immutable';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new ObjectType(DateTimeImmutable::class);
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new ObjectType(DateTimeImmutable::class);
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/DateIntervalType.php b/src/Type/Doctrine/Descriptors/DateIntervalType.php
new file mode 100644
index 00000000..e4e3d3ae
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/DateIntervalType.php
@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use DateInterval;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+
+class DateIntervalType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'dateinterval';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new ObjectType(DateInterval::class);
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new ObjectType(DateInterval::class);
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/DateTimeImmutableType.php b/src/Type/Doctrine/Descriptors/DateTimeImmutableType.php
new file mode 100644
index 00000000..6f8b750a
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/DateTimeImmutableType.php
@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use DateTimeImmutable;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+
+class DateTimeImmutableType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'datetime_immutable';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new ObjectType(DateTimeImmutable::class);
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new ObjectType(DateTimeImmutable::class);
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/DateTimeType.php b/src/Type/Doctrine/Descriptors/DateTimeType.php
new file mode 100644
index 00000000..c688be01
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/DateTimeType.php
@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use DateTime;
+use DateTimeInterface;
+use PHPStan\Type\Type;
+
+class DateTimeType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'datetime';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\ObjectType(DateTime::class);
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\ObjectType(DateTimeInterface::class);
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/DateTimeTzImmutableType.php b/src/Type/Doctrine/Descriptors/DateTimeTzImmutableType.php
new file mode 100644
index 00000000..ccc05749
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/DateTimeTzImmutableType.php
@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use DateTimeImmutable;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+
+class DateTimeTzImmutableType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'datetimetz_immutable';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new ObjectType(DateTimeImmutable::class);
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new ObjectType(DateTimeImmutable::class);
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/DateTimeTzType.php b/src/Type/Doctrine/Descriptors/DateTimeTzType.php
new file mode 100644
index 00000000..ef7e7948
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/DateTimeTzType.php
@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use DateTime;
+use DateTimeInterface;
+use PHPStan\Type\Type;
+
+class DateTimeTzType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'datetimetz';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\ObjectType(DateTime::class);
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\ObjectType(DateTimeInterface::class);
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/DateType.php b/src/Type/Doctrine/Descriptors/DateType.php
new file mode 100644
index 00000000..a47454d9
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/DateType.php
@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use DateTime;
+use DateTimeInterface;
+use PHPStan\Type\Type;
+
+class DateType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'date';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\ObjectType(DateTime::class);
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\ObjectType(DateTimeInterface::class);
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/DecimalType.php b/src/Type/Doctrine/Descriptors/DecimalType.php
new file mode 100644
index 00000000..fed7b3b6
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/DecimalType.php
@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+
+class DecimalType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'decimal';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\StringType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return TypeCombinator::union(new \PHPStan\Type\StringType(), new \PHPStan\Type\FloatType(), new \PHPStan\Type\IntegerType());
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/DoctrineTypeDescriptor.php b/src/Type/Doctrine/Descriptors/DoctrineTypeDescriptor.php
new file mode 100644
index 00000000..73e1d86f
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/DoctrineTypeDescriptor.php
@@ -0,0 +1,16 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\Type;
+
+interface DoctrineTypeDescriptor
+{
+
+	public function getType(): string;
+
+	public function getWritableToPropertyType(): Type;
+
+	public function getWritableToDatabaseType(): Type;
+
+}
diff --git a/src/Type/Doctrine/Descriptors/FloatType.php b/src/Type/Doctrine/Descriptors/FloatType.php
new file mode 100644
index 00000000..50e67198
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/FloatType.php
@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+
+class FloatType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'float';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\FloatType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return TypeCombinator::union(new \PHPStan\Type\FloatType(), new \PHPStan\Type\IntegerType());
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/GuidType.php b/src/Type/Doctrine/Descriptors/GuidType.php
new file mode 100644
index 00000000..fac9a030
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/GuidType.php
@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\StringType;
+use PHPStan\Type\Type;
+
+class GuidType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'guid';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new StringType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new StringType();
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/IntegerType.php b/src/Type/Doctrine/Descriptors/IntegerType.php
new file mode 100644
index 00000000..00f231c2
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/IntegerType.php
@@ -0,0 +1,25 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\Type;
+
+class IntegerType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'integer';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\IntegerType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\IntegerType();
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/JsonArrayType.php b/src/Type/Doctrine/Descriptors/JsonArrayType.php
new file mode 100644
index 00000000..79dab63f
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/JsonArrayType.php
@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\MixedType;
+use PHPStan\Type\Type;
+
+class JsonArrayType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'json_array';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\ArrayType(new MixedType(), new MixedType());
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\ArrayType(new MixedType(), new MixedType());
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/JsonType.php b/src/Type/Doctrine/Descriptors/JsonType.php
new file mode 100644
index 00000000..225e5afa
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/JsonType.php
@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\MixedType;
+use PHPStan\Type\Type;
+
+class JsonType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'json';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\ArrayType(new MixedType(), new MixedType());
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\ArrayType(new MixedType(), new MixedType());
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/ObjectType.php b/src/Type/Doctrine/Descriptors/ObjectType.php
new file mode 100644
index 00000000..0e7d601b
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/ObjectType.php
@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\ObjectWithoutClassType;
+use PHPStan\Type\Type;
+
+class ObjectType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'object';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new ObjectWithoutClassType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new ObjectWithoutClassType();
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/SimpleArrayType.php b/src/Type/Doctrine/Descriptors/SimpleArrayType.php
new file mode 100644
index 00000000..4cae3deb
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/SimpleArrayType.php
@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\MixedType;
+use PHPStan\Type\Type;
+
+class SimpleArrayType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'simple_array';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\ArrayType(new MixedType(), new MixedType());
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\ArrayType(new MixedType(), new MixedType());
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/SmallIntType.php b/src/Type/Doctrine/Descriptors/SmallIntType.php
new file mode 100644
index 00000000..05075764
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/SmallIntType.php
@@ -0,0 +1,25 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\Type;
+
+class SmallIntType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'smallint';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\IntegerType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\IntegerType();
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/StringType.php b/src/Type/Doctrine/Descriptors/StringType.php
new file mode 100644
index 00000000..c030be48
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/StringType.php
@@ -0,0 +1,25 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\Type;
+
+class StringType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'string';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\StringType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\StringType();
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/TextType.php b/src/Type/Doctrine/Descriptors/TextType.php
new file mode 100644
index 00000000..1074ba54
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/TextType.php
@@ -0,0 +1,25 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use PHPStan\Type\Type;
+
+class TextType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'text';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\StringType();
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\StringType();
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/TimeImmutableType.php b/src/Type/Doctrine/Descriptors/TimeImmutableType.php
new file mode 100644
index 00000000..f453e122
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/TimeImmutableType.php
@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use DateTimeImmutable;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+
+class TimeImmutableType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'time_immutable';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new ObjectType(DateTimeImmutable::class);
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new ObjectType(DateTimeImmutable::class);
+	}
+
+}
diff --git a/src/Type/Doctrine/Descriptors/TimeType.php b/src/Type/Doctrine/Descriptors/TimeType.php
new file mode 100644
index 00000000..1af9342c
--- /dev/null
+++ b/src/Type/Doctrine/Descriptors/TimeType.php
@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Doctrine\Descriptors;
+
+use DateTime;
+use DateTimeInterface;
+use PHPStan\Type\Type;
+
+class TimeType implements DoctrineTypeDescriptor
+{
+
+	public function getType(): string
+	{
+		return 'time';
+	}
+
+	public function getWritableToPropertyType(): Type
+	{
+		return new \PHPStan\Type\ObjectType(DateTime::class);
+	}
+
+	public function getWritableToDatabaseType(): Type
+	{
+		return new \PHPStan\Type\ObjectType(DateTimeInterface::class);
+	}
+
+}
diff --git a/tests/Rules/Doctrine/ORM/EntityColumnRuleTest.php b/tests/Rules/Doctrine/ORM/EntityColumnRuleTest.php
new file mode 100644
index 00000000..fa366352
--- /dev/null
+++ b/tests/Rules/Doctrine/ORM/EntityColumnRuleTest.php
@@ -0,0 +1,73 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPStan\Type\Doctrine\DescriptorRegistry;
+use PHPStan\Type\Doctrine\Descriptors\BigIntType;
+use PHPStan\Type\Doctrine\Descriptors\BinaryType;
+use PHPStan\Type\Doctrine\Descriptors\DateTimeImmutableType;
+use PHPStan\Type\Doctrine\Descriptors\DateTimeType;
+use PHPStan\Type\Doctrine\Descriptors\StringType;
+use PHPStan\Type\Doctrine\ObjectMetadataResolver;
+
+class EntityColumnRuleTest extends RuleTestCase
+{
+
+	protected function getRule(): Rule
+	{
+		return new EntityColumnRule(
+			new ObjectMetadataResolver(__DIR__ . '/entity-manager.php', null),
+			new DescriptorRegistry([
+				new BigIntType(),
+				new StringType(),
+				new DateTimeType(),
+				new DateTimeImmutableType(),
+				new BinaryType(),
+			])
+		);
+	}
+
+	public function testRule(): void
+	{
+		require_once __DIR__ . '/data/MyBrokenSuperclass.php';
+		$this->analyse([__DIR__ . '/data/MyBrokenEntity.php'], [
+			[
+				'Database can contain string but property expects int.',
+				17,
+			],
+			[
+				'Database can contain string|null but property expects string.',
+				23,
+			],
+			[
+				'Property can contain string|null but database expects string.',
+				29,
+			],
+			[
+				'Database can contain DateTime but property expects DateTimeImmutable.',
+				35,
+			],
+			[
+				'Database can contain DateTimeImmutable but property expects DateTime.',
+				41,
+			],
+			[
+				'Property can contain DateTime but database expects DateTimeImmutable.',
+				41,
+			],
+		]);
+	}
+
+	public function testSuperclass(): void
+	{
+		$this->analyse([__DIR__ . '/data/MyBrokenSuperclass.php'], [
+			[
+				'Database can contain resource but property expects int.',
+				17,
+			],
+		]);
+	}
+
+}
diff --git a/tests/Rules/Doctrine/ORM/data/MyBrokenEntity.php b/tests/Rules/Doctrine/ORM/data/MyBrokenEntity.php
new file mode 100644
index 00000000..42cea9fb
--- /dev/null
+++ b/tests/Rules/Doctrine/ORM/data/MyBrokenEntity.php
@@ -0,0 +1,43 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * @ORM\Entity()
+ */
+class MyBrokenEntity extends MyBrokenSuperclass
+{
+	/**
+	 * @ORM\Id()
+	 * @ORM\Column(type="bigint")
+	 * @var int
+	 */
+	private $id;
+
+	/**
+	 * @ORM\Column(type="string", nullable=true)
+	 * @var string
+	 */
+	private $one;
+
+	/**
+	 * @ORM\Column(type="string")
+	 * @var string|null
+	 */
+	private $two;
+
+	/**
+	 * @ORM\Column(type="datetime")
+	 * @var \DateTimeImmutable
+	 */
+	private $three;
+
+	/**
+	 * @ORM\Column(type="datetime_immutable")
+	 * @var \DateTime
+	 */
+	private $four;
+
+}
diff --git a/tests/Rules/Doctrine/ORM/data/MyBrokenSuperclass.php b/tests/Rules/Doctrine/ORM/data/MyBrokenSuperclass.php
new file mode 100644
index 00000000..51e91ce6
--- /dev/null
+++ b/tests/Rules/Doctrine/ORM/data/MyBrokenSuperclass.php
@@ -0,0 +1,19 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Doctrine\ORM;
+
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * @ORM\MappedSuperclass()
+ */
+abstract class MyBrokenSuperclass
+{
+
+	/**
+	 * @ORM\Column(type="binary")
+	 * @var int
+	 */
+	private $five;
+
+}
diff --git a/tests/Rules/Doctrine/ORM/data/repository-findBy-etc.php b/tests/Rules/Doctrine/ORM/data/repository-findBy-etc.php
index d90eb209..ee5fa6a7 100644
--- a/tests/Rules/Doctrine/ORM/data/repository-findBy-etc.php
+++ b/tests/Rules/Doctrine/ORM/data/repository-findBy-etc.php
@@ -4,7 +4,7 @@
 
 use Doctrine\ORM\EntityManager;
 
-class MagicRepositoryCalls
+class RepositoryFindByCalls
 {
 
 	/** @var EntityManager */