PHP PropelObjectCollection::toKeyValue方法代码示例

 /**
  * Filter the query by a related Chart object
  *
  * @param   Chart|PropelObjectCollection $chart The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return                 JobQuery The current query, for fluid interface
  * @throws PropelException - if the provided filter is invalid.
  */
 public function filterByChart($chart, $comparison = null)
 {
     if ($chart instanceof Chart) {
         return $this->addUsingAlias(JobPeer::CHART_ID, $chart->getId(), $comparison);
     } elseif ($chart instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(JobPeer::CHART_ID, $chart->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByChart() only accepts arguments of type Chart or PropelCollection');
     }
 }

 /**
  * Filter the query by a related User object
  *
  * @param   User|PropelObjectCollection $user The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return                 JournalEntryImageQuery The current query, for fluid interface
  * @throws PropelException - if the provided filter is invalid.
  */
 public function filterByUserRelatedByUpdatedBy($user, $comparison = null)
 {
     if ($user instanceof User) {
         return $this->addUsingAlias(JournalEntryImagePeer::UPDATED_BY, $user->getId(), $comparison);
     } elseif ($user instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(JournalEntryImagePeer::UPDATED_BY, $user->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByUserRelatedByUpdatedBy() only accepts arguments of type User or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Plugin object
  *
  * @param   Plugin|PropelObjectCollection $plugin The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return                 PluginDataQuery The current query, for fluid interface
  * @throws PropelException - if the provided filter is invalid.
  */
 public function filterByPlugin($plugin, $comparison = null)
 {
     if ($plugin instanceof Plugin) {
         return $this->addUsingAlias(PluginDataPeer::PLUGIN_ID, $plugin->getId(), $comparison);
     } elseif ($plugin instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(PluginDataPeer::PLUGIN_ID, $plugin->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByPlugin() only accepts arguments of type Plugin or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Expediente object
  *
  * @param   Expediente|PropelObjectCollection $expediente The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return                 ExpedienteanticipoQuery The current query, for fluid interface
  * @throws PropelException - if the provided filter is invalid.
  */
 public function filterByExpediente($expediente, $comparison = null)
 {
     if ($expediente instanceof Expediente) {
         return $this->addUsingAlias(ExpedienteanticipoPeer::IDEXPEDIENTE, $expediente->getIdexpediente(), $comparison);
     } elseif ($expediente instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(ExpedienteanticipoPeer::IDEXPEDIENTE, $expediente->toKeyValue('PrimaryKey', 'Idexpediente'), $comparison);
     } else {
         throw new PropelException('filterByExpediente() only accepts arguments of type Expediente or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Categoriagasto object
  *
  * @param   Categoriagasto|PropelObjectCollection $categoriagasto The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return                 GastofacturacionQuery The current query, for fluid interface
  * @throws PropelException - if the provided filter is invalid.
  */
 public function filterByCategoriagasto($categoriagasto, $comparison = null)
 {
     if ($categoriagasto instanceof Categoriagasto) {
         return $this->addUsingAlias(GastofacturacionPeer::IDCATEGORIAGASTO, $categoriagasto->getIdcategoriagasto(), $comparison);
     } elseif ($categoriagasto instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(GastofacturacionPeer::IDCATEGORIAGASTO, $categoriagasto->toKeyValue('PrimaryKey', 'Idcategoriagasto'), $comparison);
     } else {
         throw new PropelException('filterByCategoriagasto() only accepts arguments of type Categoriagasto or PropelCollection');
     }
 }

 /**
  * Filter the query by a related sfGuardUser object
  *
  * @param   sfGuardUser|PropelObjectCollection $sfGuardUser The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return   sfGuardRememberKeyQuery The current query, for fluid interface
  * @throws   PropelException - if the provided filter is invalid.
  */
 public function filterBysfGuardUser($sfGuardUser, $comparison = null)
 {
     if ($sfGuardUser instanceof sfGuardUser) {
         return $this->addUsingAlias(sfGuardRememberKeyPeer::USER_ID, $sfGuardUser->getId(), $comparison);
     } elseif ($sfGuardUser instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(sfGuardRememberKeyPeer::USER_ID, $sfGuardUser->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterBysfGuardUser() only accepts arguments of type sfGuardUser or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Agenda object
  *
  * @param   Agenda|PropelObjectCollection $agenda The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return   ProcedimientregrogramadoQuery The current query, for fluid interface
  * @throws   PropelException - if the provided filter is invalid.
  */
 public function filterByAgenda($agenda, $comparison = null)
 {
     if ($agenda instanceof Agenda) {
         return $this->addUsingAlias(ProcedimientregrogramadoPeer::AGENDA_ID, $agenda->getId(), $comparison);
     } elseif ($agenda instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(ProcedimientregrogramadoPeer::AGENDA_ID, $agenda->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByAgenda() only accepts arguments of type Agenda or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Transaction object
  *
  * @param   Transaction|PropelObjectCollection $transaction The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return                 TransactionClockingQuery The current query, for fluid interface
  * @throws PropelException - if the provided filter is invalid.
  */
 public function filterByTransaction($transaction, $comparison = null)
 {
     if ($transaction instanceof Transaction) {
         return $this->addUsingAlias(TransactionClockingPeer::TRANSACTION_ID, $transaction->getId(), $comparison);
     } elseif ($transaction instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(TransactionClockingPeer::TRANSACTION_ID, $transaction->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByTransaction() only accepts arguments of type Transaction or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Localidad object
  *
  * @param   Localidad|PropelObjectCollection $localidad The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return   AfiliadoQuery The current query, for fluid interface
  * @throws   PropelException - if the provided filter is invalid.
  */
 public function filterByLocalidad($localidad, $comparison = null)
 {
     if ($localidad instanceof Localidad) {
         return $this->addUsingAlias(AfiliadoPeer::LOCALIDAD_ID, $localidad->getId(), $comparison);
     } elseif ($localidad instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(AfiliadoPeer::LOCALIDAD_ID, $localidad->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByLocalidad() only accepts arguments of type Localidad or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Rol object
  *
  * @param   Rol|PropelObjectCollection $rol The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return                 EmpleadoQuery The current query, for fluid interface
  * @throws PropelException - if the provided filter is invalid.
  */
 public function filterByRol($rol, $comparison = null)
 {
     if ($rol instanceof Rol) {
         return $this->addUsingAlias(EmpleadoPeer::IDROL, $rol->getIdrol(), $comparison);
     } elseif ($rol instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(EmpleadoPeer::IDROL, $rol->toKeyValue('PrimaryKey', 'Idrol'), $comparison);
     } else {
         throw new PropelException('filterByRol() only accepts arguments of type Rol or PropelCollection');
     }
 }

 /**
  * Filter the query by a related State object
  *
  * @param   State|PropelObjectCollection $state The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return   ContactQuery The current query, for fluid interface
  * @throws   PropelException - if the provided filter is invalid.
  */
 public function filterByState($state, $comparison = null)
 {
     if ($state instanceof State) {
         return $this->addUsingAlias(ContactPeer::STATE_ID, $state->getId(), $comparison);
     } elseif ($state instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(ContactPeer::STATE_ID, $state->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByState() only accepts arguments of type State or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Jugador object
  *
  * @param   Jugador|PropelObjectCollection $jugador The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return   JugadorMesaQuery The current query, for fluid interface
  * @throws   PropelException - if the provided filter is invalid.
  */
 public function filterByJugador($jugador, $comparison = null)
 {
     if ($jugador instanceof Jugador) {
         return $this->addUsingAlias(JugadorMesaPeer::JUGADOR_ID, $jugador->getId(), $comparison);
     } elseif ($jugador instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(JugadorMesaPeer::JUGADOR_ID, $jugador->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByJugador() only accepts arguments of type Jugador or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Perfil object
  *
  * @param   Perfil|PropelObjectCollection $perfil The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return   UsuarioQuery The current query, for fluid interface
  * @throws   PropelException - if the provided filter is invalid.
  */
 public function filterByPerfil($perfil, $comparison = null)
 {
     if ($perfil instanceof Perfil) {
         return $this->addUsingAlias(UsuarioPeer::PERFIL_ID, $perfil->getId(), $comparison);
     } elseif ($perfil instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(UsuarioPeer::PERFIL_ID, $perfil->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByPerfil() only accepts arguments of type Perfil or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Conceptocajachica object
  *
  * @param   Conceptocajachica|PropelObjectCollection $conceptocajachica The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return                 CajachicaQuery The current query, for fluid interface
  * @throws PropelException - if the provided filter is invalid.
  */
 public function filterByConceptocajachica($conceptocajachica, $comparison = null)
 {
     if ($conceptocajachica instanceof Conceptocajachica) {
         return $this->addUsingAlias(CajachicaPeer::IDCONCEPTOCAJACHICA, $conceptocajachica->getIdconceptocajachica(), $comparison);
     } elseif ($conceptocajachica instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(CajachicaPeer::IDCONCEPTOCAJACHICA, $conceptocajachica->toKeyValue('PrimaryKey', 'Idconceptocajachica'), $comparison);
     } else {
         throw new PropelException('filterByConceptocajachica() only accepts arguments of type Conceptocajachica or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Organization object
  *
  * @param   Organization|PropelObjectCollection $organization The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return                 PluginOrganizationQuery The current query, for fluid interface
  * @throws PropelException - if the provided filter is invalid.
  */
 public function filterByOrganization($organization, $comparison = null)
 {
     if ($organization instanceof Organization) {
         return $this->addUsingAlias(PluginOrganizationPeer::ORGANIZATION_ID, $organization->getId(), $comparison);
     } elseif ($organization instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(PluginOrganizationPeer::ORGANIZATION_ID, $organization->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByOrganization() only accepts arguments of type Organization or PropelCollection');
     }
 }