PHP PropelObjectCollection::getId方法代码示例

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

 /**
  * Filter the query by a related Account object
  *
  * @param   Account|PropelObjectCollection $account The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return                 PropertyQuery The current query, for fluid interface
  * @throws PropelException - if the provided filter is invalid.
  */
 public function filterByAccount($account, $comparison = null)
 {
     if ($account instanceof Account) {
         return $this->addUsingAlias(PropertyPeer::ACCOUNT_ID, $account->getId(), $comparison);
     } elseif ($account instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(PropertyPeer::ACCOUNT_ID, $account->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByAccount() only accepts arguments of type Account 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 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 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 Currency object
  *
  * @param   Currency|PropelObjectCollection $currency The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return   CountryQuery The current query, for fluid interface
  * @throws   PropelException - if the provided filter is invalid.
  */
 public function filterByCurrency($currency, $comparison = null)
 {
     if ($currency instanceof Currency) {
         return $this->addUsingAlias(CountryPeer::DEFAULT_CURRENCY_ID, $currency->getId(), $comparison);
     } elseif ($currency instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(CountryPeer::DEFAULT_CURRENCY_ID, $currency->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByCurrency() only accepts arguments of type Currency or PropelCollection');
     }
 }

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

 /**
  * Filter the query by a related sfGuardPermission object
  *
  * @param   sfGuardPermission|PropelObjectCollection $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
  * @throws   PropelException - if the provided filter is invalid.
  */
 public function filterBysfGuardPermission($sfGuardPermission, $comparison = null)
 {
     if ($sfGuardPermission instanceof sfGuardPermission) {
         return $this->addUsingAlias(sfGuardUserPermissionPeer::PERMISSION_ID, $sfGuardPermission->getId(), $comparison);
     } elseif ($sfGuardPermission instanceof PropelObjectCollection) {
         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 TipoPago object
  *
  * @param   TipoPago|PropelObjectCollection $tipoPago The related object(s) to use as filter
  * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return   TransaccionQuery The current query, for fluid interface
  * @throws   PropelException - if the provided filter is invalid.
  */
 public function filterByTipoPago($tipoPago, $comparison = null)
 {
     if ($tipoPago instanceof TipoPago) {
         return $this->addUsingAlias(TransaccionPeer::TIPO_PAGO_ID, $tipoPago->getId(), $comparison);
     } elseif ($tipoPago instanceof PropelObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(TransaccionPeer::TIPO_PAGO_ID, $tipoPago->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByTipoPago() only accepts arguments of type TipoPago or PropelCollection');
     }
 }

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

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

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

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