PHP PropelCollection::getId方法代码示例

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

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

 /**
  * Filter the query by a related sfGuardUser object
  *
  * @param     sfGuardUser|PropelCollection $sfGuardUser The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return    CommentQuery The current query, for fluid interface
  */
 public function filterBysfGuardUserRelatedByCheckUserId($sfGuardUser, $comparison = null)
 {
     if ($sfGuardUser instanceof sfGuardUser) {
         return $this->addUsingAlias(CommentPeer::CHECK_USER_ID, $sfGuardUser->getId(), $comparison);
     } elseif ($sfGuardUser instanceof PropelCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(CommentPeer::CHECK_USER_ID, $sfGuardUser->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterBysfGuardUserRelatedByCheckUserId() only accepts arguments of type sfGuardUser 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 AbsenceEleveLieu object
	 *
	 * @param     AbsenceEleveLieu|PropelCollection $absenceEleveLieu The related object(s) to use as filter
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    AbsenceEleveSaisieQuery The current query, for fluid interface
	 */
	public function filterByAbsenceEleveLieu($absenceEleveLieu, $comparison = null)
	{
		if ($absenceEleveLieu instanceof AbsenceEleveLieu) {
			return $this
				->addUsingAlias(AbsenceEleveSaisiePeer::ID_LIEU, $absenceEleveLieu->getId(), $comparison);
		} elseif ($absenceEleveLieu instanceof PropelCollection) {
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
			return $this
				->addUsingAlias(AbsenceEleveSaisiePeer::ID_LIEU, $absenceEleveLieu->toKeyValue('PrimaryKey', 'Id'), $comparison);
		} else {
			throw new PropelException('filterByAbsenceEleveLieu() only accepts arguments of type AbsenceEleveLieu 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 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 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 Chart object
  *
  * @param     Chart|PropelCollection $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
  */
 public function filterByChart($chart, $comparison = null)
 {
     if ($chart instanceof Chart) {
         return $this->addUsingAlias(JobPeer::CHART_ID, $chart->getId(), $comparison);
     } elseif ($chart instanceof PropelCollection) {
         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 CategorieMatiere object
	 *
	 * @param     CategorieMatiere|PropelCollection $categorieMatiere The related object(s) to use as filter
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    MatiereQuery The current query, for fluid interface
	 */
	public function filterByCategorieMatiere($categorieMatiere, $comparison = null)
	{
		if ($categorieMatiere instanceof CategorieMatiere) {
			return $this
				->addUsingAlias(MatierePeer::CATEGORIE_ID, $categorieMatiere->getId(), $comparison);
		} elseif ($categorieMatiere instanceof PropelCollection) {
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
			return $this
				->addUsingAlias(MatierePeer::CATEGORIE_ID, $categorieMatiere->toKeyValue('PrimaryKey', 'Id'), $comparison);
		} else {
			throw new PropelException('filterByCategorieMatiere() only accepts arguments of type CategorieMatiere or PropelCollection');
		}
	}

 /**
  * Filter the query by a related Libro object
  *
  * @param     Libro|PropelCollection $libro The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return    ClasificadosQuery The current query, for fluid interface
  */
 public function filterByLibro($libro, $comparison = null)
 {
     if ($libro instanceof Libro) {
         return $this->addUsingAlias(ClasificadosPeer::ID_LIBRO, $libro->getId(), $comparison);
     } elseif ($libro instanceof PropelCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(ClasificadosPeer::ID_LIBRO, $libro->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByLibro() only accepts arguments of type Libro 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    Solicitud_amistadQuery The current query, for fluid interface
  */
 public function filterByUsuarioRelatedById_usuario_solicitante($usuario, $comparison = null)
 {
     if ($usuario instanceof Usuario) {
         return $this->addUsingAlias(Solicitud_amistadPeer::ID_USUARIO_SOLICITANTE, $usuario->getId(), $comparison);
     } elseif ($usuario instanceof PropelCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(Solicitud_amistadPeer::ID_USUARIO_SOLICITANTE, $usuario->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByUsuarioRelatedById_usuario_solicitante() only accepts arguments of type Usuario or PropelCollection');
     }
 }

 /**
  * Filter the query by a related Lista object
  *
  * @param     Lista|PropelCollection $lista The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return    Lista_audiolibroQuery The current query, for fluid interface
  */
 public function filterByLista($lista, $comparison = null)
 {
     if ($lista instanceof Lista) {
         return $this->addUsingAlias(Lista_audiolibroPeer::ID_LISTA, $lista->getId(), $comparison);
     } elseif ($lista instanceof PropelCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(Lista_audiolibroPeer::ID_LISTA, $lista->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByLista() only accepts arguments of type Lista 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');
     }
 }