Gets next sibling for the given node if it exists

@param      ConnectionInterface $con Connection to use.
@return     ChildCategory|null         Propel object if exists else null
340160
public function getNextSibling(ConnectionInterface $con = null)
    {
        return ChildCategoryQuery::create()
            ->filterByTreeLeft($this->getRightValue() + 1)
            ->findOne($con);
    }
669228
public function getSkillRelatedByDependencyId(ConnectionInterface $con = null)
    {
        if ($this->aSkillRelatedByDependencyId === null && ($this->dependency_id !== null)) {
            $this->aSkillRelatedByDependencyId = ChildSkillQuery::create()->findPk($this->dependency_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aSkillRelatedByDependencyId->addChildren($this);
             */
        }

        return $this->aSkillRelatedByDependencyId;
    }
1343188
public function getPersonTeamLink(ConnectionInterface $con = null)
    {
        if ($this->aPersonTeamLink === null && ($this->id !== null)) {
            $this->aPersonTeamLink = ChildPersonTeamLinkQuery::create()->findPk($this->id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aPersonTeamLink->addPersonTeamLinkVersions($this);
             */
        }

        return $this->aPersonTeamLink;
    }
1275838
public function getFeatureFeatureType(ConnectionInterface $con = null)
    {
        if ($this->aFeatureFeatureType === null && ($this->feature_feature_type_id !== null)) {
            $this->aFeatureFeatureType = ChildFeatureFeatureTypeQuery::create()->findPk($this->feature_feature_type_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aFeatureFeatureType->addFeatureTypeAvMetas($this);
             */
        }

        return $this->aFeatureFeatureType;
    }
1055165
public function findRoot(ConnectionInterface $con = null)
    {
        return $this
            ->addUsingAlias(ChildCategory::LEFT_COL, 1, Criteria::EQUAL)
            ->findOne($con);
    }
314462
public function getIndexEngineIndex(ConnectionInterface $con = null)
    {
        if ($this->aIndexEngineIndex === null && ($this->id !== null)) {
            $this->aIndexEngineIndex = ChildIndexEngineIndexQuery::create()->findPk($this->id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aIndexEngineIndex->addIndexEngineIndexVersions($this);
             */
        }

        return $this->aIndexEngineIndex;
    }
469365
public function exists(ConnectionInterface $con = null)
    {
        if (null === $con) {
            $con = Propel::getServiceContainer()->getReadConnection($this->getDbName());
        }

        $this->basePreSelect($con);
        $criteria = $this->isKeepQuery() ? clone $this : $this;
        $criteria->setDbName($this->getDbName()); // Set the correct dbName
        $criteria->clearOrderByColumns(); // ORDER BY will do nothing but slow down the query
        $criteria->clearSelectColumns(); // We are not retrieving data
        $criteria->addSelectColumn('1');
        $criteria->limit(1);

        // We need to set the primary table name, since in the case that there are no WHERE columns
        // it will be impossible for the createSelectSql() method to determine which
        // tables go into the FROM clause.
        $criteria->setPrimaryTableName(constant($this->modelTableMapName . '::TABLE_NAME'));

        $dataFetcher = $criteria->doSelect($con);
        $exists = (boolean) $dataFetcher->fetchColumn(0);
        $dataFetcher->close();

        return $exists;
    }
217873
public function getCustomer(ConnectionInterface $con = null)
    {
        if ($this->aCustomer === null && ($this->customer_id !== null)) {
            $this->aCustomer = CustomerQuery::create()->findPk($this->customer_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aCustomer->addCustomerCustomerGroups($this);
             */
        }

        return $this->aCustomer;
    }
963954
public function getSport(ConnectionInterface $con = null)
    {
        if ($this->aSport === null && ($this->sport_id !== null)) {
            $this->aSport = ChildSportQuery::create()->findPk($this->sport_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aSport->addObjects($this);
             */
        }

        return $this->aSport;
    }
1198140
public function getStructureNodeRelatedByStructureNodeId(ConnectionInterface $con = null)
    {
        if ($this->aStructureNodeRelatedByStructureNodeId === null && ($this->structure_node_id !== null)) {
            $this->aStructureNodeRelatedByStructureNodeId = ChildStructureNodeQuery::create()->findPk($this->structure_node_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aStructureNodeRelatedByStructureNodeId->addStructureNodeParentsRelatedByStructureNodeId($this);
             */
        }

        return $this->aStructureNodeRelatedByStructureNodeId;
    }
1344277
public function getPersonFunctionLink(ConnectionInterface $con = null)
    {
        if ($this->aPersonFunctionLink === null && ($this->id !== null)) {
            $this->aPersonFunctionLink = ChildPersonFunctionLinkQuery::create()->findPk($this->id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aPersonFunctionLink->addPersonFunctionLinkVersions($this);
             */
        }

        return $this->aPersonFunctionLink;
    }
17434
public function getFolder(ConnectionInterface $con = null)
    {
        if ($this->aFolder === null && ($this->folder_id !== null)) {
            $this->aFolder = FolderQuery::create()->findPk($this->folder_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aFolder->addDealerFolders($this);
             */
        }

        return $this->aFolder;
    }
233610
public function getAncestor(ConnectionInterface $con = null)
    {
        if ($this->aAncestor === null && ($this->ancestor_id !== null)) {
            $this->aAncestor = ChildSkillQuery::create()->findPk($this->ancestor_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aAncestor->addLineagesRelatedByAncestorId($this);
             */
        }

        return $this->aAncestor;
    }
701930
public function countChildren(Criteria $criteria = null, ConnectionInterface $con = null)
    {
        if (null === $this->collNestedSetChildren || null !== $criteria) {
            if ($this->isLeaf() || ($this->isNew() && null === $this->collNestedSetChildren)) {
                return 0;
            } else {
                return ChildCategoryQuery::create(null, $criteria)
                    ->childrenOf($this)
                    ->count($con);
            }
        } else {
            return count($this->collNestedSetChildren);
        }
    }
1045156
public function hasNextSibling(ConnectionInterface $con = null)
    {
        if (!ChildCategoryQuery::isValid($this)) {
            return false;
        }

        return ChildCategoryQuery::create()
            ->filterByTreeLeft($this->getRightValue() + 1)
            ->exists($con);
    }
456085
public function getSkillRelatedByPartId(ConnectionInterface $con = null)
    {
        if ($this->aSkillRelatedByPartId === null && ($this->part_id !== null)) {
            $this->aSkillRelatedByPartId = ChildSkillQuery::create()->findPk($this->part_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aSkillRelatedByPartId->addParts($this);
             */
        }

        return $this->aSkillRelatedByPartId;
    }
1183467
public function getProduct(ConnectionInterface $con = null)
    {
        if ($this->aProduct === null && ($this->product_id !== null)) {
            $this->aProduct = ProductQuery::create()->findPk($this->product_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aProduct->addDealerProducts($this);
             */
        }

        return $this->aProduct;
    }