Gets all the versions of this object, in incremental order

@param   ConnectionInterface $con the connection to use

@return  ObjectCollection|ChildSkillVersion[] A list of ChildSkillVersion objects
433513
public function getAllVersions($con = null)
    {
        $criteria = new Criteria();
        $criteria->addAscendingOrderByColumn(SkillVersionTableMap::COL_VERSION);

        return $this->getSkillVersions($criteria, $con);
    }
1160029
protected function doInsert(ConnectionInterface $con)
    {
        $modifiedColumns = array();
        $index = 0;


         // check the columns in natural order for more readable SQL queries
        if ($this->isColumnModified(DealerShedulesVersionTableMap::ID)) {
            $modifiedColumns[':p' . $index++]  = 'ID';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::DEALER_ID)) {
            $modifiedColumns[':p' . $index++]  = 'DEALER_ID';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::DAY)) {
            $modifiedColumns[':p' . $index++]  = 'DAY';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::BEGIN)) {
            $modifiedColumns[':p' . $index++]  = 'BEGIN';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::END)) {
            $modifiedColumns[':p' . $index++]  = 'END';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::CLOSED)) {
            $modifiedColumns[':p' . $index++]  = 'CLOSED';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::PERIOD_BEGIN)) {
            $modifiedColumns[':p' . $index++]  = 'PERIOD_BEGIN';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::PERIOD_END)) {
            $modifiedColumns[':p' . $index++]  = 'PERIOD_END';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::CREATED_AT)) {
            $modifiedColumns[':p' . $index++]  = 'CREATED_AT';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::UPDATED_AT)) {
            $modifiedColumns[':p' . $index++]  = 'UPDATED_AT';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::VERSION)) {
            $modifiedColumns[':p' . $index++]  = 'VERSION';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::VERSION_CREATED_AT)) {
            $modifiedColumns[':p' . $index++]  = 'VERSION_CREATED_AT';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::VERSION_CREATED_BY)) {
            $modifiedColumns[':p' . $index++]  = 'VERSION_CREATED_BY';
        }
        if ($this->isColumnModified(DealerShedulesVersionTableMap::DEALER_ID_VERSION)) {
            $modifiedColumns[':p' . $index++]  = 'DEALER_ID_VERSION';
        }

        $sql = sprintf(
            'INSERT INTO dealer_shedules_version (%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 'DEALER_ID':
                        $stmt->bindValue($identifier, $this->dealer_id, PDO::PARAM_INT);
                        break;
                    case 'DAY':
                        $stmt->bindValue($identifier, $this->day, PDO::PARAM_INT);
                        break;
                    case 'BEGIN':
                        $stmt->bindValue($identifier, $this->begin ? $this->begin->format("Y-m-d H:i:s") : null, PDO::PARAM_STR);
                        break;
                    case 'END':
                        $stmt->bindValue($identifier, $this->end ? $this->end->format("Y-m-d H:i:s") : null, PDO::PARAM_STR);
                        break;
                    case 'CLOSED':
                        $stmt->bindValue($identifier, (int) $this->closed, PDO::PARAM_INT);
                        break;
                    case 'PERIOD_BEGIN':
                        $stmt->bindValue($identifier, $this->period_begin ? $this->period_begin->format("Y-m-d H:i:s") : null, PDO::PARAM_STR);
                        break;
                    case 'PERIOD_END':
                        $stmt->bindValue($identifier, $this->period_end ? $this->period_end->format("Y-m-d H:i:s") : null, 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;
                    case 'VERSION':
                        $stmt->bindValue($identifier, $this->version, PDO::PARAM_INT);
                        break;
                    case 'VERSION_CREATED_AT':
                        $stmt->bindValue($identifier, $this->version_created_at ? $this->version_created_at->format("Y-m-d H:i:s") : null, PDO::PARAM_STR);
                        break;
                    case 'VERSION_CREATED_BY':
                        $stmt->bindValue($identifier, $this->version_created_by, PDO::PARAM_STR);
                        break;
                    case 'DEALER_ID_VERSION':
                        $stmt->bindValue($identifier, $this->dealer_id_version, 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);
        }

        $this->setNew(false);
    }
1174416
public function getAllVersions($con = null)
    {
        $criteria = new Criteria();
        $criteria->addAscendingOrderByColumn(DealerAdminVersionTableMap::VERSION);

        return $this->getDealerAdminVersions($criteria, $con);
    }
178830
public function getPrevSibling(ConnectionInterface $con = null)
    {
        return ChildCategoryQuery::create()
            ->filterByTreeRight($this->getLeftValue() - 1)
            ->findOne($con);
    }
723876
public function addVersion($con = null)
    {
        $this->enforceVersion = false;

        $version = new ChildDealerContactInfoVersion();
        $version->setId($this->getId());
        $version->setContactId($this->getContactId());
        $version->setContactType($this->getContactType());
        $version->setCreatedAt($this->getCreatedAt());
        $version->setUpdatedAt($this->getUpdatedAt());
        $version->setVersion($this->getVersion());
        $version->setVersionCreatedAt($this->getVersionCreatedAt());
        $version->setVersionCreatedBy($this->getVersionCreatedBy());
        $version->setDealerContactInfo($this);
        if (($related = $this->getDealerContact($con)) && $related->getVersion()) {
            $version->setContactIdVersion($related->getVersion());
        }
        $version->save($con);

        return $version;
    }
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;
    }
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;
    }
207912
public function getLastVersionNumber($con = null)
    {
        $v = ChildDealerVersionQuery::create()
            ->filterByDealer($this)
            ->orderByVersion('desc')
            ->findOne($con);
        if (!$v) {
            return 0;
        }

        return $v->getVersion();
    }
1196426
public function getAllVersions($con = null)
    {
        $criteria = new Criteria();
        $criteria->addAscendingOrderByColumn(DealerShedulesVersionTableMap::VERSION);

        return $this->getDealerShedulesVersions($criteria, $con);
    }
370440
public function getSource(ConnectionInterface $con = null)
    {
        if ($this->aSource === null && ($this->source_id != 0)) {
            $this->aSource = ChildSourceQuery::create()->findPk($this->source_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->aSource->addPages($this);
             */
        }

        return $this->aSource;
    }
1054141
public function getOneVersion($versionNumber, $con = null)
    {
        return ChildIndexEngineIndexVersionQuery::create()
            ->filterByIndexEngineIndex($this)
            ->filterByVersion($versionNumber)
            ->findOne($con);
    }
1179412
public function getOneVersion($versionNumber, $con = null)
    {
        return ChildDealerFolderVersionQuery::create()
            ->filterByDealerFolder($this)
            ->filterByVersion($versionNumber)
            ->findOne($con);
    }
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;
    }
846738
protected function updateRelatedObjectSkillCount(ConnectionInterface $con)
    {
        if ($object = $this->getObject()) {
            $object->updateSkillCount($con);
        }
        if ($this->oldObjectSkillCount) {
            $this->oldObjectSkillCount->updateSkillCount($con);
            $this->oldObjectSkillCount = null;
        }
    }
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;
    }
720261
public function getOneVersion($versionNumber, $con = null)
    {
        return ChildDealerAdminVersionQuery::create()
            ->filterByDealerAdmin($this)
            ->filterByVersion($versionNumber)
            ->findOne($con);
    }
91195
public function getSmartyFilter(ConnectionInterface $con = null)
    {
        if ($this->aSmartyFilter === null && ($this->id !== null)) {
            $this->aSmartyFilter = ChildSmartyFilterQuery::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->aSmartyFilter->addSmartyFilterI18ns($this);
             */
        }

        return $this->aSmartyFilter;
    }