Get the associated ChildFolder object

@param      ConnectionInterface $con Optional Connection object.
@return                 ChildFolder The associated ChildFolder object.
@throws PropelException
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;
    }
358704
public function getRole(ConnectionInterface $con = null)
    {
        if ($this->aRole === null && ($this->role_id !== null)) {
            $this->aRole = ChildRoleQuery::create()->findPk($this->role_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->aRole->addUserRoles($this);
             */
        }

        return $this->aRole;
    }
1358825
public function getDealerContactInfo(ConnectionInterface $con = null)
    {
        if ($this->aDealerContactInfo === null && ($this->id !== null)) {
            $this->aDealerContactInfo = ChildDealerContactInfoQuery::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->aDealerContactInfo->addDealerContactInfoVersions($this);
             */
        }

        return $this->aDealerContactInfo;
    }
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;
    }
392729
public function delete(ConnectionInterface $con = null)
    {
        if ($this->isDeleted()) {
            throw new PropelException("This object has already been deleted.");
        }

        if ($con === null) {
            $con = Propel::getServiceContainer()->getWriteConnection(CategoryTableMap::DATABASE_NAME);
        }

        $con->transaction(function () use ($con) {
            $deleteQuery = ChildCategoryQuery::create()
                ->filterByPrimaryKey($this->getPrimaryKey());
            $ret = $this->preDelete($con);
            // nested_set behavior
            if ($this->isRoot()) {
                throw new PropelException('Deletion of a root node is disabled for nested sets. Use ChildCategoryQuery::deleteTree() instead to delete an entire tree');
            }

            if ($this->isInTree()) {
                $this->deleteDescendants($con);
            }

            if ($ret) {
                $deleteQuery->delete($con);
                $this->postDelete($con);
                // nested_set behavior
                if ($this->isInTree()) {
                    // fill up the room that was used by the node
                    ChildCategoryQuery::shiftRLValues(-2, $this->getRightValue() + 1, null, $con);
                }

                $this->setDeleted(true);
            }
        });
    }
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;
    }
213377
protected function doInsert(ConnectionInterface $con)
    {
        $modifiedColumns = array();
        $index = 0;

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

         // check the columns in natural order for more readable SQL queries
        if ($this->isColumnModified(FeatureTypeTableMap::ID)) {
            $modifiedColumns[':p' . $index++]  = 'ID';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::SLUG)) {
            $modifiedColumns[':p' . $index++]  = 'SLUG';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::HAS_FEATURE_AV_VALUE)) {
            $modifiedColumns[':p' . $index++]  = 'HAS_FEATURE_AV_VALUE';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::IS_MULTILINGUAL_FEATURE_AV_VALUE)) {
            $modifiedColumns[':p' . $index++]  = 'IS_MULTILINGUAL_FEATURE_AV_VALUE';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::PATTERN)) {
            $modifiedColumns[':p' . $index++]  = 'PATTERN';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::CSS_CLASS)) {
            $modifiedColumns[':p' . $index++]  = 'CSS_CLASS';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::INPUT_TYPE)) {
            $modifiedColumns[':p' . $index++]  = 'INPUT_TYPE';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::MAX)) {
            $modifiedColumns[':p' . $index++]  = 'MAX';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::MIN)) {
            $modifiedColumns[':p' . $index++]  = 'MIN';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::STEP)) {
            $modifiedColumns[':p' . $index++]  = 'STEP';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::IMAGE_MAX_WIDTH)) {
            $modifiedColumns[':p' . $index++]  = 'IMAGE_MAX_WIDTH';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::IMAGE_MAX_HEIGHT)) {
            $modifiedColumns[':p' . $index++]  = 'IMAGE_MAX_HEIGHT';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::IMAGE_RATIO)) {
            $modifiedColumns[':p' . $index++]  = 'IMAGE_RATIO';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::CREATED_AT)) {
            $modifiedColumns[':p' . $index++]  = 'CREATED_AT';
        }
        if ($this->isColumnModified(FeatureTypeTableMap::UPDATED_AT)) {
            $modifiedColumns[':p' . $index++]  = 'UPDATED_AT';
        }

        $sql = sprintf(
            'INSERT INTO feature_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 'SLUG':
                        $stmt->bindValue($identifier, $this->slug, PDO::PARAM_STR);
                        break;
                    case 'HAS_FEATURE_AV_VALUE':
                        $stmt->bindValue($identifier, $this->has_feature_av_value, PDO::PARAM_INT);
                        break;
                    case 'IS_MULTILINGUAL_FEATURE_AV_VALUE':
                        $stmt->bindValue($identifier, $this->is_multilingual_feature_av_value, PDO::PARAM_INT);
                        break;
                    case 'PATTERN':
                        $stmt->bindValue($identifier, $this->pattern, PDO::PARAM_STR);
                        break;
                    case 'CSS_CLASS':
                        $stmt->bindValue($identifier, $this->css_class, PDO::PARAM_STR);
                        break;
                    case 'INPUT_TYPE':
                        $stmt->bindValue($identifier, $this->input_type, PDO::PARAM_STR);
                        break;
                    case 'MAX':
                        $stmt->bindValue($identifier, $this->max, PDO::PARAM_STR);
                        break;
                    case 'MIN':
                        $stmt->bindValue($identifier, $this->min, PDO::PARAM_STR);
                        break;
                    case 'STEP':
                        $stmt->bindValue($identifier, $this->step, PDO::PARAM_STR);
                        break;
                    case 'IMAGE_MAX_WIDTH':
                        $stmt->bindValue($identifier, $this->image_max_width, PDO::PARAM_STR);
                        break;
                    case 'IMAGE_MAX_HEIGHT':
                        $stmt->bindValue($identifier, $this->image_max_height, PDO::PARAM_STR);
                        break;
                    case 'IMAGE_RATIO':
                        $stmt->bindValue($identifier, $this->image_ratio, PDO::PARAM_STR);
                        break;
                    case 'CREATED_AT':
                        $stmt->bindValue($identifier, $this->created_at ? $this->created_at->format("Y-m-d H:i:s") : null, PDO::PARAM_STR);
                        break;
                    case 'UPDATED_AT':
                        $stmt->bindValue($identifier, $this->updated_at ? $this->updated_at->format("Y-m-d H:i:s") : 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);
    }
798210
public function getPersonFunction(ConnectionInterface $con = null)
    {
        if ($this->aPersonFunction === null && ($this->id !== null)) {
            $this->aPersonFunction = ChildPersonFunctionQuery::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->aPersonFunction->addPersonFunctionI18ns($this);
             */
        }

        return $this->aPersonFunction;
    }
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;
    }
605830
protected function doInsert(ConnectionInterface $con)
    {
        $modifiedColumns = array();
        $index = 0;

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

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

        $sql = sprintf(
            'INSERT INTO smarty_filter (%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 'ACTIVE':
                        $stmt->bindValue($identifier, $this->active, PDO::PARAM_INT);
                        break;
                    case 'FILTERTYPE':
                        $stmt->bindValue($identifier, $this->filtertype, PDO::PARAM_STR);
                        break;
                    case 'CODE':
                        $stmt->bindValue($identifier, $this->code, 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);
    }
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;
    }
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;
    }
569041
public function delete(ConnectionInterface $con = null)
    {
        if (0 === count($this->getMap())) {
            throw new PropelException(__METHOD__ .' expects a Criteria with at least one condition. Use deleteAll() to delete all the rows of a table');
        }

        if (null === $con) {
            $con = Propel::getServiceContainer()->getWriteConnection($this->getDbName());
        }

        $criteria = $this->isKeepQuery() ? clone $this : $this;
        $criteria->setDbName($this->getDbName());

        try {
            return $con->transaction(function () use ($con, $criteria) {
                $affectedRows = $criteria->basePreDelete($con);
                if (!$affectedRows) {
                    $affectedRows = $criteria->doDelete($con);
                }
                $criteria->basePostDelete($affectedRows, $con);

                return $affectedRows;
            });
        } catch (PropelException $e) {
            throw new PropelException(__METHOD__  . ' is unable to delete. ', 0, $e);
        }
    }
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;
    }
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;
    }
763599
public function getParent(ConnectionInterface $con = null)
    {
        if (null === $this->aNestedSetParent && $this->hasParent()) {
            $this->aNestedSetParent = ChildCategoryQuery::create()
                ->ancestorsOf($this)
                ->orderByLevel(true)
                ->findOne($con);
        }

        return $this->aNestedSetParent;
    }