PHP ObjectCollection::getId方法代码示例

 /**
  * Filter the query by a related \Menu\Model\MenuI18n object
  *
  * @param \Menu\Model\MenuI18n|ObjectCollection $menuI18n The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildMenuI18nVersionQuery The current query, for fluid interface
  */
 public function filterByMenuI18n($menuI18n, $comparison = null)
 {
     if ($menuI18n instanceof \Menu\Model\MenuI18n) {
         return $this->addUsingAlias(MenuI18nVersionTableMap::ID, $menuI18n->getId(), $comparison);
     } elseif ($menuI18n instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(MenuI18nVersionTableMap::ID, $menuI18n->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByMenuI18n() only accepts arguments of type \\Menu\\Model\\MenuI18n or Collection');
     }
 }

 /**
  * Filter the query by a related \Tekstove\ApiBundle\Model\Acl\PermissionGroup object
  *
  * @param \Tekstove\ApiBundle\Model\Acl\PermissionGroup|ObjectCollection $permissionGroup The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @throws \Propel\Runtime\Exception\PropelException
  *
  * @return ChildPermissionGroupUserQuery The current query, for fluid interface
  */
 public function filterByPermissionGroup($permissionGroup, $comparison = null)
 {
     if ($permissionGroup instanceof \Tekstove\ApiBundle\Model\Acl\PermissionGroup) {
         return $this->addUsingAlias(PermissionGroupUserTableMap::COL_GROUP_ID, $permissionGroup->getId(), $comparison);
     } elseif ($permissionGroup instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(PermissionGroupUserTableMap::COL_GROUP_ID, $permissionGroup->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByPermissionGroup() only accepts arguments of type \\Tekstove\\ApiBundle\\Model\\Acl\\PermissionGroup or Collection');
     }
 }

 /**
  * Filter the query by a related \App\Models\TranslationApplication object
  *
  * @param \App\Models\TranslationApplication|ObjectCollection $translationApplication The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @throws \Propel\Runtime\Exception\PropelException
  *
  * @return ChildTranslationCatalogQuery The current query, for fluid interface
  */
 public function filterByTranslationApplication($translationApplication, $comparison = null)
 {
     if ($translationApplication instanceof \App\Models\TranslationApplication) {
         return $this->addUsingAlias(TranslationCatalogTableMap::COL_APPLICATION_ID, $translationApplication->getId(), $comparison);
     } elseif ($translationApplication instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(TranslationCatalogTableMap::COL_APPLICATION_ID, $translationApplication->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByTranslationApplication() only accepts arguments of type \\App\\Models\\TranslationApplication or Collection');
     }
 }

 /**
  * Filter the query by a related \Thelia\Model\Product object
  *
  * @param \Thelia\Model\Product|ObjectCollection $product The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildProductVersionQuery The current query, for fluid interface
  */
 public function filterByProduct($product, $comparison = null)
 {
     if ($product instanceof \Thelia\Model\Product) {
         return $this->addUsingAlias(ProductVersionTableMap::ID, $product->getId(), $comparison);
     } elseif ($product instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(ProductVersionTableMap::ID, $product->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByProduct() only accepts arguments of type \\Thelia\\Model\\Product or Collection');
     }
 }

 /**
  * Filter the query by a related \Diaporamas\Model\Diaporama object
  *
  * @param \Diaporamas\Model\Diaporama|ObjectCollection $diaporama The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildDiaporamaVersionQuery The current query, for fluid interface
  */
 public function filterByDiaporama($diaporama, $comparison = null)
 {
     if ($diaporama instanceof \Diaporamas\Model\Diaporama) {
         return $this->addUsingAlias(DiaporamaVersionTableMap::ID, $diaporama->getId(), $comparison);
     } elseif ($diaporama instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(DiaporamaVersionTableMap::ID, $diaporama->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByDiaporama() only accepts arguments of type \\Diaporamas\\Model\\Diaporama or Collection');
     }
 }

 /**
  * Filter the query by a related \Thelia\Model\Order object
  *
  * @param \Thelia\Model\Order|ObjectCollection $order The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildOrderCouponQuery The current query, for fluid interface
  */
 public function filterByOrder($order, $comparison = null)
 {
     if ($order instanceof \Thelia\Model\Order) {
         return $this->addUsingAlias(OrderCouponTableMap::ORDER_ID, $order->getId(), $comparison);
     } elseif ($order instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(OrderCouponTableMap::ORDER_ID, $order->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByOrder() only accepts arguments of type \\Thelia\\Model\\Order or Collection');
     }
 }

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

 /**
  * Filter the query by a related \Users object
  *
  * @param \Users|ObjectCollection $users The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @throws \Propel\Runtime\Exception\PropelException
  *
  * @return ChildBooksQuery The current query, for fluid interface
  */
 public function filterByuserSysRef($users, $comparison = null)
 {
     if ($users instanceof \Users) {
         return $this->addUsingAlias(BooksTableMap::COL___USER__, $users->getId(), $comparison);
     } elseif ($users instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(BooksTableMap::COL___USER__, $users->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByuserSysRef() only accepts arguments of type \\Users or Collection');
     }
 }

 /**
  * Filter the query by a related \Templatenames object
  *
  * @param \Templatenames|ObjectCollection $templatenames The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @throws \Propel\Runtime\Exception\PropelException
  *
  * @return ChildContributionsQuery The current query, for fluid interface
  */
 public function filterByTemplatenames($templatenames, $comparison = null)
 {
     if ($templatenames instanceof \Templatenames) {
         return $this->addUsingAlias(ContributionsTableMap::COL__FORTEMPLATE, $templatenames->getId(), $comparison);
     } elseif ($templatenames instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(ContributionsTableMap::COL__FORTEMPLATE, $templatenames->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByTemplatenames() only accepts arguments of type \\Templatenames or Collection');
     }
 }

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

 /**
  * Filter the query by a related \gossi\trixionary\model\Reference object
  *
  * @param \gossi\trixionary\model\Reference|ObjectCollection $reference The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @throws \Propel\Runtime\Exception\PropelException
  *
  * @return ChildVideoQuery The current query, for fluid interface
  */
 public function filterByReference($reference, $comparison = null)
 {
     if ($reference instanceof \gossi\trixionary\model\Reference) {
         return $this->addUsingAlias(VideoTableMap::COL_REFERENCE_ID, $reference->getId(), $comparison);
     } elseif ($reference instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(VideoTableMap::COL_REFERENCE_ID, $reference->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByReference() only accepts arguments of type \\gossi\\trixionary\\model\\Reference or Collection');
     }
 }

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

 /**
  * Filter the query by a related \Thelia\Model\AttributeAv object
  *
  * @param \Thelia\Model\AttributeAv|ObjectCollection $attributeAv The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildAttributeAvI18nQuery The current query, for fluid interface
  */
 public function filterByAttributeAv($attributeAv, $comparison = null)
 {
     if ($attributeAv instanceof \Thelia\Model\AttributeAv) {
         return $this->addUsingAlias(AttributeAvI18nTableMap::ID, $attributeAv->getId(), $comparison);
     } elseif ($attributeAv instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(AttributeAvI18nTableMap::ID, $attributeAv->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByAttributeAv() only accepts arguments of type \\Thelia\\Model\\AttributeAv or Collection');
     }
 }

 /**
  * Filter the query by a related \SoColissimo\Model\Thelia\Model\OrderAddress object
  *
  * @param \SoColissimo\Model\Thelia\Model\OrderAddress|ObjectCollection $orderAddress The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @return ChildOrderAddressSocolissimoQuery The current query, for fluid interface
  */
 public function filterByOrderAddress($orderAddress, $comparison = null)
 {
     if ($orderAddress instanceof \SoColissimo\Model\Thelia\Model\OrderAddress) {
         return $this->addUsingAlias(OrderAddressSocolissimoTableMap::ID, $orderAddress->getId(), $comparison);
     } elseif ($orderAddress instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(OrderAddressSocolissimoTableMap::ID, $orderAddress->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByOrderAddress() only accepts arguments of type \\SoColissimo\\Model\\Thelia\\Model\\OrderAddress or Collection');
     }
 }

 /**
  * Filter the query by a related \testpropel\Author object
  *
  * @param \testpropel\Author|ObjectCollection $author The related object(s) to use as filter
  * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
  *
  * @throws \Propel\Runtime\Exception\PropelException
  *
  * @return ChildBookQuery The current query, for fluid interface
  */
 public function filterByAuthor($author, $comparison = null)
 {
     if ($author instanceof \testpropel\Author) {
         return $this->addUsingAlias(BookTableMap::COL_AUTHOR_ID, $author->getId(), $comparison);
     } elseif ($author instanceof ObjectCollection) {
         if (null === $comparison) {
             $comparison = Criteria::IN;
         }
         return $this->addUsingAlias(BookTableMap::COL_AUTHOR_ID, $author->toKeyValue('PrimaryKey', 'Id'), $comparison);
     } else {
         throw new PropelException('filterByAuthor() only accepts arguments of type \\testpropel\\Author or Collection');
     }
 }