oxbase.php

Go to the documentation of this file.

<?php

DEFINE('ACTION_NA', 0);
DEFINE('ACTION_DELETE', 1);
DEFINE('ACTION_INSERT', 2);
DEFINE('ACTION_UPDATE', 3);
DEFINE('ACTION_UPDATE_STOCK', 4);

class oxBase extends oxSuperCfg
{

    protected $_sOXID = null;

    protected $_iShopId = null;

    protected $_blIsSimplyClonable = true;

    protected $_sClassName = 'oxbase';

    protected $_sCoreTable = null;

    protected $_sViewTable = null;


    protected $_aFieldNames = array('oxid' => 0);

    protected $_sCacheKey = null;

    protected $_blUseLazyLoading = false;

    protected $_aSkipSaveFields = array('oxtimestamp');

    protected $_blUseSkipSaveFields = true;

    protected $_sExistKey = 'oxid';

    protected $_blIsDerived = null;

    protected static $_blDisableFieldCaching = array();

    protected $_blIsSeoObject = false;

    protected $_blUpdateSeo = true;

    protected $_blReadOnly = false;

    protected $_blIsInList = false;

    protected $_isLoaded = false;

    protected $_aInnerLazyCache = null;

    protected $_blEmployMultilanguage = false;


    public function getUseSkipSaveFields()
    {
        return $this->_blUseSkipSaveFields;
    }

    public function setUseSkipSaveFields($blUseSkipSaveFields)
    {
        $this->_blUseSkipSaveFields = $blUseSkipSaveFields;
    }

    public function __construct()
    {
        // set active shop
        $myConfig = $this->getConfig();
        $this->_sCacheKey = $this->getViewName();

        $this->_addSkippedSaveFieldsForMapping();
        $this->_disableLazyLoadingForCaching();

        if ($this->_blUseLazyLoading) {
            $this->_sCacheKey .= $myConfig->getActiveView()->getClassName();
        } else {
            $this->_sCacheKey .= 'allviews';
        }

        //do not cache for admin?
        if ($this->isAdmin()) {
            $this->_sCacheKey = null;
        }

        $this->setShopId($myConfig->getShopId());
    }

    public function __set($sName, $sValue)
    {
        $this->$sName = $sValue;
        if ($this->_blUseLazyLoading && strpos($sName, $this->_sCoreTable . '__') === 0) {
            $sFieldName = str_replace($this->_sCoreTable . "__", '', $sName);
            if ($sFieldName != 'oxnid' && (!isset($this->_aFieldNames[$sFieldName]) || !$this->_aFieldNames[$sFieldName])) {
                $aAllFields = $this->_getAllFields(true);
                if (isset($aAllFields[strtolower($sFieldName)])) {
                    $iFieldStatus = $this->_getFieldStatus($sFieldName);
                    $this->_addField($sFieldName, $iFieldStatus);
                }
            }
        }
    }

    public function __get($sName)
    {
        switch ($sName) {
            case 'blIsDerived':
                return $this->isDerived();
                break;
            case 'sOXID':
                return $this->getId();
                break;
            case 'blReadOnly':
                return $this->isReadOnly();
                break;
        }

        // implementing lazy loading fields
        // This part of the code is slow and normally is called before field cache is built.
        // Make sure it is not called after first page is loaded and cache data is fully built.
        if ($this->_blUseLazyLoading && stripos($sName, $this->_sCoreTable . "__") === 0) {

            if ($this->getId()) {

                //lazy load it
                $sFieldName = str_replace($this->_sCoreTable . '__', '', $sName);
                $sCacheFieldName = strtoupper($sFieldName);

                $iFieldStatus = $this->_getFieldStatus($sFieldName);
                $sViewName = $this->getViewName();
                $sId = $this->getId();

                try {
                    if ($this->_aInnerLazyCache === null) {

                        $oDb = oxDb::getDb(oxDb::FETCH_MODE_ASSOC);
                        $sQ = 'SELECT * FROM ' . $sViewName . ' WHERE `oxid` = ' . $oDb->quote($sId);
                        $rs = $oDb->select($sQ);
                        if ($rs && $rs->RecordCount()) {
                            $this->_aInnerLazyCache = array_change_key_case($rs->fields, CASE_UPPER);
                            if (array_key_exists($sCacheFieldName, $this->_aInnerLazyCache)) {
                                $sFieldValue = $this->_aInnerLazyCache[$sCacheFieldName];
                            } else {
                                return null;
                            }
                        } else {
                            return null;
                        }
                    } elseif (array_key_exists($sCacheFieldName, $this->_aInnerLazyCache)) {
                        $sFieldValue = $this->_aInnerLazyCache[$sCacheFieldName];
                    } else {
                        return null;
                    }

                    $this->_addField($sFieldName, $iFieldStatus);
                    $this->_setFieldData($sFieldName, $sFieldValue);

                    //save names to cache for next loading
                    if ($this->_sCacheKey) {
                        $myUtils = oxRegistry::getUtils();
                        $sCacheKey = 'fieldnames_' . $this->_sCoreTable . '_' . $this->_sCacheKey;
                        $aFieldNames = $myUtils->fromFileCache($sCacheKey);
                        $aFieldNames[$sFieldName] = $iFieldStatus;
                        $myUtils->toFileCache($sCacheKey, $aFieldNames);
                    }
                } catch (Exception $e) {
                    return null;
                }

                //do not use field cache for this page
                //as if we use it for lists then objects are loaded empty instead of lazy loading.
                self::$_blDisableFieldCaching[get_class($this)] = true;
            }

            oxUtilsObject::getInstance()->resetInstanceCache(get_class($this));
        }

        //returns stdClass implementing __toString() method due to uknown scenario where this var should be used.
        if (!isset($this->$sName)) {
            $this->$sName = null;
        }

        return $this->$sName;
    }

    public function __isset($mVar)
    {
        return isset($this->$mVar);
    }

    public function __clone()
    {
        if (!$this->_blIsSimplyClonable) {
            foreach ($this->_aFieldNames as $sField => $sVal) {
                $sLongName = $this->_getFieldLongName($sField);
                if (is_object($this->$sLongName)) {
                    $this->$sLongName = clone $this->$sLongName;
                }
            }
        }
    }

    public function oxClone($oObject)
    {
        $aClasVars = get_object_vars($oObject);
        while (list($name, $value) = each($aClasVars)) {
            if (is_object($oObject->$name)) {
                $this->$name = clone $oObject->$name;
            } else {
                $this->$name = $oObject->$name;
            }
        }
    }

    public function getUpdateSeo()
    {
        return $this->_blUpdateSeo;
    }

    public function setUpdateSeo($blUpdateSeo)
    {
        $this->_blUpdateSeo = $blUpdateSeo;
    }

    protected function _setUpdateSeoOnFieldChange($sField)
    {
        if ($this->getId() && in_array($sField, $this->getFieldNames())) {
            $oDb = oxDb::getDb();
            $sTableName = $this->getCoreTableName();
            $sQuotedOxid = $oDb->quote($this->getId());
            $sTitle = $oDb->getOne("select `{$sField}` from `{$sTableName}` where `oxid` = {$sQuotedOxid}");
            $sFieldValue = "{$sTableName}__{$sField}";
            $sCurrentTitle = $this->$sFieldValue->value;

            if ($sTitle == $sCurrentTitle) {
                $this->setUpdateSeo(false);
            }
        }
    }

    public function init($sTableName = null, $blForceAllFields = false)
    {
        if ($sTableName) {
            $this->_sCoreTable = $sTableName;
        }

        // reset view table
        $this->_sViewTable = false;

        if (count($this->_aFieldNames) <= 1) {
            $this->_initDataStructure($blForceAllFields);
        }
    }

    public function assign($dbRecord)
    {
        if (!is_array($dbRecord)) {
            return;
        }


        reset($dbRecord);
        while (list($sName, $sValue) = each($dbRecord)) {

            // patch for IIS
            //TODO: test it on IIS do we still need it
            //if( is_array($value) && count( $value) == 1)
            //    $value = current( $value);

            $this->_setFieldData($sName, $sValue);
        }

        $sOxidField = $this->_getFieldLongName('oxid');
        $this->_sOXID = $this->$sOxidField->value;

    }

    public function getClassName()
    {
        return $this->_sClassName;
    }

    public function getCoreTableName()
    {
        return $this->_sCoreTable;
    }

    public function getId()
    {
        return $this->_sOXID;
    }

    public function setId($sOXID = null)
    {
        if ($sOXID) {
            $this->_sOXID = $sOXID;
        } else {
            if ($this->getCoreTableName() == 'oxobject2category') {
                $sObjectId = $this->oxobject2category__oxobjectid;
                $sCatId = $this->oxobject2category__oxcatnid;
                $sShopID = $this->oxobject2category__oxshopid;
                $this->_sOXID = md5($sObjectId . $sCatId . $sShopID);
            } else {
                $this->_sOXID = oxUtilsObject::getInstance()->generateUID();
            }
        }

        $sIdVarName = $this->getCoreTableName() . '__oxid';
        $this->$sIdVarName = new oxField($this->_sOXID, oxField::T_RAW);

        return $this->_sOXID;
    }

    public function setShopId($iShopId)
    {
        $this->_iShopId = $iShopId;
    }

    public function getShopId()
    {
        return $this->_iShopId;
    }

    public function getViewName($blForceCoreTableUsage = null)
    {
        if (!$this->_sViewTable || ($blForceCoreTableUsage !== null)) {
            if ($blForceCoreTableUsage === true) {
                return $this->getCoreTableName();
            }


            if (($blForceCoreTableUsage !== null) && $blForceCoreTableUsage) {
                $iShopId = -1;
            } else {
                $iShopId = oxRegistry::getConfig()->getShopId();
            }

            $sViewName = getViewName($this->getCoreTableName(), $this->_blEmployMultilanguage == false ? -1 : $this->getLanguage(), $iShopId);
            if ($blForceCoreTableUsage !== null) {
                return $sViewName;
            }
            $this->_sViewTable = $sViewName;
        }

        return $this->_sViewTable;
    }

    public function modifyCacheKey($sCacheKey, $blOverride = false)
    {
        if ($blOverride) {
            $this->_sCacheKey = $sCacheKey;
        } else {
            $this->_sCacheKey .= $sCacheKey;
        }
    }

    public function disableLazyLoading()
    {
        $this->_blUseLazyLoading = false;
        $this->_initDataStructure(true);
    }


    public function isDerived()
    {

        return $this->_blIsDerived;
    }

    public function setIsDerived($blVal)
    {
        $this->_blIsDerived = $blVal;
    }

    public function isMultilang()
    {
        return false;
    }

    public function load($sOXID)
    {

        //getting at least one field before lazy loading the object
        $this->_addField('oxid', 0);
        $sSelect = $this->buildSelectString(array($this->getViewName() . '.oxid' => $sOXID));
        $this->_isLoaded = $this->assignRecord($sSelect);


        return $this->_isLoaded;
    }


    public function isLoaded()
    {
        return $this->_isLoaded;
    }

    public function buildSelectString($aWhere = null)
    {
        $oDB = oxDb::getDb();

        $sGet = $this->getSelectFields();
        $sSelect = "select $sGet from " . $this->getViewName() . ' where 1 ';

        if ($aWhere) {
            reset($aWhere);
            while (list($name, $value) = each($aWhere)) {
                $sSelect .= ' and ' . $name . ' = ' . $oDB->quote($value);
            }
        }

        // add active shop

        return $sSelect;
    }

    public function assignRecord($sSelect)
    {
        $blRet = false;

        $rs = oxDb::getDb(oxDb::FETCH_MODE_ASSOC)->select($sSelect);

        if ($rs != false && $rs->recordCount() > 0) {
            $blRet = true;
            $this->assign($rs->fields);
        }

        return $blRet;
    }

    public function getFieldData($sFieldName)
    {
        $sLongFieldName = $this->_getFieldLongName($sFieldName);

        return $this->$sLongFieldName->value;
    }

    public function getSelectFields($blForceCoreTableUsage = null)
    {
        $aSelectFields = array();

        $sViewName = $this->getViewName($blForceCoreTableUsage);

        foreach ($this->_aFieldNames as $sKey => $sField) {
            if ($sViewName) {
                $aSelectFields[] = "`$sViewName`.`$sKey`";
            } else {
                $aSelectFields[] = ".`$sKey`";
            }

        }

        $sSelectFields = join(', ', $aSelectFields);

        return $sSelectFields;
    }

    public function delete($sOxId = null)
    {
        if (!$sOxId) {
            $sOxId = $this->getId();

            //do not allow derived deletion
            if (!$this->allowDerivedDelete()) {
                return false;
            }
        }

        if (!$sOxId) {
            return false;
        }


        $this->_removeElement2ShopRelations($sOxId);

        $oDB = oxDb::getDb(oxDb::FETCH_MODE_ASSOC);
        $sCoreTable = $this->getCoreTableName();
        $sDelete = "delete from {$sCoreTable} where oxid = " . $oDB->quote($sOxId);
        $oDB->execute($sDelete);
        if ($blDelete = (bool) $oDB->affected_Rows()) {
            $this->onChange(ACTION_DELETE, $sOxId);
        }

        return $blDelete;
    }

    protected function _removeElement2ShopRelations($sOxId)
    {
    }


    public function save()
    {
        if (!is_array($this->_aFieldNames)) {
            return false;
        }

        // #739A - should be executed here because of date/time formatting feature
        if ($this->isAdmin() && !$this->getConfig()->getConfigParam('blSkipFormatConversion')) {
            foreach ($this->_aFieldNames as $sName => $sVal) {
                $sLongName = $this->_getFieldLongName($sName);
                if (isset($this->$sLongName->fldtype) && $this->$sLongName->fldtype == 'datetime') {
                    oxRegistry::get('oxUtilsDate')->convertDBDateTime($this->$sLongName, true);
                } elseif (isset($this->$sLongName->fldtype) && $this->$sLongName->fldtype == 'timestamp') {
                    oxRegistry::get('oxUtilsDate')->convertDBTimestamp($this->$sLongName, true);
                } elseif (isset($this->$sLongName->fldtype) && $this->$sLongName->fldtype == 'date') {
                    oxRegistry::get('oxUtilsDate')->convertDBDate($this->$sLongName, true);
                }
            }
        }

        if ($this->exists()) {
            //do not allow derived update
            if (!$this->allowDerivedUpdate()) {
                return false;
            }

            $blRet = $this->_update();
            $sAction = ACTION_UPDATE;
        } else {
            $blRet = $this->_insert();
            $sAction = ACTION_INSERT;
        }

        $this->onChange($sAction);

        if ($blRet) {
            return $this->getId();
        } else {
            return false;
        }
    }

    public function allowDerivedUpdate()
    {
        return !$this->isDerived();
    }

    public function allowDerivedDelete()
    {
        return !$this->isDerived();
    }

    public function exists($sOXID = null)
    {
        if (!$sOXID) {
            $sOXID = $this->getId();
        }
        if (!$sOXID) {
            return false;
        }

        $sViewName = $this->getCoreTableName();
        $oDb = oxDb::getDb(oxDb::FETCH_MODE_ASSOC);
        $sSelect = "select {$this->_sExistKey} from {$sViewName} where {$this->_sExistKey} = " . $oDb->quote($sOXID);

        return ( bool ) $oDb->getOne($sSelect, false, false);
    }

    public function getSqlActiveSnippet($blForceCoreTable = null)
    {
        $sQ = '';
        $sTable = $this->getViewName($blForceCoreTable);

        // has 'active' field ?
        if (isset($this->_aFieldNames['oxactive'])) {
            $sQ = " $sTable.oxactive = 1 ";
        }

        // has 'activefrom'/'activeto' fields ?
        if (isset($this->_aFieldNames['oxactivefrom']) && isset($this->_aFieldNames['oxactiveto'])) {

            $sDate = date('Y-m-d H:i:s', oxRegistry::get('oxUtilsDate')->getTime());

            $sQ = $sQ ? " $sQ or " : '';
            $sQ = " ( $sQ ( $sTable.oxactivefrom < '$sDate' and $sTable.oxactiveto > '$sDate' ) ) ";
        }

        return $sQ;
    }

    public function beforeUpdate($sOXID = null)
    {
    }

    public function onChange($iAction = null, $sOXID = null)
    {
    }


    public function setInList()
    {
        $this->_blIsInList = true;
    }

    protected function _isInList()
    {
        return $this->_blIsInList;
    }

    protected function _getObjectViewName($sTable, $sShopID = null)
    {

        return getViewName($sTable, -1, $sShopID);
    }


    protected function _getTableFields($sTable, $blReturnSimple = false)
    {
        $myUtils = oxRegistry::getUtils();

        $sCacheKey = $sTable . '_allfields_' . $blReturnSimple;
        $aMetaFields = $myUtils->fromFileCache($sCacheKey);

        if ($aMetaFields) {
            return $aMetaFields;
        }

        $aMetaFields = oxDb::getInstance()->getTableDescription($sTable);

        if (!$blReturnSimple) {
            $myUtils->toFileCache($sCacheKey, $aMetaFields);

            return $aMetaFields;
        }

        //returning simple array
        $aRet = array();
        if (is_array($aMetaFields)) {
            foreach ($aMetaFields as $oVal) {
                $aRet[strtolower($oVal->name)] = 0;
            }
        }

        $myUtils->toFileCache($sCacheKey, $aRet);

        return $aRet;
    }

    protected function _getAllFields($blReturnSimple = false)
    {
        if (!$this->getCoreTableName()) {
            return array();
        }

        return $this->_getTableFields($this->getCoreTableName(), $blReturnSimple);
    }

    protected function _initDataStructure($blForceFullStructure = false)
    {
        $myUtils = oxRegistry::getUtils();

        //get field names from cache
        $aFieldNames = null;
        $sFullCacheKey = 'fieldnames_' . $this->getCoreTableName() . '_' . $this->_sCacheKey;
        if ($this->_sCacheKey && !$this->_isDisabledFieldCache()) {
            $aFieldNames = $myUtils->fromFileCache($sFullCacheKey);
        }

        if (!$aFieldNames) {
            $aFieldNames = $this->_getNonCachedFieldNames($blForceFullStructure);
            if ($this->_sCacheKey && !$this->_isDisabledFieldCache()) {
                $myUtils->toFileCache($sFullCacheKey, $aFieldNames);
            }
        }

        if ($aFieldNames !== false) {
            foreach ($aFieldNames as $sField => $sStatus) {
                $this->_addField($sField, $sStatus);
            }
        }
    }

    protected function _getNonCachedFieldNames($blForceFullStructure = false)
    {
        //T2008-02-22
        //so if this method is executed on cached version we see it when profiling
        startProfile('!__CACHABLE__!');

        //case 1. (admin)
        if ($this->isAdmin()) {
            $aMetaFields = $this->_getAllFields();
            foreach ($aMetaFields as $oField) {
                if ($oField->max_length == -1) {
                    $oField->max_length = 10; // double or float
                }

                if ($oField->type == 'datetime') {
                    $oField->max_length = 20;
                }

                $this->_addField($oField->name, $this->_getFieldStatus($oField->name), $oField->type, $oField->max_length);
            }
            stopProfile('!__CACHABLE__!');

            return false;
        }

        //case 2. (just get all fields)
        if ($blForceFullStructure || !$this->_blUseLazyLoading) {
            $aMetaFields = $this->_getAllFields(true);
            /*
            foreach ( $aMetaFields as $sFieldName => $sVal) {
                $this->_addField( $sFieldName, $this->_getFieldStatus($sFieldName));
            }*/
            stopProfile('!__CACHABLE__!');

            return $aMetaFields;
        }

        //case 3. (get only oxid field, so we can fetch the rest of the fields over lazy loading mechanism)
        stopProfile('!__CACHABLE__!');

        return array('oxid' => 0);
    }

    protected function _getFieldStatus($sFieldName)
    {
        return 0;
    }

    protected function _addField($sName, $iStatus, $sType = null, $sLength = null)
    {
        //preparation
        $sName = strtolower($sName);

        //adding field names element
        $this->_aFieldNames[$sName] = $iStatus;

        //already set?
        $sLongName = $this->_getFieldLongName($sName);
        if (isset($this->$sLongName)) {
            return;
        }

        //defining the field
        $oField = false;

        if (isset($sType)) {
            $oField = new oxField();
            $oField->fldtype = $sType;
            //T2008-01-29
            //can't clone as the fields are objects and are not fully cloned
            $this->_blIsSimplyClonable = false;
        }

        if (isset($sLength)) {
            if (!$oField) {
                $oField = new oxField();
            }
            $oField->fldmax_length = $sLength;
            $this->_blIsSimplyClonable = false;
        }

        $this->$sLongName = $oField;
    }

    protected function _getFieldLongName($sFieldName)
    {
        //trying to avoid strpos call as often as possible
        $sCoreTableName = $this->getCoreTableName();
        if ($sFieldName[2] == $sCoreTableName[2] && strpos($sFieldName, $sCoreTableName . '__') === 0) {
            return $sFieldName;
        }

        return $sCoreTableName . '__' . strtolower($sFieldName);
    }

    protected function _setFieldData($sFieldName, $sValue, $iDataType = oxField::T_TEXT)
    {

        $sLongFieldName = $this->_getFieldLongName($sFieldName);
        //$sLongFieldName = $this->_sCoreTable . "__" . strtolower($sFieldName);

        //T2008-03-14
        //doing this because in lazy loaded lists on first load it is harmful to have initialised fields but not yet set
        //situation: only first article is loaded fully for "select oxid from oxarticles"
        /*
        if ($this->_blUseLazyLoading && !isset($this->$sLongFieldName))
            return;*/

        //in non lazy loading case we just add a field and do not care about it more
        if (!$this->_blUseLazyLoading && !isset($this->$sLongFieldName)) {
            $aFields = $this->_getAllFields(true);
            if (isset($aFields[strtolower($sFieldName)])) {
                $this->_addField($sFieldName, $this->_getFieldStatus($sFieldName));
            }
        }
        // if we have a double field we replace "," with "." in case somebody enters it in european format
        if (isset($this->$sLongFieldName) && isset($this->$sLongFieldName->fldtype) && $this->$sLongFieldName->fldtype == 'double') {
            $sValue = str_replace(',', '.', $sValue);
        }

        // isset is REQUIRED here not to use getter
        if (isset($this->$sLongFieldName) && is_object($this->$sLongFieldName)) {
            $this->$sLongFieldName->setValue($sValue, $iDataType);
        } else {
            $this->$sLongFieldName = new oxField($sValue, $iDataType);
        }

    }

    protected function _canFieldBeNull($sFieldName)
    {
        $aMetaData = $this->_getAllFields();
        foreach ($aMetaData as $oMetaInfo) {
            if (strcasecmp($oMetaInfo->name, $sFieldName) == 0) {
                return !$oMetaInfo->not_null;
            }
        }

        return false;
    }

    protected function _getFieldDefaultValue($sFieldName)
    {
        $aMetaData = $this->_getAllFields();
        foreach ($aMetaData as $oMetaInfo) {
            if (strcasecmp($oMetaInfo->name, $sFieldName) == 0) {
                return $oMetaInfo->default_value;
            }
        }

        return false;
    }

    protected function _getUpdateFieldValue($sFieldName, $oField)
    {
        $mValue = null;
        if ($oField instanceof oxField) {
            $mValue = $oField->getRawValue();
        } elseif (isset($oField->value)) {
            $mValue = $oField->value;
        }

        $oDb = oxDb::getDb();
        //Check if this field value is null AND it can be null according if not returning default value
        if ((null === $mValue)) {
            if ($this->_canFieldBeNull($sFieldName)) {
                return 'null';
            } elseif ($mValue = $this->_getFieldDefaultValue($sFieldName)) {
                return $oDb->quote($mValue);
            }
        }

        return $oDb->quote($mValue);
    }

    protected function _getUpdateFields($blUseSkipSaveFields = true)
    {
        $sSql = '';
        $blSep = false;

        foreach (array_keys($this->_aFieldNames) as $sKey) {
            $sLongName = $this->_getFieldLongName($sKey);
            $oField = $this->$sLongName;


            if (!$blUseSkipSaveFields || ($blUseSkipSaveFields && !in_array(strtolower($sKey), $this->_aSkipSaveFields))) {
                $sSql .= (($blSep) ? ',' : '') . $sKey . ' = ' . $this->_getUpdateFieldValue($sKey, $oField);
                $blSep = true;
            }
        }

        return $sSql;
    }

    protected function _update()
    {
        //do not allow derived item update
        if (!$this->allowDerivedUpdate()) {
            return false;
        }


        if (!$this->getId()) {
            $oEx = oxNew('oxObjectException');
            $oEx->setMessage('EXCEPTION_OBJECT_OXIDNOTSET');
            $oEx->setObject($this);
            throw $oEx;
        }
        $sCoreTableName = $this->getCoreTableName();

        $sIDKey = oxRegistry::getUtils()->getArrFldName($sCoreTableName . '.oxid');
        $this->$sIDKey = new oxField($this->getId(), oxField::T_RAW);
        $oDb = oxDb::getDb();

        $sUpdate = "update {$sCoreTableName} set " . $this->_getUpdateFields()
                   . " where {$sCoreTableName}.oxid = " . $oDb->quote($this->getId());

        //trigger event
        $this->beforeUpdate();

        $blRet = (bool) $oDb->execute($sUpdate);

        return $blRet;
    }

    protected function _insert()
    {

        $oDb = oxDb::getDb(oxDb::FETCH_MODE_ASSOC);
        $myConfig = $this->getConfig();
        $myUtils = oxRegistry::getUtils();

        // let's get a new ID
        if (!$this->getId()) {
            $this->setId();
        }

        $sIDKey = $myUtils->getArrFldName($this->getCoreTableName() . '.oxid');
        $this->$sIDKey = new oxField($this->getId(), oxField::T_RAW);
        $sInsert = "Insert into {$this->getCoreTableName()} set ";

        //setting oxshopid
        $sShopField = $myUtils->getArrFldName($this->getCoreTableName() . '.oxshopid');

        if (isset($this->$sShopField) && !$this->$sShopField->value) {
            $this->$sShopField = new oxField($myConfig->getShopId(), oxField::T_RAW);
        }

        $sInsert .= $this->_getUpdateFields($this->getUseSkipSaveFields());

        $blRet = (bool) $oDb->execute($sInsert);


        return $blRet;
    }


    protected function _isDisabledFieldCache()
    {
        $sClass = get_class($this);
        if (isset(self::$_blDisableFieldCaching[$sClass]) && self::$_blDisableFieldCaching[$sClass]) {
            return true;
        }

        return false;
    }

    protected function _addSkippedSaveFieldsForMapping()
    {
    }

    protected function _disableLazyLoadingForCaching()
    {
    }

    public function isOx()
    {
        $sOxId = $this->getId();
        if ($sOxId[0] == 'o' && $sOxId[1] == 'x') {
            return true;
        }

        return false;
    }

    public function isReadOnly()
    {
        return $this->_blReadOnly;
    }

    public function setReadOnly($blReadOnly)
    {
        $this->_blReadOnly = $blReadOnly;
    }

    public function getFieldNames()
    {
        return array_keys($this->_aFieldNames);
    }

    public function addFieldName($sName)
    {
        //preparation
        $sName = strtolower($sName);
        $this->_aFieldNames[$sName] = 0;
    }

    public function getLanguage()
    {
        return -1;
    }

}