PHP Table::association方法代码示例

 /**
  * Method that renders Entity values through Field Handler Factory.
  *
  * @param  Cake\ORM\Entity       $entity    Entity instance
  * @param  Cake\ORM\Table|string $table     Table instance
  * @param  array                 $fields    Fields to prettify
  * @return void
  */
 protected function _prettify(Entity $entity, $table, array $fields = [])
 {
     if (!$this->__fhf instanceof FieldHandlerFactory) {
         $this->__fhf = new FieldHandlerFactory();
     }
     if (empty($fields)) {
         $fields = array_keys($entity->toArray());
     }
     foreach ($fields as $field) {
         // handle belongsTo associated data
         if ($entity->{$field} instanceof Entity) {
             $tableName = $table->association($entity->{$field}->source())->className();
             $this->_prettify($entity->{$field}, $tableName);
         }
         // handle hasMany associated data
         if (is_array($entity->{$field})) {
             if (empty($entity->{$field})) {
                 continue;
             }
             foreach ($entity->{$field} as $associatedEntity) {
                 if (!$associatedEntity instanceof Entity) {
                     continue;
                 }
                 $tableName = $table->association($associatedEntity->source())->className();
                 $this->_prettify($associatedEntity, $tableName);
             }
         }
         $renderOptions = ['entity' => $entity];
         $entity->{$field} = $this->__fhf->renderValue($table instanceof Table ? $table->registryAlias() : $table, $field, $entity->{$field}, $renderOptions);
     }
 }

 /**
  * Build the map of property => marshalling callable.
  *
  * @param array $data The data being marshalled.
  * @param array $options List of options containing the 'associated' key.
  * @throws \InvalidArgumentException When associations do not exist.
  * @return array
  */
 protected function _buildPropertyMap($data, $options)
 {
     $map = [];
     $schema = $this->_table->schema();
     // Is a concrete column?
     foreach (array_keys($data) as $prop) {
         $columnType = $schema->columnType($prop);
         if ($columnType) {
             $map[$prop] = function ($value, $entity) use($columnType) {
                 return Type::build($columnType)->marshal($value);
             };
         }
     }
     // Map associations
     if (!isset($options['associated'])) {
         $options['associated'] = [];
     }
     $include = $this->_normalizeAssociations($options['associated']);
     foreach ($include as $key => $nested) {
         if (is_int($key) && is_scalar($nested)) {
             $key = $nested;
             $nested = [];
         }
         $assoc = $this->_table->association($key);
         // If the key is not a special field like _ids or _joinData
         // it is a missing association that we should error on.
         if (!$assoc) {
             if (substr($key, 0, 1) !== '_') {
                 throw new \InvalidArgumentException(sprintf('Cannot marshal data for "%s" association. It is not associated with "%s".', $key, $this->_table->alias()));
             }
             continue;
         }
         if (isset($options['forceNew'])) {
             $nested['forceNew'] = $options['forceNew'];
         }
         if (isset($options['isMerge'])) {
             $callback = function ($value, $entity) use($assoc, $nested) {
                 $options = $nested + ['associated' => []];
                 return $this->_mergeAssociation($entity->get($assoc->property()), $assoc, $value, $options);
             };
         } else {
             $callback = function ($value, $entity) use($assoc, $nested) {
                 $options = $nested + ['associated' => []];
                 return $this->_marshalAssociation($assoc, $value, $options);
             };
         }
         $map[$assoc->property()] = $callback;
     }
     $behaviors = $this->_table->behaviors();
     foreach ($behaviors->loaded() as $name) {
         $behavior = $behaviors->get($name);
         if ($behavior instanceof PropertyMarshalInterface) {
             $map += $behavior->buildMarshalMap($this, $map, $options);
         }
     }
     return $map;
 }

 /**
  * Build the map of property => association names.
  *
  * @param array $include The array of included associations.
  * @return array
  */
 protected function _buildPropertyMap($include)
 {
     $map = [];
     foreach ($include as $key => $nested) {
         if (is_int($key) && is_scalar($nested)) {
             $key = $nested;
             $nested = [];
         }
         $nested = isset($nested['associated']) ? $nested['associated'] : [];
         $assoc = $this->_table->association($key);
         if ($assoc) {
             $map[$assoc->property()] = ['association' => $assoc, 'nested' => $nested];
         }
     }
     return $map;
 }

 /**
  * Build the map of property => association names.
  *
  * @param array $include The array of included associations.
  * @return array
  */
 protected function _buildPropertyMap($include)
 {
     if (empty($include['associated'])) {
         return [];
     }
     foreach ($include['associated'] as $key => $options) {
         if (is_int($key) && is_scalar($options)) {
             $key = $options;
             $options = [];
         }
         $options += ['validate' => true, 'associated' => []];
         $assoc = $this->_table->association($key);
         if ($assoc) {
             $map[$assoc->property()] = ['association' => $assoc, 'options' => $options];
         }
     }
     return $map;
 }

 /**
  * Build the map of property => association names.
  *
  * @param array $options List of options containing the 'associated' key.
  * @return array
  */
 protected function _buildPropertyMap($options)
 {
     if (empty($options['associated'])) {
         return [];
     }
     $include = $options['associated'];
     $map = [];
     $include = $this->_normalizeAssociations($include);
     foreach ($include as $key => $nested) {
         if (is_int($key) && is_scalar($nested)) {
             $key = $nested;
             $nested = [];
         }
         $assoc = $this->_table->association($key);
         if ($assoc) {
             $map[$assoc->property()] = ['association' => $assoc] + $nested + ['associated' => []];
         }
     }
     return $map;
 }

 /**
  * Returns the ids found for each of the condition arrays passed for the translations
  * table. Each records is indexed by the corresponding position to the conditions array
  *
  * @param array $ruleSet an array of arary of conditions to be used for finding each
  * @return array
  */
 protected function _findExistingTranslations($ruleSet)
 {
     $association = $this->_table->association($this->_translationTable->alias());
     $query = $association->find()->select(['id', 'num' => 0])->where(current($ruleSet))->hydrate(false)->bufferResults(false);
     unset($ruleSet[0]);
     foreach ($ruleSet as $i => $conditions) {
         $q = $association->find()->select(['id', 'num' => $i])->where($conditions);
         $query->unionAll($q);
     }
     return $query->combine('num', 'id')->toArray();
 }

 /**
  * Returns association object for all versions or single field version.
  *
  * @param string|null $field Field name for per-field association.
  * @param array $options Association options.
  * @return \Cake\ORM\Association
  */
 public function versionAssociation($field = null, $options = [])
 {
     $name = $this->_associationName($field);
     if (!$this->_table->associations()->has($name)) {
         $model = $this->_config['referenceName'];
         if ($field) {
             $this->_table->hasOne($name, $options + ['className' => $this->_config['versionTable'], 'foreignKey' => $this->_config['foreignKey'], 'joinType' => 'LEFT', 'conditions' => [$name . '.model' => $model, $name . '.field' => $field], 'propertyName' => $field . '_version']);
         } else {
             $this->_table->hasMany($name, $options + ['className' => $this->_config['versionTable'], 'foreignKey' => $this->_config['foreignKey'], 'strategy' => 'subquery', 'conditions' => ["{$name}.model" => $model], 'propertyName' => '__version', 'dependent' => true]);
         }
     }
     return $this->_table->association($name);
 }

 /**
  * Build the map of property => association names.
  *
  * @param array $options List of options containing the 'associated' key.
  * @throws \RuntimeException When associations do not exist.
  * @return array
  */
 protected function _buildPropertyMap($options)
 {
     if (empty($options['associated'])) {
         return [];
     }
     $include = $options['associated'];
     $map = [];
     $include = $this->_normalizeAssociations($include);
     foreach ($include as $key => $nested) {
         if (is_int($key) && is_scalar($nested)) {
             $key = $nested;
             $nested = [];
         }
         if ($key === '_joinData') {
             continue;
         }
         $assoc = $this->_table->association($key);
         if (!$assoc) {
             throw new RuntimeException(sprintf('Cannot marshal data for "%s" association. It is not associated with "%s".', $key, $this->_table->alias()));
         }
         $map[$assoc->property()] = ['association' => $assoc] + $nested + ['associated' => []];
     }
     return $map;
 }

 /**
  * @param \ArrayObject $data
  * @param \Cake\ORM\Table $table
  * @return \ArrayObject
  */
 protected function _process($data, Table $table)
 {
     $associations = [];
     /* @var \Cake\ORM\Association $association */
     foreach ($table->associations() as $association) {
         $associations[$association->property()] = $association->name();
     }
     foreach ($data as $key => $value) {
         if (array_key_exists($key, $associations)) {
             $data[$key] = $this->_process($data[$key], $table->association($associations[$key])->target());
             continue;
         }
         $nullable = Hash::get((array) $table->schema()->column($key), 'null');
         if ($nullable !== true) {
             continue;
         }
         if ($value !== '') {
             continue;
         }
         $default = Hash::get((array) $table->schema()->column($key), 'default');
         $data[$key] = $default;
     }
     return $data;
 }

 /**
  * Auxiliary function responsible for fully normalizing deep associations defined
  * using `contain()`
  *
  * @param Table $parent owning side of the association
  * @param string $alias name of the association to be loaded
  * @param array $options list of extra options to use for this association
  * @param array $paths An array with two values, the first one is a list of dot
  * separated strings representing associations that lead to this `$alias` in the
  * chain of associations to be loaded. The second value is the path to follow in
  * entities' properties to fetch a record of the corresponding association.
  * @return array normalized associations
  * @throws \InvalidArgumentException When containments refer to associations that do not exist.
  */
 protected function _normalizeContain(Table $parent, $alias, $options, $paths)
 {
     $defaults = $this->_containOptions;
     $instance = $parent->association($alias);
     if (!$instance) {
         throw new InvalidArgumentException(sprintf('%s is not associated with %s', $parent->alias(), $alias));
     }
     if ($instance->alias() !== $alias) {
         throw new InvalidArgumentException(sprintf("You have contained '%s' but that association was bound as '%s'.", $alias, $instance->alias()));
     }
     $paths += ['aliasPath' => '', 'propertyPath' => '', 'root' => $alias];
     $paths['aliasPath'] .= '.' . $alias;
     $paths['propertyPath'] .= '.' . $instance->property();
     $table = $instance->target();
     $extra = array_diff_key($options, $defaults);
     $config = ['associations' => [], 'instance' => $instance, 'config' => array_diff_key($options, $extra), 'aliasPath' => trim($paths['aliasPath'], '.'), 'propertyPath' => trim($paths['propertyPath'], '.')];
     $config['canBeJoined'] = $instance->canBeJoined($config['config']);
     $eagerLoadable = new EagerLoadable($alias, $config);
     if ($config['canBeJoined']) {
         $this->_aliasList[$paths['root']][$alias][] = $eagerLoadable;
     } else {
         $paths['root'] = $config['aliasPath'];
     }
     foreach ($extra as $t => $assoc) {
         $eagerLoadable->addAssociation($t, $this->_normalizeContain($table, $t, $assoc, $paths));
     }
     return $eagerLoadable;
 }

 /**
  * Generate associations on the junction table as necessary
  *
  * Generates the following associations:
  *
  * - junction belongsTo source e.g. ArticlesTags belongsTo Tags
  * - junction belongsTo target e.g. ArticlesTags belongsTo Articles
  *
  * You can override these generated associations by defining associations
  * with the correct aliases.
  *
  * @param \Cake\ORM\Table $junction The junction table.
  * @param \Cake\ORM\Table $source The source table.
  * @param \Cake\ORM\Table $target The target table.
  * @return void
  */
 protected function _generateJunctionAssociations($junction, $source, $target)
 {
     $tAlias = $target->alias();
     $sAlias = $source->alias();
     if (!$junction->association($tAlias)) {
         $junction->belongsTo($tAlias, ['foreignKey' => $this->targetForeignKey(), 'targetTable' => $target]);
     }
     if (!$junction->association($sAlias)) {
         $junction->belongsTo($sAlias, ['foreignKey' => $this->foreignKey(), 'targetTable' => $source]);
     }
 }

 /**
  * Used to recursively add contained association column types to
  * the query.
  *
  * @param \Cake\ORM\Table $table The table instance to pluck associations from.
  * @param \Cake\Database\TypeMap $typeMap The typemap to check for columns in.
  *   This typemap is indirectly mutated via Cake\ORM\Query::addDefaultTypes()
  * @param array $associations The nested tree of associations to walk.
  * @return void
  */
 protected function _addAssociationsToTypeMap($table, $typeMap, $associations)
 {
     $typeMap = $this->typeMap();
     foreach ($associations as $name => $nested) {
         $association = $table->association($name);
         if (!$association) {
             continue;
         }
         $target = $association->target();
         $primary = (array) $target->primaryKey();
         if (empty($primary) || $typeMap->type($target->aliasField($primary[0])) === null) {
             $this->addDefaultTypes($target);
         }
         if (!empty($nested)) {
             $this->_addAssociationsToTypeMap($target, $typeMap, $nested);
         }
     }
 }

 /**
  * Test that save has append as the default save strategy
  *
  * @return void
  */
 public function testSaveDefaultSaveStrategy()
 {
     $authors = new Table(['table' => 'authors', 'alias' => 'Authors', 'connection' => $this->connection, 'entityClass' => 'Cake\\ORM\\Entity']);
     $authors->hasMany('Articles', ['saveStrategy' => 'append']);
     $this->assertEquals('append', $authors->association('articles')->saveStrategy());
 }

 /**
  * Tests that BelongsToMany() creates and configures correctly the association
  *
  * @return void
  */
 public function testBelongsToMany()
 {
     $options = ['foreignKey' => 'thing_id', 'joinTable' => 'things_tags', 'conditions' => ['b' => 'c'], 'sort' => ['foo' => 'asc']];
     $table = new Table(['table' => 'authors', 'connection' => $this->connection]);
     $belongsToMany = $table->belongsToMany('tag', $options);
     $this->assertInstanceOf('Cake\\ORM\\Association\\BelongsToMany', $belongsToMany);
     $this->assertSame($belongsToMany, $table->association('tag'));
     $this->assertEquals('tag', $belongsToMany->name());
     $this->assertEquals('thing_id', $belongsToMany->foreignKey());
     $this->assertEquals(['b' => 'c'], $belongsToMany->conditions());
     $this->assertEquals(['foo' => 'asc'], $belongsToMany->sort());
     $this->assertSame($table, $belongsToMany->source());
     $this->assertSame('things_tags', $belongsToMany->junction()->table());
 }

 /**
  * Iterate all associations and update counter caches.
  *
  * @param Event $event
  * @param Entity $entity
  * @return void
  */
 protected function _processAssociations(Event $event, Entity $entity)
 {
     foreach ($this->_config as $assoc => $settings) {
         $assoc = $this->_table->association($assoc);
         $this->_processAssociation($event, $entity, $assoc, $settings);
     }
 }