/** * 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'); } }
/** * Filter the query by a related AncienEtablissement object * * @param AncienEtablissement|PropelCollection $ancienEtablissement The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return JEleveAncienEtablissementQuery The current query, for fluid interface */ public function filterByAncienEtablissement($ancienEtablissement, $comparison = null) { if ($ancienEtablissement instanceof AncienEtablissement) { return $this ->addUsingAlias(JEleveAncienEtablissementPeer::ID_ETABLISSEMENT, $ancienEtablissement->getId(), $comparison); } elseif ($ancienEtablissement instanceof PropelCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this ->addUsingAlias(JEleveAncienEtablissementPeer::ID_ETABLISSEMENT, $ancienEtablissement->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByAncienEtablissement() only accepts arguments of type AncienEtablissement 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 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 FileQuery The current query, for fluid interface */ public function filterBysfGuardUser($sfGuardUser, $comparison = null) { if ($sfGuardUser instanceof sfGuardUser) { return $this->addUsingAlias(FilePeer::LAST_CHANGE_COMMIT_USER, $sfGuardUser->getId(), $comparison); } elseif ($sfGuardUser instanceof PropelCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(FilePeer::LAST_CHANGE_COMMIT_USER, $sfGuardUser->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterBysfGuardUser() only accepts arguments of type sfGuardUser or PropelCollection'); } }
/** * Filter the query by a related Ciudad object * * @param Ciudad|PropelCollection $ciudad The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return ClienteQuery The current query, for fluid interface */ public function filterByCiudadRelatedByIdCiudad($ciudad, $comparison = null) { if ($ciudad instanceof Ciudad) { return $this->addUsingAlias(ClientePeer::ID_CIUDAD, $ciudad->getIdciudad(), $comparison); } elseif ($ciudad instanceof PropelCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(ClientePeer::ID_CIUDAD, $ciudad->toKeyValue('PrimaryKey', 'Idciudad'), $comparison); } else { throw new PropelException('filterByCiudadRelatedByIdCiudad() only accepts arguments of type Ciudad 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 AbsenceAgregationDecompteQuery The current query, for fluid interface */ public function filterByEleve($eleve, $comparison = null) { if ($eleve instanceof Eleve) { return $this ->addUsingAlias(AbsenceAgregationDecomptePeer::ELEVE_ID, $eleve->getId(), $comparison); } elseif ($eleve instanceof PropelCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this ->addUsingAlias(AbsenceAgregationDecomptePeer::ELEVE_ID, $eleve->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByEleve() only accepts arguments of type Eleve or PropelCollection'); } }
/** * Filter the query by a related Genero object * * @param Genero|PropelCollection $genero The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return ProductoQuery The current query, for fluid interface */ public function filterByGenero($genero, $comparison = null) { if ($genero instanceof Genero) { return $this->addUsingAlias(ProductoPeer::IDGENERO, $genero->getIdgenero(), $comparison); } elseif ($genero instanceof PropelCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(ProductoPeer::IDGENERO, $genero->toKeyValue('PrimaryKey', 'Idgenero'), $comparison); } else { throw new PropelException('filterByGenero() only accepts arguments of type Genero or PropelCollection'); } }
/** * Filter the query by a related Privilegios object * * @param Privilegios|PropelCollection $privilegios 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 */ public function filterByPrivilegios($privilegios, $comparison = null) { if ($privilegios instanceof Privilegios) { return $this->addUsingAlias(EmpleadoPeer::IDPRIVILEGIO, $privilegios->getIdprivilegios(), $comparison); } elseif ($privilegios instanceof PropelCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(EmpleadoPeer::IDPRIVILEGIO, $privilegios->toKeyValue('PrimaryKey', 'Idprivilegios'), $comparison); } else { throw new PropelException('filterByPrivilegios() only accepts arguments of type Privilegios or PropelCollection'); } }
/** * Filter the query by a related Adresse object * * @param Adresse|PropelCollection $adresse The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return AbsenceEleveNotificationQuery The current query, for fluid interface */ public function filterByAdresse($adresse, $comparison = null) { if ($adresse instanceof Adresse) { return $this ->addUsingAlias(AbsenceEleveNotificationPeer::ADR_ID, $adresse->getId(), $comparison); } elseif ($adresse instanceof PropelCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this ->addUsingAlias(AbsenceEleveNotificationPeer::ADR_ID, $adresse->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByAdresse() only accepts arguments of type Adresse or PropelCollection'); } }
/** * Filter the query by a related sfGuardPermission object * * @param sfGuardPermission|PropelCollection $sfGuardPermission The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return sfGuardUserPermissionQuery The current query, for fluid interface */ public function filterBysfGuardPermission($sfGuardPermission, $comparison = null) { if ($sfGuardPermission instanceof sfGuardPermission) { return $this->addUsingAlias(sfGuardUserPermissionPeer::PERMISSION_ID, $sfGuardPermission->getId(), $comparison); } elseif ($sfGuardPermission instanceof PropelCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(sfGuardUserPermissionPeer::PERMISSION_ID, $sfGuardPermission->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterBysfGuardPermission() only accepts arguments of type sfGuardPermission or PropelCollection'); } }
/** * Filter the query by a related ResponsableEleve object * * @param ResponsableEleve|PropelCollection $responsableEleve 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 filterByResponsableEleve($responsableEleve, $comparison = null) { if ($responsableEleve instanceof ResponsableEleve) { return $this ->addUsingAlias(JNotificationResponsableElevePeer::PERS_ID, $responsableEleve->getResponsableEleveId(), $comparison); } elseif ($responsableEleve instanceof PropelCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this ->addUsingAlias(JNotificationResponsableElevePeer::PERS_ID, $responsableEleve->toKeyValue('PrimaryKey', 'ResponsableEleveId'), $comparison); } else { throw new PropelException('filterByResponsableEleve() only accepts arguments of type ResponsableEleve or PropelCollection'); } }
/** * Filter the query by a related Groupe object * * @param Groupe|PropelCollection $groupe The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return JEleveGroupeQuery The current query, for fluid interface */ public function filterByGroupe($groupe, $comparison = null) { if ($groupe instanceof Groupe) { return $this ->addUsingAlias(JEleveGroupePeer::ID_GROUPE, $groupe->getId(), $comparison); } elseif ($groupe instanceof PropelCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this ->addUsingAlias(JEleveGroupePeer::ID_GROUPE, $groupe->toKeyValue('PrimaryKey', 'Id'), $comparison); } else { throw new PropelException('filterByGroupe() only accepts arguments of type Groupe 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 Course object * * @param Course|PropelCollection $course The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return CourseMetadataQuery The current query, for fluid interface */ public function filterByCourse($course, $comparison = null) { if ($course instanceof Course) { return $this->addUsingAlias(CourseMetadataPeer::COURSE_B_ID, $course->getBId(), $comparison); } elseif ($course instanceof PropelCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this->addUsingAlias(CourseMetadataPeer::COURSE_B_ID, $course->toKeyValue('PrimaryKey', 'BId'), $comparison); } else { throw new PropelException('filterByCourse() only accepts arguments of type Course or PropelCollection'); } }
/** * Filter the query by a related UtilisateurProfessionnel object * * @param UtilisateurProfessionnel|PropelCollection $utilisateurProfessionnel The related object(s) to use as filter * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL * * @return JProfesseursMatieresQuery The current query, for fluid interface */ public function filterByProfesseur($utilisateurProfessionnel, $comparison = null) { if ($utilisateurProfessionnel instanceof UtilisateurProfessionnel) { return $this ->addUsingAlias(JProfesseursMatieresPeer::ID_PROFESSEUR, $utilisateurProfessionnel->getLogin(), $comparison); } elseif ($utilisateurProfessionnel instanceof PropelCollection) { if (null === $comparison) { $comparison = Criteria::IN; } return $this ->addUsingAlias(JProfesseursMatieresPeer::ID_PROFESSEUR, $utilisateurProfessionnel->toKeyValue('PrimaryKey', 'Login'), $comparison); } else { throw new PropelException('filterByProfesseur() only accepts arguments of type UtilisateurProfessionnel 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'); } }