getTable() public method

Gets table name from given fully qualified entity class name
public getTable ( string $entityClass ) : string
$entityClass string
return string
コード例 #1
0
 /**
  * @param string $definition
  * @param string $alias
  * @param string $type
  * @throws InvalidArgumentException
  */
 public function addJoinByType($definition, $alias, $type)
 {
     list($fromAlias, $viaProperty) = $this->parseDotNotation($definition);
     $entityReflection = $this->getReflection($fromEntity = $this->aliases->getEntityClass($fromAlias));
     $property = $entityReflection->getEntityProperty($viaProperty);
     if (!$property->hasRelationship()) {
         throw new InvalidArgumentException();
     }
     $relationship = $property->getRelationship();
     if ($relationship instanceof HasMany) {
         $this->clauses->join[] = array('type' => $type, 'joinParameters' => array($relationshipTable = $relationship->getRelationshipTable(), $relTableAlias = $relationshipTable . $this->indexer), 'onParameters' => array($fromAlias, $primaryKey = $this->mapper->getPrimaryKey($fromTable = $this->mapper->getTable($fromEntity)), $relTableAlias, $columnReferencingSourceTable = $relationship->getColumnReferencingSourceTable()));
         $this->hydratorMeta->addTablePrefix($relTableAlias, $relationshipTable);
         $this->hydratorMeta->addPrimaryKey($relationshipTable, $relTablePrimaryKey = $this->mapper->getPrimaryKey($relationshipTable));
         $this->hydratorMeta->addRelationship($alias, new Relationship($fromAlias, $fromTable, $columnReferencingSourceTable, Relationship::DIRECTION_REFERENCING, $relTableAlias, $relationshipTable, $primaryKey));
         $this->clauses->join[] = array('type' => $type, 'joinParameters' => array($targetTable = $relationship->getTargetTable(), $alias), 'onParameters' => array($relTableAlias, $columnReferencingTargetTable = $relationship->getColumnReferencingTargetTable(), $alias, $primaryKey = $this->mapper->getPrimaryKey($targetTable)));
         $this->aliases->addAlias($alias, $property->getType());
         $this->hydratorMeta->addTablePrefix($alias, $targetTable);
         $this->hydratorMeta->addPrimaryKey($targetTable, $primaryKey);
         $this->hydratorMeta->addRelationship($relTableAlias, new Relationship($relTableAlias, $relationshipTable, $columnReferencingTargetTable, Relationship::DIRECTION_REFERENCED, $alias, $targetTable, $primaryKey));
         $this->relationshipTables[$alias] = array($relTableAlias, $relTablePrimaryKey, $relTableAlias . QueryHelper::PREFIX_SEPARATOR . $relTablePrimaryKey, $relTableAlias, $columnReferencingSourceTable, $relTableAlias . QueryHelper::PREFIX_SEPARATOR . $columnReferencingSourceTable, $relTableAlias, $columnReferencingTargetTable, $relTableAlias . QueryHelper::PREFIX_SEPARATOR . $columnReferencingTargetTable);
         $this->indexer++;
     } else {
         $this->clauses->join[] = array('type' => $type, 'joinParameters' => array($targetTable = $relationship->getTargetTable(), $alias), 'onParameters' => $relationship instanceof HasOne ? array($fromAlias, $relationshipColumn = $relationship->getColumnReferencingTargetTable(), $alias, $primaryKey = $this->mapper->getPrimaryKey($targetTable)) : array($fromAlias, $primaryKey = $this->mapper->getPrimaryKey($fromTable = $this->mapper->getTable($fromEntity)), $alias, $columnReferencingSourceTable = $relationship->getColumnReferencingSourceTable()));
         $this->aliases->addAlias($alias, $property->getType());
         $this->hydratorMeta->addTablePrefix($alias, $targetTable);
         if ($relationship instanceof HasOne) {
             $this->hydratorMeta->addPrimaryKey($targetTable, $primaryKey);
             $this->hydratorMeta->addRelationship($alias, new Relationship($fromAlias, $this->mapper->getTable($fromEntity), $relationshipColumn, Relationship::DIRECTION_REFERENCED, $alias, $targetTable, $primaryKey));
         } else {
             $this->hydratorMeta->addPrimaryKey($targetTable, $targetTablePrimaryKey = $this->mapper->getPrimaryKey($targetTable));
             $this->hydratorMeta->addRelationship($fromAlias, new Relationship($fromAlias, $fromTable, $columnReferencingSourceTable, Relationship::DIRECTION_REFERENCING, $alias, $targetTable, $primaryKey));
         }
     }
 }
コード例 #2
0
ファイル: Query.php プロジェクト: inlm/query-object
 private function replaceEntitiesForItsPrimaryKeyValues(array $entities)
 {
     foreach ($entities as &$entity) {
         if ($entity instanceof LeanMapper\Entity) {
             $entityTable = $this->mapper->getTable(get_class($entity));
             // FIXME: Column name could be specified in the entity instead of mapper provided by 'getEntityField' function.
             $idField = $this->mapper->getEntityField($entityTable, $this->mapper->getPrimaryKey($entityTable));
             $entity = $entity->{$idField};
         }
     }
     return $entities;
 }
コード例 #3
0
ファイル: Repository.php プロジェクト: tharos/leanmapper
 /**
  * @param Entity $entity
  * @return mixed
  */
 private function getIdValue(Entity $entity)
 {
     $table = $this->getTable();
     do {
         $primaryKey = $this->mapper->getPrimaryKey($table);
         $idField = $this->mapper->getEntityField($table, $primaryKey);
         $value = $entity->{$idField};
         if (!$value instanceof Entity) {
             return $value;
         }
         $entity = $value;
         $table = $this->mapper->getTable(get_class($entity));
     } while (true);
 }
コード例 #4
0
ファイル: DomainQuery.php プロジェクト: jasir/LeanQuery
 /**
  * @return Entity[]
  */
 public function getEntities($limit = null, $offset = null)
 {
     if ($this->entities === NULL) {
         $entities = array();
         $entityClass = $this->clauses->from['entityClass'];
         $result = $this->getResult($this->clauses->from['alias'], $limit, $offset);
         $primaryKey = $this->mapper->getPrimaryKey($this->mapper->getTable($entityClass));
         foreach ($result as $key => $row) {
             $entity = $this->entityFactory->createEntity($entityClass, new Row($result, $key));
             $entities[$entity->{$primaryKey}] = $entity;
             $entity->makeAlive($this->entityFactory, $this->connection, $this->mapper);
             $entity->cleanReferencingRowsCache();
         }
         $this->entities = $this->entityFactory->createCollection($entities);
     }
     return $this->entities;
 }
コード例 #5
0
ファイル: Entity.php プロジェクト: tharos/leanmapper
 /**
  * @param string $action
  * @param string $name
  * @param mixed $arg
  * @throws InvalidMethodCallException
  * @throws InvalidArgumentException
  * @throws InvalidValueException
  */
 private function addToOrRemoveFrom($action, $name, $arg)
 {
     if ($this->isDetached()) {
         throw new InvalidMethodCallException('Cannot add or remove related entity to detached entity.');
     }
     if ($arg === null) {
         throw new InvalidArgumentException('Invalid argument given in entity ' . get_called_class() . '.');
     }
     if (is_array($arg) or $arg instanceof Traversable and !$arg instanceof Entity) {
         foreach ($arg as $value) {
             $this->addToOrRemoveFrom($action, $name, $value);
         }
     } else {
         $method = $action === self::ACTION_ADD ? 'addTo' : 'removeFrom';
         $property = $this->getCurrentReflection()->getEntityProperty($name);
         if ($property === null or !$property->hasRelationship() or !$property->getRelationship() instanceof Relationship\HasMany) {
             throw new InvalidMethodCallException("Cannot call {$method} method with '{$name}' property in entity " . get_called_class() . '. Only properties with m:hasMany relationship can be managed this way.');
         }
         if ($property->getFilters()) {
             throw new InvalidMethodCallException("Cannot call {$method} method with '{$name}' property in entity " . get_called_class() . '. Only properties without filters can be managed this way.');
             // deliberate restriction
         }
         $relationship = $property->getRelationship();
         if ($arg instanceof Entity) {
             if ($arg->isDetached()) {
                 throw new InvalidArgumentException('Cannot add or remove detached entity ' . get_class($arg) . " to {$name} in entity " . get_called_class() . '.');
             }
             $type = $property->getType();
             if (!$arg instanceof $type) {
                 $type = gettype($arg) !== 'object' ? gettype($arg) : 'instance of ' . get_class($arg);
                 throw new InvalidValueException("Unexpected value type given in property '{$property->getName()}' in entity " . get_called_class() . ", {$property->getType()} expected, {$type} given.");
             }
             $data = $arg->getRowData();
             $arg = $data[$this->mapper->getPrimaryKey($relationship->getTargetTable())];
         }
         $table = $this->mapper->getTable($this->getCurrentReflection()->getName());
         $values = [$relationship->getColumnReferencingSourceTable() => $this->row->{$this->mapper->getPrimaryKey($table)}, $relationship->getColumnReferencingTargetTable() => $arg];
         $method .= 'Referencing';
         $this->row->{$method}($values, $relationship->getRelationshipTable(), $relationship->getColumnReferencingSourceTable(), null, $relationship->getStrategy());
     }
 }
コード例 #6
0
ファイル: PropertyFactory.php プロジェクト: tharos/leanmapper
 /**
  * @param string $sourceClass
  * @param PropertyType $propertyType
  * @param string $relationshipType
  * @param string|null $definition
  * @param IMapper|null $mapper
  * @return mixed
  * @throws InvalidAnnotationException
  */
 private static function createRelationship($sourceClass, PropertyType $propertyType, $relationshipType, $definition = null, IMapper $mapper = null)
 {
     if ($relationshipType !== 'hasOne') {
         $strategy = Result::STRATEGY_IN;
         // default strategy
         if ($definition !== null and substr($definition, -6) === '#union') {
             $strategy = Result::STRATEGY_UNION;
             $definition = substr($definition, 0, -6);
         }
     }
     $pieces = array_replace(array_fill(0, 6, ''), $definition !== null ? explode(':', $definition) : []);
     $sourceTable = $mapper !== null ? $mapper->getTable($sourceClass) : null;
     $targetTable = $mapper !== null ? $mapper->getTable($propertyType->getType()) : null;
     switch ($relationshipType) {
         case 'hasOne':
             $relationshipColumn = $mapper !== null ? $mapper->getRelationshipColumn($sourceTable, $targetTable) : self::getSurrogateRelationshipColumn($propertyType);
             return new Relationship\HasOne($pieces[0] ?: $relationshipColumn, $pieces[1] ?: $targetTable);
         case 'hasMany':
             return new Relationship\HasMany($pieces[0] ?: ($mapper !== null ? $mapper->getRelationshipColumn($mapper->getRelationshipTable($sourceTable, $targetTable), $sourceTable) : null), $pieces[1] ?: ($mapper !== null ? $mapper->getRelationshipTable($sourceTable, $targetTable) : null), $pieces[2] ?: ($mapper !== null ? $mapper->getRelationshipColumn($mapper->getRelationshipTable($sourceTable, $targetTable), $targetTable) : null), $pieces[3] ?: $targetTable, $strategy);
         case 'belongsToOne':
             $relationshipColumn = $mapper !== null ? $mapper->getRelationshipColumn($targetTable, $sourceTable) : $sourceTable;
             return new Relationship\BelongsToOne($pieces[0] ?: $relationshipColumn, $pieces[1] ?: $targetTable, $strategy);
         case 'belongsToMany':
             $relationshipColumn = $mapper !== null ? $mapper->getRelationshipColumn($targetTable, $sourceTable) : $sourceTable;
             return new Relationship\BelongsToMany($pieces[0] ?: $relationshipColumn, $pieces[1] ?: $targetTable, $strategy);
     }
     return null;
 }
コード例 #7
0
 public function createSchema(array $entities)
 {
     $config = array_merge($this->defaultConfig, $this->options);
     $schema = new Schema();
     Type::addType(LongTextType::LONG_TEXT, '\\Joseki\\Migration\\Generator\\DBAL\\Types\\LongTextType');
     Type::addType(TimestampType::TIMESTAMP, '\\Joseki\\Migration\\Generator\\DBAL\\Types\\TimestampType');
     $createdTables = [];
     /** @var \LeanMapper\Entity $entity */
     foreach ($entities as $entity) {
         $reflection = $entity->getReflection($this->mapper);
         $properties = $reflection->getEntityProperties();
         $onEnd = [];
         if (count($properties) === 0) {
             continue;
         }
         $tableName = $this->mapper->getTable(get_class($entity));
         $table = $schema->createTable($tableName);
         $table->addOption('collate', $config['collate']);
         $primaryKey = $this->mapper->getPrimaryKey($tableName);
         foreach ($properties as $property) {
             /** @var Property $property */
             if ($this->isIgnored($property)) {
                 continue;
             }
             if (!$property->hasRelationship()) {
                 if (!$property->isWritable()) {
                     continue;
                 }
                 $type = $this->getType($property);
                 if ($type === null) {
                     throw new \Exception('Unknown type');
                 }
                 /** @var Column $column */
                 $column = $table->addColumn($property->getColumn(), $type);
                 if ($property->getName() == $primaryKey) {
                     $table->setPrimaryKey([$property->getColumn()]);
                     if ($property->hasCustomFlag('unique')) {
                         throw new Exception\InvalidAnnotationException("Entity {$reflection->name}:{$property->getName()} - m:unique can not be used together with m:pk.");
                     }
                     if ($config['autoincrement'] == 'auto' && $type === 'integer') {
                         $column->setAutoincrement(true);
                     }
                 }
                 if ($property->hasCustomFlag('autoincrement')) {
                     $column->setAutoincrement(true);
                 }
                 if ($type == 'string' && $property->hasCustomFlag('size')) {
                     $column->setLength($property->getCustomFlagValue('size'));
                 }
                 if ($type == TimestampType::TIMESTAMP) {
                     $flagArgs = explode(':', strtolower($property->getCustomFlagValue('type')));
                     if (count($flagArgs) > 1 && $flagArgs[1] == 'true') {
                         $column->setColumnDefinition('TIMESTAMP NOT NULL ON UPDATE CURRENT_TIMESTAMP');
                     } else {
                         $column->setColumnDefinition('TIMESTAMP NOT NULL');
                     }
                 }
             } else {
                 $relationship = $property->getRelationship();
                 if ($relationship instanceof HasMany) {
                     $relationshipTableName = $relationship->getRelationshipTable();
                     if (!in_array($relationshipTableName, $createdTables)) {
                         $createdTables[] = $relationshipTableName;
                         $relationshipTable = $schema->createTable($relationship->getRelationshipTable());
                         $cascade = $config['cascading'] ? 'CASCADE' : 'NO ACTION';
                         $columnReferencingSourceTable = $relationship->getColumnReferencingSourceTable();
                         $sourceTableType = $this->getRelationshipColumnType($columnReferencingSourceTable);
                         $sourceColumn = $relationshipTable->addColumn($columnReferencingSourceTable, $sourceTableType);
                         $primaryKey1 = $this->mapper->getPrimaryKey($tableName);
                         $columnReferencingTargetTable = $relationship->getColumnReferencingTargetTable();
                         $targetTableType = $this->getRelationshipColumnType($columnReferencingTargetTable);
                         $targetColumn = $relationshipTable->addColumn($columnReferencingTargetTable, $targetTableType);
                         $primaryKey2 = $this->mapper->getPrimaryKey($relationship->getTargetTable());
                         $relationshipTable->addForeignKeyConstraint($table, [$columnReferencingSourceTable], [$primaryKey1], ['onDelete' => $cascade, 'onUpdate' => $cascade]);
                         $relationshipTable->addForeignKeyConstraint($relationship->getTargetTable(), [$columnReferencingTargetTable], [$primaryKey2], ['onDelete' => $cascade, 'onUpdate' => $cascade]);
                         $sourceColumnProperty = $this->getRelationshipColumnProperty($tableName);
                         if ($this->getType($sourceColumnProperty) === 'string' && $sourceColumnProperty->hasCustomFlag('size')) {
                             $sourceColumn->setLength($sourceColumnProperty->getCustomFlagValue('size'));
                         }
                         $targetColumnProperty = $this->getRelationshipColumnProperty($relationship->getTargetTable());
                         if ($this->getType($targetColumnProperty) === 'string' && $targetColumnProperty->hasCustomFlag('size')) {
                             $targetColumn->setLength($targetColumnProperty->getCustomFlagValue('size'));
                         }
                     }
                 } elseif ($relationship instanceof HasOne) {
                     $targetEntityClass = $property->getType();
                     $targetTable = $this->mapper->getTable($targetEntityClass);
                     $targetType = $this->getRelationshipColumnType($targetTable);
                     $column = $table->addColumn($relationship->getColumnReferencingTargetTable(), $targetType);
                     $targetColumnProperty = $this->getRelationshipColumnProperty($targetTable);
                     if ($this->getType($targetColumnProperty) === 'string' && $targetColumnProperty->hasCustomFlag('size')) {
                         $column->setLength($targetColumnProperty->getCustomFlagValue('size'));
                     }
                     if (!$property->hasCustomFlag('nofk')) {
                         $onDeleteCascade = $config['cascading'] ? $property->isNullable() ? 'SET NULL' : 'CASCADE' : 'NO ACTION';
                         $onUpdateCascade = $config['cascading'] ? $property->isNullable() ? 'SET NULL' : 'CASCADE' : 'NO ACTION';
                         $table->addForeignKeyConstraint($relationship->getTargetTable(), [$column->getName()], [$this->mapper->getPrimaryKey($relationship->getTargetTable())], ['onDelete' => $onDeleteCascade, 'onUpdate' => $onUpdateCascade]);
                     }
                 }
             }
             if ($property->hasCustomFlag('unique')) {
                 $indexColumns = $this->parseColumns($property->getCustomFlagValue('unique'), [$column->getName()]);
                 $onEnd[] = $this->createIndexClosure($table, $indexColumns, true);
             }
             if ($property->hasCustomFlag('index')) {
                 $indexColumns = $this->parseColumns($property->getCustomFlagValue('index'), [$column->getName()]);
                 $onEnd[] = $this->createIndexClosure($table, $indexColumns, false);
             }
             if ($property->hasCustomFlag('comment')) {
                 $column->setComment($property->getCustomFlagValue('comment'));
             }
             if (isset($column)) {
                 if ($property->isNullable()) {
                     $column->setNotnull(false);
                 }
                 if ($property->hasDefaultValue()) {
                     $column->setDefault($property->getDefaultValue());
                 }
             }
         }
         foreach ($onEnd as $cb) {
             $cb();
         }
     }
     return $schema;
 }