public function testColumnWithMissingTypeDefaultsToString() { $cm = new ClassMetadata(ColumnWithoutType::class); $cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService()); $annotationDriver = $this->_loadDriver(); $annotationDriver->loadMetadataForClass('Doctrine\\Tests\\ORM\\Mapping\\InvalidColumn', $cm); $this->assertEquals('string', $cm->fieldMappings['id']['type']); }
/** * @param ClassMetadata $targetClass * @param array $assoc * @param mixed $actualValue * * @return self */ public static function invalidAssociation(ClassMetadata $targetClass, $assoc, $actualValue) { $expectedType = 'Doctrine\\Common\\Collections\\Collection|array'; if (($assoc['association'] & ClassMetadata::TO_ONE) > 0) { $expectedType = $targetClass->getName(); } return new self(sprintf('Expected value of type "%s" for association field "%s#$%s", got "%s" instead.', $expectedType, $assoc['sourceDoc'], $assoc['fieldName'], is_object($actualValue) ? get_class($actualValue) : gettype($actualValue))); }
/** * Lookup the document class to find methods that match to event lifecycle names * * @param ClassMetadata $metadata The document metadata. * @param string $className The listener class name. * * @throws MappingException When the listener class not found. */ public static function bindDocumentListener(ClassMetadata $metadata, $className) { $class = $metadata->fullyQualifiedClassName($className); if (!class_exists($class)) { throw MappingException::documentListenerClassNotFound($class, $className); } foreach (get_class_methods($class) as $method) { if (!isset(self::$events[$method])) { continue; } $metadata->addDocumentListener($method, $class, $method); } }
/** * Generates a closure capable of initializing a proxy * * @param ClassMetadata $class * @param DocumentPersister $documentPersister * @param \ReflectionProperty $reflectionId * * @return callable */ private function createInitializer(ClassMetadata $class, DocumentPersister $documentPersister, \ReflectionProperty $reflectionId) { if ($class->getReflectionClass()->hasMethod('__wakeup')) { return function (BaseProxy $proxy) use($reflectionId, $documentPersister) { $proxy->__setInitializer(null); $proxy->__setCloner(null); if ($proxy->__isInitialized()) { return; } $properties = $proxy->__getLazyProperties(); foreach ($properties as $propertyName => $property) { if (!isset($proxy->{$propertyName})) { $proxy->{$propertyName} = $properties[$propertyName]; } } $proxy->__setInitialized(true); $proxy->__wakeup(); $rid = $reflectionId->getValue($proxy); if ($documentPersister->load($rid, '*:0', $proxy) === null) { throw DocumentNotFoundException::documentNotFound(get_class($proxy), $rid); } }; } return function (BaseProxy $proxy) use($reflectionId, $documentPersister) { $proxy->__setInitializer(null); $proxy->__setCloner(null); if ($proxy->__isInitialized()) { return; } $properties = $proxy->__getLazyProperties(); foreach ($properties as $propertyName => $property) { if (!isset($proxy->{$propertyName})) { $proxy->{$propertyName} = $properties[$propertyName]; } } $proxy->__setInitialized(true); $rid = $reflectionId->getValue($proxy); if ($documentPersister->load($rid, '*:0', $proxy) === null) { throw DocumentNotFoundException::documentNotFound(get_class($proxy), $rid); } }; }
/** * Detects instances of ClassMetadata that don't need to be processed in the SchemaTool context. * * @param ClassMetadata $class * @param array $processedClasses * * @return bool */ private function processingNotRequired($class, array $processedClasses) { return isset($processedClasses[$class->name]) || $class->isMappedSuperclass(); }
/** * @param string $className * @param ClassMetadata $metadata * @param DocumentListeners $annot * * @throws MappingException */ private function mapDocumentListeners($className, ClassMetadata $metadata, DocumentListeners $annot) { foreach ($annot->value as $item) { $listenerClassName = $metadata->fullyQualifiedClassName($item); if (!class_exists($listenerClassName)) { throw MappingException::documentListenerClassNotFound($listenerClassName, $className); } $hasMapping = false; $listenerClass = new \ReflectionClass($listenerClassName); /* @var $method \ReflectionMethod */ foreach ($listenerClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) { // find method callbacks. $callbacks = $this->getMethodCallbacks($method); $hasMapping = $hasMapping ?: !empty($callbacks); foreach ($callbacks as $value) { $metadata->addDocumentListener($value[1], $listenerClassName, $value[0]); } } // Evaluate the listener using naming convention. if (!$hasMapping) { DocumentListenerBuilder::bindDocumentListener($metadata, $listenerClassName); } } }
/** * @depends can_set_isMappedSuperclass * @test */ function can_clear_isMappedSuperclass() { $this->metadata->clearIsMappedSuperclass(); $this->assertFalse($this->metadata->isMappedSuperclass()); $this->assertEquals(0, $this->metadata->attributes & ClassMetadata::CA_TYPE_MAPPED_SUPERCLASS); }
/** * Prepares the array that is ready to be inserted to mongodb for a given object document. * * @param ClassMetadata $class * @param UnitOfWork $uow * @param object $document * * @return \stdClass $insertData * @throws ODMOrientDbException */ public function prepareData(ClassMetadata $class, UnitOfWork $uow, $document) { $insertData = new \stdClass(); if ($class->isEmbeddedDocument()) { $insertData->{'@type'} = 'd'; $insertData->{'@class'} = $class->getOrientClass(); $cs = $uow->getDocumentActualData($document); } else { $cs = $uow->getDocumentChangeSet($document); array_Walk($cs, function (&$val) { $val = $val[1]; }); } $mappings =& $class->fieldMappings; foreach ($cs as $name => $new) { $mapping = isset($mappings[$name]) ? $mappings[$name] : null; if ($mapping === null) { // don't store arbitrary values for now continue; } // Don't store null values unless nullable === true if ($new === null && $mapping['nullable'] === false) { continue; } $value = null; if ($new !== null) { switch (true) { // @Property case !isset($mapping['association']): $value = Type::getType($mapping['type'])->convertToDatabaseValue($new); break; case $mapping['association'] & ClassMetadata::LINK: $value = $this->getDocReference($new); break; case $mapping['association'] & ClassMetadata::LINK_MANY: // initialize the link collection if ($mapping['association'] & ClassMetadata::LINK_MAP) { $value = new \stdClass(); } else { $value = []; } break; case $mapping['association'] & ClassMetadata::EMBED: /** @var ClassMetadata $rmd */ $rmd = $this->metadataFactory->getMetadataFor(get_class($new)); $value = $this->prepareData($rmd, $uow, $new); break; case $mapping['association'] & ClassMetadata::EMBED_MANY: $value = []; if ($mapping['association'] & ClassMetadata::EMBED_MAP) { foreach ($new as $k => $item) { /** @var ClassMetadata $rmd */ $rmd = $this->metadataFactory->getMetadataFor(get_class($item)); $value[$k] = $this->prepareData($rmd, $uow, $item); } } else { foreach ($new as $k => $item) { /** @var ClassMetadata $rmd */ $rmd = $this->metadataFactory->getMetadataFor(get_class($item)); $value[] = $this->prepareData($rmd, $uow, $item); } } break; } } $insertData->{$mapping['name']} = $value; } return $insertData; }
/** * Adds inherited fields to the subclass mapping. * * @param ClassMetadata $subClass * @param ClassMetadata $parentClass */ private function addInheritedFields(ClassMetadata $subClass, ClassMetadata $parentClass) { foreach ($parentClass->fieldMappings as $fieldName => $mapping) { if (!isset($mapping['inherited']) && !$parentClass->isMappedSuperclass()) { $mapping['inherited'] = $parentClass->name; } if (!isset($mapping['declared'])) { $mapping['declared'] = $parentClass->name; } $subClass->addInheritedFieldMapping($mapping); } foreach ($parentClass->reflFields as $name => $field) { $subClass->reflFields[$name] = $field; } }
/** * @param object $document * * @return bool */ public function exists($document) { $rid = $this->class->getIdentifierValue($document); return $this->binding->documentExists($rid); }
/** * Returns the POPO class associated with this repository. * * @return string */ public function getClassName() { return $this->metadata->getName(); }
/** * @depends load_edge_document * @test * * @param ClassMetadata $md * * @return ClassMetadata */ public function is_edge_document(ClassMetadata $md) { $this->assertTrue($md->isEdge()); return $md; }
private function addFieldMapping(ClassMetadata $metadata, &$mapping) { $metadata->mapField($mapping); }