Get the associated ChildSport object

@param  ConnectionInterface $con Optional Connection object.
@return ChildSport The associated ChildSport object.
@throws PropelException
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;
    }
1017795
public function getUser(ConnectionInterface $con = null)
    {
        if ($this->aUser === null && ($this->user_id !== null)) {
            $this->aUser = ChildUserQuery::create()->findPk($this->user_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->aUser->addUserRoles($this);
             */
        }

        return $this->aUser;
    }
399948
public function getAttributeAttributeType(ConnectionInterface $con = null)
    {
        if ($this->aAttributeAttributeType === null && ($this->attribute_attribute_type_id !== null)) {
            $this->aAttributeAttributeType = ChildAttributeAttributeTypeQuery::create()->findPk($this->attribute_attribute_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->aAttributeAttributeType->addAttributeTypeAvMetas($this);
             */
        }

        return $this->aAttributeAttributeType;
    }
1320690
public function getReference(ConnectionInterface $con = null)
    {
        if ($this->aReference === null && ($this->reference_id !== null)) {
            $this->aReference = ChildReferenceQuery::create()->findPk($this->reference_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->aReference->addVideos($this);
             */
        }

        return $this->aReference;
    }
1271541
public function getEndPosition(ConnectionInterface $con = null)
    {
        if ($this->aEndPosition === null && ($this->end_position_id !== null)) {
            $this->aEndPosition = ChildPositionQuery::create()->findPk($this->end_position_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->aEndPosition->addSkillsRelatedByEndPositionId($this);
             */
        }

        return $this->aEndPosition;
    }
111866
public function getNext(ConnectionInterface $con = null)
    {

        $query = ChildCustomerGroupQuery::create();

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


        return $query->findOne($con);
    }
1265241
public function getPlayer(ConnectionInterface $con = null)
    {
        if ($this->aPlayer === null && ($this->player_id !== null)) {
            $this->aPlayer = PlayerQuery::create()->findPk($this->player_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->aPlayer->addRecords($this);
             */
        }

        return $this->aPlayer;
    }
821382
protected function doUpdate(ConnectionInterface $con)
    {
        $selectCriteria = $this->buildPkeyCriteria();
        $valuesCriteria = $this->buildCriteria();

        return $selectCriteria->doUpdate($valuesCriteria, $con);
    }
546037
protected function doInsert(ConnectionInterface $con)
    {
        $modifiedColumns = array();
        $index = 0;

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

         // check the columns in natural order for more readable SQL queries
        if ($this->isColumnModified(LineageTableMap::COL_ID)) {
            $modifiedColumns[':p' . $index++]  = '`id`';
        }
        if ($this->isColumnModified(LineageTableMap::COL_SKILL_ID)) {
            $modifiedColumns[':p' . $index++]  = '`skill_id`';
        }
        if ($this->isColumnModified(LineageTableMap::COL_ANCESTOR_ID)) {
            $modifiedColumns[':p' . $index++]  = '`ancestor_id`';
        }
        if ($this->isColumnModified(LineageTableMap::COL_POSITION)) {
            $modifiedColumns[':p' . $index++]  = '`position`';
        }

        $sql = sprintf(
            'INSERT INTO `kk_trixionary_lineage` (%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 '`skill_id`':
                        $stmt->bindValue($identifier, $this->skill_id, PDO::PARAM_INT);
                        break;
                    case '`ancestor_id`':
                        $stmt->bindValue($identifier, $this->ancestor_id, PDO::PARAM_INT);
                        break;
                    case '`position`':
                        $stmt->bindValue($identifier, $this->position, 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);
    }
784762
protected function doInsert(ConnectionInterface $con)
    {
        $modifiedColumns = array();
        $index = 0;

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

         // check the columns in natural order for more readable SQL queries
        if ($this->isColumnModified(SportTableMap::COL_ID)) {
            $modifiedColumns[':p' . $index++]  = '`id`';
        }
        if ($this->isColumnModified(SportTableMap::COL_TITLE)) {
            $modifiedColumns[':p' . $index++]  = '`title`';
        }
        if ($this->isColumnModified(SportTableMap::COL_SLUG)) {
            $modifiedColumns[':p' . $index++]  = '`slug`';
        }
        if ($this->isColumnModified(SportTableMap::COL_ATHLETE_LABEL)) {
            $modifiedColumns[':p' . $index++]  = '`athlete_label`';
        }
        if ($this->isColumnModified(SportTableMap::COL_OBJECT_SLUG)) {
            $modifiedColumns[':p' . $index++]  = '`object_slug`';
        }
        if ($this->isColumnModified(SportTableMap::COL_OBJECT_LABEL)) {
            $modifiedColumns[':p' . $index++]  = '`object_label`';
        }
        if ($this->isColumnModified(SportTableMap::COL_OBJECT_PLURAL_LABEL)) {
            $modifiedColumns[':p' . $index++]  = '`object_plural_label`';
        }
        if ($this->isColumnModified(SportTableMap::COL_SKILL_SLUG)) {
            $modifiedColumns[':p' . $index++]  = '`skill_slug`';
        }
        if ($this->isColumnModified(SportTableMap::COL_SKILL_LABEL)) {
            $modifiedColumns[':p' . $index++]  = '`skill_label`';
        }
        if ($this->isColumnModified(SportTableMap::COL_SKILL_PLURAL_LABEL)) {
            $modifiedColumns[':p' . $index++]  = '`skill_plural_label`';
        }
        if ($this->isColumnModified(SportTableMap::COL_SKILL_PICTURE_URL)) {
            $modifiedColumns[':p' . $index++]  = '`skill_picture_url`';
        }
        if ($this->isColumnModified(SportTableMap::COL_GROUP_SLUG)) {
            $modifiedColumns[':p' . $index++]  = '`group_slug`';
        }
        if ($this->isColumnModified(SportTableMap::COL_GROUP_LABEL)) {
            $modifiedColumns[':p' . $index++]  = '`group_label`';
        }
        if ($this->isColumnModified(SportTableMap::COL_GROUP_PLURAL_LABEL)) {
            $modifiedColumns[':p' . $index++]  = '`group_plural_label`';
        }
        if ($this->isColumnModified(SportTableMap::COL_TRANSITION_LABEL)) {
            $modifiedColumns[':p' . $index++]  = '`transition_label`';
        }
        if ($this->isColumnModified(SportTableMap::COL_TRANSITION_PLURAL_LABEL)) {
            $modifiedColumns[':p' . $index++]  = '`transition_plural_label`';
        }
        if ($this->isColumnModified(SportTableMap::COL_TRANSITIONS_SLUG)) {
            $modifiedColumns[':p' . $index++]  = '`transitions_slug`';
        }
        if ($this->isColumnModified(SportTableMap::COL_POSITION_SLUG)) {
            $modifiedColumns[':p' . $index++]  = '`position_slug`';
        }
        if ($this->isColumnModified(SportTableMap::COL_POSITION_LABEL)) {
            $modifiedColumns[':p' . $index++]  = '`position_label`';
        }
        if ($this->isColumnModified(SportTableMap::COL_FEATURE_COMPOSITION)) {
            $modifiedColumns[':p' . $index++]  = '`feature_composition`';
        }
        if ($this->isColumnModified(SportTableMap::COL_FEATURE_TESTER)) {
            $modifiedColumns[':p' . $index++]  = '`feature_tester`';
        }
        if ($this->isColumnModified(SportTableMap::COL_IS_DEFAULT)) {
            $modifiedColumns[':p' . $index++]  = '`is_default`';
        }

        $sql = sprintf(
            'INSERT INTO `kk_trixionary_sport` (%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 '`slug`':
                        $stmt->bindValue($identifier, $this->slug, PDO::PARAM_STR);
                        break;
                    case '`athlete_label`':
                        $stmt->bindValue($identifier, $this->athlete_label, PDO::PARAM_STR);
                        break;
                    case '`object_slug`':
                        $stmt->bindValue($identifier, $this->object_slug, PDO::PARAM_STR);
                        break;
                    case '`object_label`':
                        $stmt->bindValue($identifier, $this->object_label, PDO::PARAM_STR);
                        break;
                    case '`object_plural_label`':
                        $stmt->bindValue($identifier, $this->object_plural_label, PDO::PARAM_STR);
                        break;
                    case '`skill_slug`':
                        $stmt->bindValue($identifier, $this->skill_slug, PDO::PARAM_STR);
                        break;
                    case '`skill_label`':
                        $stmt->bindValue($identifier, $this->skill_label, PDO::PARAM_STR);
                        break;
                    case '`skill_plural_label`':
                        $stmt->bindValue($identifier, $this->skill_plural_label, PDO::PARAM_STR);
                        break;
                    case '`skill_picture_url`':
                        $stmt->bindValue($identifier, $this->skill_picture_url, PDO::PARAM_STR);
                        break;
                    case '`group_slug`':
                        $stmt->bindValue($identifier, $this->group_slug, PDO::PARAM_STR);
                        break;
                    case '`group_label`':
                        $stmt->bindValue($identifier, $this->group_label, PDO::PARAM_STR);
                        break;
                    case '`group_plural_label`':
                        $stmt->bindValue($identifier, $this->group_plural_label, PDO::PARAM_STR);
                        break;
                    case '`transition_label`':
                        $stmt->bindValue($identifier, $this->transition_label, PDO::PARAM_STR);
                        break;
                    case '`transition_plural_label`':
                        $stmt->bindValue($identifier, $this->transition_plural_label, PDO::PARAM_STR);
                        break;
                    case '`transitions_slug`':
                        $stmt->bindValue($identifier, $this->transitions_slug, PDO::PARAM_STR);
                        break;
                    case '`position_slug`':
                        $stmt->bindValue($identifier, $this->position_slug, PDO::PARAM_STR);
                        break;
                    case '`position_label`':
                        $stmt->bindValue($identifier, $this->position_label, PDO::PARAM_STR);
                        break;
                    case '`feature_composition`':
                        $stmt->bindValue($identifier, (int) $this->feature_composition, PDO::PARAM_INT);
                        break;
                    case '`feature_tester`':
                        $stmt->bindValue($identifier, (int) $this->feature_tester, PDO::PARAM_INT);
                        break;
                    case '`is_default`':
                        $stmt->bindValue($identifier, (int) $this->is_default, 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);
    }
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;
    }
129986
public function getMultipleOf(ConnectionInterface $con = null)
    {
        if ($this->aMultipleOf === null && ($this->multiple_of_id !== null)) {
            $this->aMultipleOf = ChildSkillQuery::create()->findPk($this->multiple_of_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->aMultipleOf->addMultiples($this);
             */
        }

        return $this->aMultipleOf;
    }
922821
public function getCustomerGroup(ConnectionInterface $con = null)
    {
        if ($this->aCustomerGroup === null && ($this->id !== null)) {
            $this->aCustomerGroup = ChildCustomerGroupQuery::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->aCustomerGroup->addCustomerGroupI18ns($this);
             */
        }

        return $this->aCustomerGroup;
    }
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;
    }
772424
public function getKstruktur(ConnectionInterface $con = null)
    {

        if ($this->singleKstruktur === null && !$this->isNew()) {
            $this->singleKstruktur = ChildKstrukturQuery::create()->findPk($this->getPrimaryKey(), $con);
        }

        return $this->singleKstruktur;
    }
496763
public function getStartPosition(ConnectionInterface $con = null)
    {
        if ($this->aStartPosition === null && ($this->start_position_id !== null)) {
            $this->aStartPosition = ChildPositionQuery::create()->findPk($this->start_position_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->aStartPosition->addSkillsRelatedByStartPositionId($this);
             */
        }

        return $this->aStartPosition;
    }
1082522
public function getVariationOf(ConnectionInterface $con = null)
    {
        if ($this->aVariationOf === null && ($this->variation_of_id !== null)) {
            $this->aVariationOf = ChildSkillQuery::create()->findPk($this->variation_of_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->aVariationOf->addVariations($this);
             */
        }

        return $this->aVariationOf;
    }