PHP PropelCollection::toKeyValue方法代码示例

 /**
  * Filter the query by a related MeshingSchema object
  *
  * @param     MeshingSchema|PropelCollection $meshingSchema The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return    MeshingSchemaTableQuery The current query, for fluid interface
  */
 public function filterByMeshingSchema($meshingSchema, $comparison = null)
 {
     if ($meshingSchema instanceof MeshingSchema) {
         return $this->addUsingAlias(MeshingSchemaTablePeer::SCHEMA_ID, $meshingSchema->getId(), $comparison);
     } elseif ($meshingSchema instanceof PropelCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(MeshingSchemaTablePeer::SCHEMA_ID, $meshingSchema->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByMeshingSchema() only accepts arguments of type MeshingSchema or PropelCollection');
     }
 }

 /**
  * Filter the query by a related MeshingTrustType object
  *
  * @param     MeshingTrustType|PropelCollection $meshingTrustType The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return    MeshingTrustLocalQuery The current query, for fluid interface
  */
 public function filterByMeshingTrustType($meshingTrustType, $comparison = null)
 {
     if ($meshingTrustType instanceof MeshingTrustType) {
         return $this->addUsingAlias(MeshingTrustLocalPeer::TYPE, $meshingTrustType->getId(), $comparison);
     } elseif ($meshingTrustType instanceof PropelCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(MeshingTrustLocalPeer::TYPE, $meshingTrustType->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByMeshingTrustType() only accepts arguments of type MeshingTrustType or PropelCollection');
     }
 }

	/**
	 * Filter the query by a related CahierTexteSequence object
	 *
	 * @param     CahierTexteSequence|PropelCollection $cahierTexteSequence The related object(s) to use as filter
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CahierTexteCompteRenduQuery The current query, for fluid interface
	 */
	public function filterByCahierTexteSequence($cahierTexteSequence, $comparison = null)
	{
		if ($cahierTexteSequence instanceof CahierTexteSequence) {
			return $this
				->addUsingAlias(CahierTexteCompteRenduPeer::ID_SEQUENCE, $cahierTexteSequence->getId(), $comparison);
		} elseif ($cahierTexteSequence instanceof PropelCollection) {
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
			return $this
				->addUsingAlias(CahierTexteCompteRenduPeer::ID_SEQUENCE, $cahierTexteSequence->toKeyValue('PrimaryKey', 'Id'), $comparison);
		} else {
			throw new PropelException('filterByCahierTexteSequence() only accepts arguments of type CahierTexteSequence or PropelCollection');
		}
	}

 /**
  * Filter the query by a related Usuario object
  *
  * @param     Usuario|PropelCollection $usuario The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return    Libro_colaboradorQuery The current query, for fluid interface
  */
 public function filterByUsuario($usuario, $comparison = null)
 {
     if ($usuario instanceof Usuario) {
         return $this->addUsingAlias(Libro_colaboradorPeer::IDUSUARIO, $usuario->getId(), $comparison);
     } elseif ($usuario instanceof PropelCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(Libro_colaboradorPeer::IDUSUARIO, $usuario->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByUsuario() only accepts arguments of type Usuario or PropelCollection');
     }
 }

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

 /**
  * Filter the query by a related Pelicula object
  *
  * @param     Pelicula|PropelCollection $pelicula The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return    SocioAlquilerQuery The current query, for fluid interface
  */
 public function filterByPelicula($pelicula, $comparison = null)
 {
     if ($pelicula instanceof Pelicula) {
         return $this->addUsingAlias(SocioAlquilerPeer::PELICULA_ID, $pelicula->getId(), $comparison);
     } elseif ($pelicula instanceof PropelCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(SocioAlquilerPeer::PELICULA_ID, $pelicula->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByPelicula() only accepts arguments of type Pelicula or PropelCollection');
     }
 }

	/**
	 * Filter the query by a related AbsenceEleveTraitement object
	 *
	 * @param     AbsenceEleveTraitement|PropelCollection $absenceEleveTraitement The related object(s) to use as filter
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    JTraitementSaisieEleveQuery The current query, for fluid interface
	 */
	public function filterByAbsenceEleveTraitement($absenceEleveTraitement, $comparison = null)
	{
		if ($absenceEleveTraitement instanceof AbsenceEleveTraitement) {
			return $this
				->addUsingAlias(JTraitementSaisieElevePeer::A_TRAITEMENT_ID, $absenceEleveTraitement->getId(), $comparison);
		} elseif ($absenceEleveTraitement instanceof PropelCollection) {
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
			return $this
				->addUsingAlias(JTraitementSaisieElevePeer::A_TRAITEMENT_ID, $absenceEleveTraitement->toKeyValue('PrimaryKey', 'Id'), $comparison);
		} else {
			throw new PropelException('filterByAbsenceEleveTraitement() only accepts arguments of type AbsenceEleveTraitement or PropelCollection');
		}
	}

 /**
  * Filter the query by a related Dept object
  *
  * @param     Dept|PropelCollection $dept The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return    DeptMetadataQuery The current query, for fluid interface
  */
 public function filterByDept($dept, $comparison = null)
 {
     if ($dept instanceof Dept) {
         return $this->addUsingAlias(DeptMetadataPeer::DEPT_B_ID, $dept->getBId(), $comparison);
     } elseif ($dept instanceof PropelCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(DeptMetadataPeer::DEPT_B_ID, $dept->toKeyValue('PrimaryKey', 'BId'), $comparison);
     } else {
         throw new PropelException('filterByDept() only accepts arguments of type Dept or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Socio object
  *
  * @param     Socio|PropelCollection $socio The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return    AlquilerQuery The current query, for fluid interface
  */
 public function filterBySocio($socio, $comparison = null)
 {
     if ($socio instanceof Socio) {
         return $this->addUsingAlias(AlquilerPeer::SOCIO_ID, $socio->getId(), $comparison);
     } elseif ($socio instanceof PropelCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(AlquilerPeer::SOCIO_ID, $socio->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterBySocio() only accepts arguments of type Socio or PropelCollection');
     }
 }

	/**
	 * Filter the query by a related CahierTexteCompteRendu object
	 *
	 * @param     CahierTexteCompteRendu|PropelCollection $cahierTexteCompteRendu The related object(s) to use as filter
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CahierTexteCompteRenduFichierJointQuery The current query, for fluid interface
	 */
	public function filterByCahierTexteCompteRendu($cahierTexteCompteRendu, $comparison = null)
	{
		if ($cahierTexteCompteRendu instanceof CahierTexteCompteRendu) {
			return $this
				->addUsingAlias(CahierTexteCompteRenduFichierJointPeer::ID_CT, $cahierTexteCompteRendu->getIdCt(), $comparison);
		} elseif ($cahierTexteCompteRendu instanceof PropelCollection) {
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
			return $this
				->addUsingAlias(CahierTexteCompteRenduFichierJointPeer::ID_CT, $cahierTexteCompteRendu->toKeyValue('PrimaryKey', 'IdCt'), $comparison);
		} else {
			throw new PropelException('filterByCahierTexteCompteRendu() only accepts arguments of type CahierTexteCompteRendu or PropelCollection');
		}
	}

 /**
  * Filter the query by a related Producto object
  *
  * @param     Producto|PropelCollection $producto The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return    VentaQuery The current query, for fluid interface
  */
 public function filterByProducto($producto, $comparison = null)
 {
     if ($producto instanceof Producto) {
         return $this->addUsingAlias(VentaPeer::IDPRODUCTO, $producto->getIdproducto(), $comparison);
     } elseif ($producto instanceof PropelCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(VentaPeer::IDPRODUCTO, $producto->toKeyValue('PrimaryKey', 'Idproducto'), $comparison);
     } else {
         throw new PropelException('filterByProducto() only accepts arguments of type Producto or PropelCollection');
     }
 }

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

	/**
	 * Filter the query by a related Classe object
	 *
	 * @param     Classe|PropelCollection $classe The related object(s) to use as filter
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    PeriodeNoteQuery The current query, for fluid interface
	 */
	public function filterByClasse($classe, $comparison = null)
	{
		if ($classe instanceof Classe) {
			return $this
				->addUsingAlias(PeriodeNotePeer::ID_CLASSE, $classe->getId(), $comparison);
		} elseif ($classe instanceof PropelCollection) {
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
			return $this
				->addUsingAlias(PeriodeNotePeer::ID_CLASSE, $classe->toKeyValue('PrimaryKey', 'Id'), $comparison);
		} else {
			throw new PropelException('filterByClasse() only accepts arguments of type Classe or PropelCollection');
		}
	}

	/**
	 * Filter the query by a related Eleve object
	 *
	 * @param     Eleve|PropelCollection $eleve The related object(s) to use as filter
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    JAidElevesQuery The current query, for fluid interface
	 */
	public function filterByEleve($eleve, $comparison = null)
	{
		if ($eleve instanceof Eleve) {
			return $this
				->addUsingAlias(JAidElevesPeer::LOGIN, $eleve->getLogin(), $comparison);
		} elseif ($eleve instanceof PropelCollection) {
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
			return $this
				->addUsingAlias(JAidElevesPeer::LOGIN, $eleve->toKeyValue('PrimaryKey', 'Login'), $comparison);
		} else {
			throw new PropelException('filterByEleve() only accepts arguments of type Eleve or PropelCollection');
		}
	}

 /**
  * Filter the query by a related Tipo_notificacion object
  *
  * @param     Tipo_notificacion|PropelCollection $tipo_notificacion The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return    NotificacionQuery The current query, for fluid interface
  */
 public function filterByTipo_notificacion($tipo_notificacion, $comparison = null)
 {
     if ($tipo_notificacion instanceof Tipo_notificacion) {
         return $this->addUsingAlias(NotificacionPeer::ID_TIPO_NOTIFICACION, $tipo_notificacion->getId(), $comparison);
     } elseif ($tipo_notificacion instanceof PropelCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(NotificacionPeer::ID_TIPO_NOTIFICACION, $tipo_notificacion->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByTipo_notificacion() only accepts arguments of type Tipo_notificacion or PropelCollection');
     }
 }