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 $_aErrors = array();

    protected $_sClassName = 'oxbase';

    protected $_sCoreTable = null;

    protected $_sCoreTbl = null;

    protected $_sViewTable  = null;


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

    protected $_blIsNewCache = false;

    protected $_sCacheKey = null;

    protected $_blUseLazyLoading = false;

    protected $_aSkipSaveFields = array();

    protected $_sExistKey = "oxid";

    protected $_blIsDerived = null;

    protected static $_blDisableFieldCaching = array();

    protected $_blIsSeoObject = false;

    protected $_blReadOnly = false;

    protected $_blIsInList = false;

    protected $_isLoaded = false;

    protected $_aInnerLazyCache = null;

    protected $_blEmployMultilanguage = false;

    public function __construct()
    {
        // set active shop
        $myConfig = $this->getConfig();
        $this->_sCacheKey = $this->getViewName();
        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 = oxUtils::getInstance();
                        $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 oxStdClass 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 init( $sTableName = null, $blForceAllFields = false)
    {

        if ( !$sTableName ) {
            $sTableName = $this->_sCoreTable;
        } else {
            $this->_sCoreTable = $sTableName;
        }

        // compatibility due to parameter deprecation
        $this->_sCoreTbl = $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 {
            $this->_sOXID = oxUtilsObject::getInstance()->generateUID();
        }

        $sIdVarName = $this->_sCoreTable . "__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->_sCoreTable;
            }


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


            $sViewName = getViewName( $this->_sCoreTable, $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)
    {
        /*
        if( !isset($oxID)){
            $oEx = oxNew('oxObjectException','core');
            $oEx->setMessage('EXCEPTION_OBJECT_OXIDNOTSET');
            $oEx->setObject($this);
            throw $oEx;
        }*/

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

        return $this->_isLoaded = $this->assignRecord( $sSelect );
    }

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

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

        $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 ) {
            $aSelectFields[] = $sViewName . '.' . $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;
        }


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

        return $blDelete;
    }


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

        $blRet = 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" ) {
                    oxDb::getInstance()->convertDBDateTime( $this->$sLongName, true );
                } elseif ( isset($this->$sLongName->fldtype) && $this->$sLongName->fldtype == "timestamp" ) {
                    oxDb::getInstance()->convertDBTimestamp( $this->$sLongName, true);
                } elseif ( isset($this->$sLongName->fldtype) && $this->$sLongName->fldtype == "date" ) {
                    oxDb::getInstance()->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 );
    }

    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', oxUtilsDate::getInstance()->getTime() );

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

        return $sQ;
    }

    public function validate()
    {
        $this->_aErrors = array();
        foreach ($this->_aFieldNames as $fName => $iVal) {

            $fName = $this->_getFieldLongName($fName);

            if ( method_exists ( $this, "validate_$fName")) {
                $validatorMethod = "validate_$fName";
                if ( $error = $this->$validatorMethod()) {
                    $this->_aErrors[$fName] = $error;
                }
            }
        }
        return !$this->hasErrors();
    }

    public function beforeUpdate( $sOXID = null )
    {
    }

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


    public function hasErrors()
    {
        return count($this->_aErrors) > 0;
    }

    public function getErrors()
    {
        return $this->_aErrors;
    }

    public function getError( $sField)
    {
        if (isset($this->_aErrors[$sField])) {
            return $this->_aErrors[$sField];
        }

        //T2007-10-19
        //return array();
        return null;
    }

    public function getHtmlError( $sField)
    {
        if ( $error = $this->getError($sField) ) {
            return $error;
        }
    }

    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 = oxUtils::getInstance();

        $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->_sCoreTable) {
            return array();
        }
        return $this->_getTableFields($this->_sCoreTable, $blReturnSimple);
    }

    protected function _initDataStructure($blForceFullStructure = false)
    {
        $myUtils = oxUtils::getInstance();

        //get field names from cache
        $aFieldNames = null;
        $sFullCacheKey = 'fieldnames_' .$this->_sCoreTable . "_" . $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;

        //allready 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
        if ( $sFieldName[2] == $this->_sCoreTable[2] && strpos( $sFieldName, $this->_sCoreTable . "__" ) === 0 ) {
            return $sFieldName;
        }

        return $this->_sCoreTable . "__" . 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 initilised 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;
        }

        $sIDKey = oxUtils::getInstance()->getArrFldName( $this->_sCoreTable.".oxid");
        $this->$sIDKey = new oxField($this->getId(), oxField::T_RAW);
        $oDb = oxDb::getDb();

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

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

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

        return $blRet;
    }

    protected function _insert()
    {

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

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

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

        //setting oxshopid
        $sShopField = $myUtils->getArrFldName($this->_sCoreTable.".oxshopid");

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


        $sInsert .= $this->_getUpdateFields( false );
        $blRet = (bool) $oDb->execute( $sInsert);

        $this->_rebuildCache();

        return $blRet;

    }

    protected function _rebuildCache()
    {
        if ( !$this->_blIsNewCache) {
            oxUtils::getInstance()->rebuildCache();
            $this->_blIsNewCache = true;
        }
    }

    protected function _setRecordNumber( $sMaxField, $aWhere = null, $iMaxTryCnt = 5 )
    {
        // filtering
        $sWhere = "";
        if ( is_array( $aWhere ) && count( $aWhere ) > 0) {
            $sWhere = implode(" and ", $aWhere).' and ';
        }
        $oDb = oxDb::getDb( oxDb::FETCH_MODE_ASSOC );

        // SQL to set record number
        $sUpdate = "update {$this->getViewName()} as t1, (select (max($sMaxField)+1) as t2max from {$this->getViewName()} where $sWhere 1) as t2 set t1.$sMaxField=t2.t2max where t1.oxid = ".$oDb->quote( $this->getId() );

        // SQL to check record number dublicates
        //this should not happen normally but we prefer to take extra care in this case due to parallel script execution etc.
        $sMaxSelect = "select $sMaxField from ".$this->getViewName()." where oxid=".$oDb->quote( $this->getId() );
        $sCheck = "select count(oxid) from ".$this->getViewName()." where $sMaxField = ($sMaxSelect) and $sWhere 1 ";

        do {
            if ( $oDb->execute( $sUpdate ) === false ) {
                return false;
            }

            $iChkCnt = $oDb->getOne( $sCheck );
        } while ( ( $iChkCnt > 1 ) && $iMaxTryCnt-- );

        $sFieldName = $this->getViewName().'__'.$sMaxField;
        $this->$sFieldName = new oxField( $oDb->getOne( $sMaxSelect ), oxField::T_RAW);//int value

        return ( $iChkCnt == 1 );
    }

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

        return false;
    }

    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;
    }
}