Get the associated ChildTeam object

@param      ConnectionInterface $con Optional Connection object.
@return                 ChildTeam The associated ChildTeam object.
@throws PropelException
439359
public function getTeam(ConnectionInterface $con = null)
    {
        if ($this->aTeam === null && ($this->id !== null)) {
            $this->aTeam = ChildTeamQuery::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->aTeam->addTeamVersions($this);
             */
        }

        return $this->aTeam;
    }
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;
    }
983762
public function getPermissionRelatedByParentId(ConnectionInterface $con = null)
    {
        if ($this->aPermissionRelatedByParentId === null && ($this->parent_id !== null)) {
            $this->aPermissionRelatedByParentId = ChildPermissionQuery::create()->findPk($this->parent_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->aPermissionRelatedByParentId->addPermissionsRelatedById($this);
             */
        }

        return $this->aPermissionRelatedByParentId;
    }
1045156
public function hasNextSibling(ConnectionInterface $con = null)
    {
        if (!ChildCategoryQuery::isValid($this)) {
            return false;
        }

        return ChildCategoryQuery::create()
            ->filterByTreeLeft($this->getRightValue() + 1)
            ->exists($con);
    }
318129
public function getAttribute(ConnectionInterface $con = null)
    {
        if ($this->aAttribute === null && ($this->attribute_id !== null)) {
            $this->aAttribute = AttributeQuery::create()->findPk($this->attribute_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->aAttribute->addAttributeAttributeTypes($this);
             */
        }

        return $this->aAttribute;
    }
793787
public function getTranslation($locale = 'en_US', ConnectionInterface $con = null)
    {
        if (!isset($this->currentTranslations[$locale])) {
            if (null !== $this->collFeatureTypeI18ns) {
                foreach ($this->collFeatureTypeI18ns as $translation) {
                    if ($translation->getLocale() == $locale) {
                        $this->currentTranslations[$locale] = $translation;

                        return $translation;
                    }
                }
            }
            if ($this->isNew()) {
                $translation = new ChildFeatureTypeI18n();
                $translation->setLocale($locale);
            } else {
                $translation = ChildFeatureTypeI18nQuery::create()
                    ->filterByPrimaryKey(array($this->getPrimaryKey(), $locale))
                    ->findOneOrCreate($con);
                $this->currentTranslations[$locale] = $translation;
            }
            $this->addFeatureTypeI18n($translation);
        }

        return $this->currentTranslations[$locale];
    }
111866
public function getNext(ConnectionInterface $con = null)
    {

        $query = ChildCustomerGroupQuery::create();

        $query->filterByRank($this->getPosition() + 1);


        return $query->findOne($con);
    }
583374
public function getDealerProduct(ConnectionInterface $con = null)
    {
        if ($this->aDealerProduct === null && ($this->id !== null)) {
            $this->aDealerProduct = ChildDealerProductQuery::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->aDealerProduct->addDealerProductVersions($this);
             */
        }

        return $this->aDealerProduct;
    }
975106
public function getDealerContact(ConnectionInterface $con = null)
    {
        if ($this->aDealerContact === null && ($this->id !== null)) {
            $this->aDealerContact = ChildDealerContactQuery::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->aDealerContact->addDealerContactVersions($this);
             */
        }

        return $this->aDealerContact;
    }
36964
public function getChildren(Criteria $criteria = null, ConnectionInterface $con = null)
    {
        if (null === $this->collNestedSetChildren || null !== $criteria) {
            if ($this->isLeaf() || ($this->isNew() && null === $this->collNestedSetChildren)) {
                // return empty collection
                $this->initNestedSetChildren();
            } else {
                $collNestedSetChildren = ChildCategoryQuery::create(null, $criteria)
                    ->childrenOf($this)
                    ->orderByBranch()
                    ->find($con);
                if (null !== $criteria) {
                    return $collNestedSetChildren;
                }
                $this->collNestedSetChildren = $collNestedSetChildren;
            }
        }

        return $this->collNestedSetChildren;
    }
1044777
public function getMaxRankArray(ConnectionInterface $con = null)
    {
        if ($con === null) {
            $con = Propel::getConnection(CustomerGroupTableMap::DATABASE_NAME);
        }
        // shift the objects with a position lower than the one of object
        $this->addSelectColumn('MAX(' . CustomerGroupTableMap::RANK_COL . ')');
        $stmt = $this->doSelect($con);

        return $stmt->fetchColumn();
    }
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;
    }
622098
public function getAttributeAv(ConnectionInterface $con = null)
    {
        if ($this->aAttributeAv === null && ($this->attribute_av_id !== null)) {
            $this->aAttributeAv = AttributeAvQuery::create()->findPk($this->attribute_av_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->aAttributeAv->addAttributeTypeAvMetas($this);
             */
        }

        return $this->aAttributeAv;
    }
559976
public function getPersonImage(ConnectionInterface $con = null)
    {
        if ($this->aPersonImage === null && ($this->id !== null)) {
            $this->aPersonImage = ChildPersonImageQuery::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->aPersonImage->addPersonImageVersions($this);
             */
        }

        return $this->aPersonImage;
    }
542275
public function getPermission(ConnectionInterface $con = null)
    {
        if ($this->aPermission === null && ($this->permission_id !== null)) {
            $this->aPermission = ChildPermissionQuery::create()->findPk($this->permission_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->aPermission->addRolePermissions($this);
             */
        }

        return $this->aPermission;
    }
475033
protected function doInsert(ConnectionInterface $con)
    {
        $modifiedColumns = array();
        $index = 0;

        $this->modifiedColumns[GroupTableMap::COL_ID] = true;
        if (null !== $this->id) {
            throw new PropelException('Cannot insert a value for auto-increment primary key (' . GroupTableMap::COL_ID . ')');
        }

         // check the columns in natural order for more readable SQL queries
        if ($this->isColumnModified(GroupTableMap::COL_ID)) {
            $modifiedColumns[':p' . $index++]  = '`id`';
        }
        if ($this->isColumnModified(GroupTableMap::COL_TITLE)) {
            $modifiedColumns[':p' . $index++]  = '`title`';
        }
        if ($this->isColumnModified(GroupTableMap::COL_DESCRIPTION)) {
            $modifiedColumns[':p' . $index++]  = '`description`';
        }
        if ($this->isColumnModified(GroupTableMap::COL_SLUG)) {
            $modifiedColumns[':p' . $index++]  = '`slug`';
        }
        if ($this->isColumnModified(GroupTableMap::COL_SPORT_ID)) {
            $modifiedColumns[':p' . $index++]  = '`sport_id`';
        }
        if ($this->isColumnModified(GroupTableMap::COL_SKILL_COUNT)) {
            $modifiedColumns[':p' . $index++]  = '`skill_count`';
        }

        $sql = sprintf(
            'INSERT INTO `kk_trixionary_group` (%s) VALUES (%s)',
            implode(', ', $modifiedColumns),
            implode(', ', array_keys($modifiedColumns))
        );

        try {
            $stmt = $con->prepare($sql);
            foreach ($modifiedColumns as $identifier => $columnName) {
                switch ($columnName) {
                    case '`id`':
                        $stmt->bindValue($identifier, $this->id, PDO::PARAM_INT);
                        break;
                    case '`title`':
                        $stmt->bindValue($identifier, $this->title, PDO::PARAM_STR);
                        break;
                    case '`description`':
                        $stmt->bindValue($identifier, $this->description, PDO::PARAM_STR);
                        break;
                    case '`slug`':
                        $stmt->bindValue($identifier, $this->slug, PDO::PARAM_STR);
                        break;
                    case '`sport_id`':
                        $stmt->bindValue($identifier, $this->sport_id, PDO::PARAM_INT);
                        break;
                    case '`skill_count`':
                        $stmt->bindValue($identifier, $this->skill_count, PDO::PARAM_INT);
                        break;
                }
            }
            $stmt->execute();
        } catch (Exception $e) {
            Propel::log($e->getMessage(), Propel::LOG_ERR);
            throw new PropelException(sprintf('Unable to execute INSERT statement [%s]', $sql), 0, $e);
        }

        try {
            $pk = $con->lastInsertId();
        } catch (Exception $e) {
            throw new PropelException('Unable to get autoincrement id.', 0, $e);
        }
        $this->setId($pk);

        $this->setNew(false);
    }
394834
public function getCategory(ConnectionInterface $con = null)
    {
        if ($this->aCategory === null && ($this->category_id != 0)) {
            $this->aCategory = ChildCategoryQuery::create()->findPk($this->category_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->aCategory->addC2Ms($this);
             */
        }

        return $this->aCategory;
    }