Get the associated ChildDealerContact object

@param      ConnectionInterface $con Optional Connection object.
@return                 ChildDealerContact The associated ChildDealerContact object.
@throws PropelException
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;
    }
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;
    }
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);
    }
269621
public function getFeature(ConnectionInterface $con = null)
    {
        if ($this->aFeature === null && ($this->feature_id !== null)) {
            $this->aFeature = FeatureQuery::create()->findPk($this->feature_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->aFeature->addFeatureFeatureTypes($this);
             */
        }

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

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

         // check the columns in natural order for more readable SQL queries
        if ($this->isColumnModified(AttributeAttributeTypeTableMap::ID)) {
            $modifiedColumns[':p' . $index++]  = 'ID';
        }
        if ($this->isColumnModified(AttributeAttributeTypeTableMap::ATTRIBUTE_ID)) {
            $modifiedColumns[':p' . $index++]  = 'ATTRIBUTE_ID';
        }
        if ($this->isColumnModified(AttributeAttributeTypeTableMap::ATTRIBUTE_TYPE_ID)) {
            $modifiedColumns[':p' . $index++]  = 'ATTRIBUTE_TYPE_ID';
        }

        $sql = sprintf(
            'INSERT INTO attribute_attribute_type (%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 'ATTRIBUTE_ID':
                        $stmt->bindValue($identifier, $this->attribute_id, PDO::PARAM_INT);
                        break;
                    case 'ATTRIBUTE_TYPE_ID':
                        $stmt->bindValue($identifier, $this->attribute_type_id, 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);
    }
772424
public function getKstruktur(ConnectionInterface $con = null)
    {

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

        return $this->singleKstruktur;
    }
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;
    }
1027259
public function getSkillRelatedByCompositeId(ConnectionInterface $con = null)
    {
        if ($this->aSkillRelatedByCompositeId === null && ($this->composite_id !== null)) {
            $this->aSkillRelatedByCompositeId = ChildSkillQuery::create()->findPk($this->composite_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->aSkillRelatedByCompositeId->addComposites($this);
             */
        }

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

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

         // check the columns in natural order for more readable SQL queries
        if ($this->isColumnModified(GamecurrencyTableMap::COL_ID)) {
            $modifiedColumns[':p' . $index++]  = 'id';
        }
        if ($this->isColumnModified(GamecurrencyTableMap::COL_SENDERLOGIN)) {
            $modifiedColumns[':p' . $index++]  = 'senderLogin';
        }
        if ($this->isColumnModified(GamecurrencyTableMap::COL_RECEIVERLOGIN)) {
            $modifiedColumns[':p' . $index++]  = 'receiverLogin';
        }
        if ($this->isColumnModified(GamecurrencyTableMap::COL_TRANSACTIONID)) {
            $modifiedColumns[':p' . $index++]  = 'transactionId';
        }
        if ($this->isColumnModified(GamecurrencyTableMap::COL_BILLID)) {
            $modifiedColumns[':p' . $index++]  = 'billId';
        }
        if ($this->isColumnModified(GamecurrencyTableMap::COL_AMOUNT)) {
            $modifiedColumns[':p' . $index++]  = 'amount';
        }
        if ($this->isColumnModified(GamecurrencyTableMap::COL_MESSAGE)) {
            $modifiedColumns[':p' . $index++]  = 'message';
        }
        if ($this->isColumnModified(GamecurrencyTableMap::COL_STATUS)) {
            $modifiedColumns[':p' . $index++]  = 'status';
        }
        if ($this->isColumnModified(GamecurrencyTableMap::COL_DATETIME)) {
            $modifiedColumns[':p' . $index++]  = 'datetime';
        }

        $sql = sprintf(
            'INSERT INTO gamecurrency (%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 'senderLogin':
                        $stmt->bindValue($identifier, $this->senderlogin, PDO::PARAM_STR);
                        break;
                    case 'receiverLogin':
                        $stmt->bindValue($identifier, $this->receiverlogin, PDO::PARAM_STR);
                        break;
                    case 'transactionId':
                        $stmt->bindValue($identifier, $this->transactionid, PDO::PARAM_INT);
                        break;
                    case 'billId':
                        $stmt->bindValue($identifier, $this->billid, PDO::PARAM_INT);
                        break;
                    case 'amount':
                        $stmt->bindValue($identifier, $this->amount, PDO::PARAM_INT);
                        break;
                    case 'message':
                        $stmt->bindValue($identifier, $this->message, PDO::PARAM_STR);
                        break;
                    case 'status':
                        $stmt->bindValue($identifier, $this->status, PDO::PARAM_INT);
                        break;
                    case 'datetime':
                        $stmt->bindValue($identifier, $this->datetime ? $this->datetime->format("Y-m-d H:i:s.u") : null, PDO::PARAM_STR);
                        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);
    }
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;
    }
666039
protected function doInsert(ConnectionInterface $con)
    {
        $modifiedColumns = array();
        $index = 0;

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

         // check the columns in natural order for more readable SQL queries
        if ($this->isColumnModified(PageTableMap::COL_ID)) {
            $modifiedColumns[':p' . $index++]  = 'id';
        }
        if ($this->isColumnModified(PageTableMap::COL_SOURCE_ID)) {
            $modifiedColumns[':p' . $index++]  = 'source_id';
        }
        if ($this->isColumnModified(PageTableMap::COL_PAGEID)) {
            $modifiedColumns[':p' . $index++]  = 'pageid';
        }
        if ($this->isColumnModified(PageTableMap::COL_TITLE)) {
            $modifiedColumns[':p' . $index++]  = 'title';
        }
        if ($this->isColumnModified(PageTableMap::COL_DISPLAYTITLE)) {
            $modifiedColumns[':p' . $index++]  = 'displaytitle';
        }
        if ($this->isColumnModified(PageTableMap::COL_PAGE_IMAGE_FREE)) {
            $modifiedColumns[':p' . $index++]  = 'page_image_free';
        }
        if ($this->isColumnModified(PageTableMap::COL_WIKIBASE_ITEM)) {
            $modifiedColumns[':p' . $index++]  = 'wikibase_item';
        }
        if ($this->isColumnModified(PageTableMap::COL_DISAMBIGUATION)) {
            $modifiedColumns[':p' . $index++]  = 'disambiguation';
        }
        if ($this->isColumnModified(PageTableMap::COL_DEFAULTSORT)) {
            $modifiedColumns[':p' . $index++]  = 'defaultsort';
        }
        if ($this->isColumnModified(PageTableMap::COL_CREATED_AT)) {
            $modifiedColumns[':p' . $index++]  = 'created_at';
        }
        if ($this->isColumnModified(PageTableMap::COL_UPDATED_AT)) {
            $modifiedColumns[':p' . $index++]  = 'updated_at';
        }

        $sql = sprintf(
            'INSERT INTO page (%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 'source_id':
                        $stmt->bindValue($identifier, $this->source_id, PDO::PARAM_INT);
                        break;
                    case 'pageid':
                        $stmt->bindValue($identifier, $this->pageid, PDO::PARAM_INT);
                        break;
                    case 'title':
                        $stmt->bindValue($identifier, $this->title, PDO::PARAM_STR);
                        break;
                    case 'displaytitle':
                        $stmt->bindValue($identifier, $this->displaytitle, PDO::PARAM_STR);
                        break;
                    case 'page_image_free':
                        $stmt->bindValue($identifier, $this->page_image_free, PDO::PARAM_STR);
                        break;
                    case 'wikibase_item':
                        $stmt->bindValue($identifier, $this->wikibase_item, PDO::PARAM_STR);
                        break;
                    case 'disambiguation':
                        $stmt->bindValue($identifier, $this->disambiguation, PDO::PARAM_STR);
                        break;
                    case 'defaultsort':
                        $stmt->bindValue($identifier, $this->defaultsort, PDO::PARAM_STR);
                        break;
                    case 'created_at':
                        $stmt->bindValue($identifier, $this->created_at ? $this->created_at->format("Y-m-d H:i:s.u") : null, PDO::PARAM_STR);
                        break;
                    case 'updated_at':
                        $stmt->bindValue($identifier, $this->updated_at ? $this->updated_at->format("Y-m-d H:i:s.u") : null, PDO::PARAM_STR);
                        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);
    }
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;
    }
1055165
public function findRoot(ConnectionInterface $con = null)
    {
        return $this
            ->addUsingAlias(ChildCategory::LEFT_COL, 1, Criteria::EQUAL)
            ->findOne($con);
    }
78123
protected function doInsert(ConnectionInterface $con)
    {
        $modifiedColumns = array();
        $index = 0;

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

         // check the columns in natural order for more readable SQL queries
        if ($this->isColumnModified(PlayerTableMap::COL_ID)) {
            $modifiedColumns[':p' . $index++]  = 'id';
        }
        if ($this->isColumnModified(PlayerTableMap::COL_LOGIN)) {
            $modifiedColumns[':p' . $index++]  = 'login';
        }
        if ($this->isColumnModified(PlayerTableMap::COL_NICKNAME)) {
            $modifiedColumns[':p' . $index++]  = 'nickname';
        }
        if ($this->isColumnModified(PlayerTableMap::COL_NICKNAME_STRIPPED)) {
            $modifiedColumns[':p' . $index++]  = 'nickname_stripped';
        }
        if ($this->isColumnModified(PlayerTableMap::COL_PATH)) {
            $modifiedColumns[':p' . $index++]  = 'path';
        }
        if ($this->isColumnModified(PlayerTableMap::COL_WINS)) {
            $modifiedColumns[':p' . $index++]  = 'wins';
        }
        if ($this->isColumnModified(PlayerTableMap::COL_ONLINE_TIME)) {
            $modifiedColumns[':p' . $index++]  = 'online_time';
        }
        if ($this->isColumnModified(PlayerTableMap::COL_LAST_ONLINE)) {
            $modifiedColumns[':p' . $index++]  = 'last_online';
        }

        $sql = sprintf(
            'INSERT INTO player (%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 'login':
                        $stmt->bindValue($identifier, $this->login, PDO::PARAM_STR);
                        break;
                    case 'nickname':
                        $stmt->bindValue($identifier, $this->nickname, PDO::PARAM_STR);
                        break;
                    case 'nickname_stripped':
                        $stmt->bindValue($identifier, $this->nickname_stripped, PDO::PARAM_STR);
                        break;
                    case 'path':
                        $stmt->bindValue($identifier, $this->path, PDO::PARAM_STR);
                        break;
                    case 'wins':
                        $stmt->bindValue($identifier, $this->wins, PDO::PARAM_INT);
                        break;
                    case 'online_time':
                        $stmt->bindValue($identifier, $this->online_time, PDO::PARAM_INT);
                        break;
                    case 'last_online':
                        $stmt->bindValue($identifier, $this->last_online ? $this->last_online->format("Y-m-d H:i:s.u") : null, PDO::PARAM_STR);
                        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);
    }
1294470
public function getCountry(ConnectionInterface $con = null)
    {
        if ($this->aCountry === null && ($this->country_id !== null)) {
            $this->aCountry = CountryQuery::create()->findPk($this->country_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->aCountry->addDealers($this);
             */
        }

        return $this->aCountry;
    }
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;
    }
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;
    }