oxdbmetadatahandler.php

Go to the documentation of this file.

<?php

class oxDbMetaDataHandler extends oxSuperCfg
{

    protected $_aDbTablesFields = null;


    protected $_aTables = null;

    protected $_iCurrentMaxLangId;

    protected $_aSkipTablesOnReset = array("oxcountry");

    protected $aForceOriginalFields = array('OXID');

    public function getFields($sTableName)
    {
        $aFields = array();
        $aRawFields = oxDb::getDb()->MetaColumns($sTableName);
        if (is_array($aRawFields)) {
            foreach ($aRawFields as $oField) {
                $aFields[$oField->name] = "{$sTableName}.{$oField->name}";
            }
        }

        return $aFields;
    }

    public function tableExists($sTableName)
    {
        $oDb = oxDb::getDb();
        $aTables = $oDb->getAll("show tables like " . $oDb->quote($sTableName));

        return count($aTables) > 0;
    }

    public function fieldExists($sFieldName, $sTableName)
    {
        $aTableFields = $this->getFields($sTableName);
        $sTableName = strtoupper($sTableName);
        if (is_array($aTableFields)) {
            $sFieldName = strtoupper($sFieldName);
            $aTableFields = array_map('strtoupper', $aTableFields);
            if (in_array("{$sTableName}.{$sFieldName}", $aTableFields)) {
                return true;
            }
        }

        return false;
    }


    public function getAllTables()
    {
        if (empty($this->_aTables)) {

            $aTables = oxDb::getDb()->getAll("show tables");

            foreach ($aTables as $aTableInfo) {
                $sTableName = $aTableInfo[0];

                $this->_aTables[] = $aTableInfo[0];
            }
        }

        return $this->_aTables;
    }

    public function getAllMultiTables($sTable)
    {
        $aMLTables = array();
        foreach (array_keys(oxRegistry::getLang()->getLanguageIds()) as $iLangId) {
            $sLangTableName = getLangTableName($sTable, $iLangId);
            if ($sTable != $sLangTableName && !in_array($sLangTableName, $aMLTables)) {
                $aMLTables[] = $sLangTableName;
            }
        }

        return $aMLTables;
    }

    protected function _getCreateTableSetSql($sTable, $iLang)
    {
        $sTableSet = getLangTableName($sTable, $iLang);

        $aRes = oxDb::getDb()->getAll("show create table {$sTable}");
        $sSql = "CREATE TABLE `{$sTableSet}` (" .
                "`OXID` char(32) COLLATE latin1_general_ci NOT NULL, " .
                "PRIMARY KEY (`OXID`)" .
                ") " . strstr($aRes[0][1], 'ENGINE=');

        return $sSql;
    }

    public function getAddFieldSql($sTable, $sField, $sNewField, $sPrevField, $sTableSet = null)
    {
        if (!$sTableSet) {
            $sTableSet = $sTable;
        }
        $aRes = oxDb::getDb()->getAll("show create table {$sTable}");
        $sTableSql = $aRes[0][1];

        // removing comments;
        $sTableSql = preg_replace('/COMMENT \\\'.*?\\\'/', '', $sTableSql);
        preg_match("/.*,\s+(['`]?" . preg_quote($sField, '/') . "['`]?\s+[^,]+),.*/", $sTableSql, $aMatch);
        $sFieldSql = $aMatch[1];

        $sSql = "";
        if (!empty($sFieldSql)) {
            $sFieldSql = preg_replace("/" . preg_quote($sField, '/') . "/", $sNewField, $sFieldSql);
            $sSql = "ALTER TABLE `$sTableSet` ADD " . $sFieldSql;
            if ($this->tableExists($sTableSet) && $this->fieldExists($sPrevField, $sTableSet)) {
                $sSql .= " AFTER `$sPrevField`";
            }
        }

        return $sSql;
    }


    public function getAddFieldIndexSql($sTable, $sField, $sNewField, $sTableSet = null)
    {
        $aRes = oxDb::getDb()->getAll("show create table {$sTable}");

        $sTableSql = $aRes[0][1];

        preg_match_all("/([\w]+\s+)?\bKEY\s+(`[^`]+`)?\s*\([^)]+\)/iU", $sTableSql, $aMatch);
        $aIndex = $aMatch[0];

        $blUsingTableSet = $sTableSet ? true : false;

        if (!$sTableSet) {
            $sTableSet = $sTable;
        }

        $aIndexSql = array();
        $aSql = array();
        if (count($aIndex)) {
            foreach ($aIndex as $sIndexSql) {
                if (preg_match("/\([^)]*\b" . $sField . "\b[^)]*\)/i", $sIndexSql)) {

                    //removing index name - new will be added automaticly
                    $sIndexSql = preg_replace("/(.*\bKEY\s+)`[^`]+`/", "$1", $sIndexSql);

                    if ($blUsingTableSet) {
                        // replacing multiple fields to one (#3269)
                        $sIndexSql = preg_replace("/\([^\)]+\)/", "(`$sNewField`)", $sIndexSql);
                    } else {
                        //replacing previous field name with new one
                        $sIndexSql = preg_replace("/\b" . $sField . "\b/", $sNewField, $sIndexSql);
                    }

                    $aIndexSql[] = "ADD " . $sIndexSql;
                }
            }
            if (count($aIndexSql)) {
                $aSql = array("ALTER TABLE `$sTableSet` " . implode(", ", $aIndexSql));
            }
        }

        return $aSql;
    }

    public function getCurrentMaxLangId()
    {
        if (isset($this->_iCurrentMaxLangId)) {
            return $this->_iCurrentMaxLangId;
        }

        $sTable = $sTableSet = "oxarticles";
        $sField = $sFieldSet = "oxtitle";
        $iLang = 0;
        while ($this->tableExists($sTableSet) && $this->fieldExists($sFieldSet, $sTableSet)) {
            $iLang++;
            $sTableSet = getLangTableName($sTable, $iLang);
            $sFieldSet = $sField . '_' . $iLang;
        }

        $this->_iCurrentMaxLangId = --$iLang;

        return $this->_iCurrentMaxLangId;
    }

    public function getNextLangId()
    {
        return $this->getCurrentMaxLangId() + 1;
    }

    public function getMultilangFields($sTable)
    {
        $aFields = $this->getFields($sTable);
        $aMultiLangFields = array();

        foreach ($aFields as $sField) {
            if (preg_match("/({$sTable}\.)?(?<field>.+)_1$/", $sField, $aMatches)) {
                $aMultiLangFields[] = $aMatches['field'];
            }
        }

        return $aMultiLangFields;
    }

    public function getSinglelangFields($sTable, $iLang)
    {
        $sLangTable = getLangTableName($sTable, $iLang);

        $aBaseFields = $this->getFields($sTable);
        $aLangFields = $this->getFields($sLangTable);

        //Some fields (for example OXID) must be taken from core table.
        $aLangFields = $this->filterCoreFields($aLangFields);

        $aFields = array_merge($aBaseFields, $aLangFields);
        $aSingleLangFields = array();

        foreach ($aFields as $sFieldName => $sField) {
            if (preg_match("/(({$sTable}|{$sLangTable})\.)?(?<field>.+)_(?<lang>[0-9]+)$/", $sField, $aMatches)) {
                if ($aMatches['lang'] == $iLang) {
                    $aSingleLangFields[$aMatches['field']] = $sField;
                }
            } else {
                $aSingleLangFields[$sFieldName] = $sField;
            }
        }

        return $aSingleLangFields;
    }

    public function addNewMultilangField($sTable)
    {
        $iNewLang = $this->getNextLangId();
        $this->ensureMultiLanguageFields($sTable, $iNewLang);
    }

    public function resetMultilangFields($iLangId, $sTableName)
    {
        $iLangId = (int) $iLangId;

        if ($iLangId === 0) {
            return;
        }

        $aSql = array();

        $aFields = $this->getMultilangFields($sTableName);
        if (is_array($aFields) && count($aFields) > 0) {
            foreach ($aFields as $sFieldName) {
                $sFieldName = $sFieldName . "_" . $iLangId;

                if ($this->fieldExists($sFieldName, $sTableName)) {
                    //resetting field value to default
                    $aSql[] = "UPDATE {$sTableName} SET {$sFieldName} = DEFAULT;";
                }
            }
        }

        if (!empty($aSql)) {
            $this->executeSql($aSql);
        }
    }

    public function addNewLangToDb()
    {
        //reset max count
        $this->_iCurrentMaxLangId = null;

        $aTable = $this->getAllTables();

        foreach ($aTable as $sTableName) {
            $this->addNewMultilangField($sTableName);
        }

        //updating views
        $this->updateViews();
    }

    public function resetLanguage($iLangId)
    {
        if ((int) $iLangId === 0) {
            return;
        }

        $aTables = $this->getAllTables();

        // removing tables which does not requires reset
        foreach ($this->_aSkipTablesOnReset as $sSkipTable) {

            if (($iSkipId = array_search($sSkipTable, $aTables)) !== false) {
                unset($aTables[$iSkipId]);
            }
        }

        foreach ($aTables as $sTableName) {
            $this->resetMultilangFields($iLangId, $sTableName);
        }
    }

    public function executeSql($aSql)
    {
        $oDb = oxDb::getDb();

        if (is_array($aSql) && !empty($aSql)) {
            foreach ($aSql as $sSql) {
                $sSql = trim($sSql);
                if (!empty($sSql)) {
                    $oDb->execute($sSql);
                }
            }
        }
    }

    public function updateViews($aTables = null)
    {
        set_time_limit(0);

        $oDb = oxDb::getDb();
        $oConfig = oxRegistry::getConfig();

        $this->safeGuardAdditionalMultiLanguageTables();

        $aShops = $oDb->getAll("select * from oxshops");

        $aTables = $aTables ? $aTables : $oConfig->getConfigParam('aMultiShopTables');

        $bSuccess = true;
        foreach ($aShops as $aShop) {
            $sShopId = $aShop[0];
            $oShop = oxNew('oxshop');
            $oShop->load($sShopId);
            $oShop->setMultiShopTables($aTables);
            $aMallInherit = array();
            foreach ($aTables as $sTable) {
                $aMallInherit[$sTable] = $oConfig->getShopConfVar('blMallInherit_' . $sTable, $sShopId);
            }
            if (!$oShop->generateViews(false, $aMallInherit) && $bSuccess) {
                $bSuccess = false;
            }
        }

        return $bSuccess;
    }

    protected function filterCoreFields($aFields)
    {
        foreach ($this->aForceOriginalFields as $aFieldname) {
            if (array_key_exists($aFieldname, $aFields)) {
                unset($aFields[$aFieldname]);
            }
        }
        return $aFields;
    }

    protected function safeGuardAdditionalMultiLanguageTables()
    {
        $iMaxLang = $this->getCurrentMaxLangId();
        $aMultiLanguageTables = $this->getConfig()->getConfigParam('aMultiLangTables');

        if (!is_array($aMultiLanguageTables) || empty($aMultiLanguageTables)) {
            return; //nothing to do
        }

        foreach ($aMultiLanguageTables as $sTable) {
            if ($this->tableExists($sTable)) {
                //We start with language id 1 and rely on that all fields for language 0 exists.
                //For language id 0 we have e.g. OXTITLE and logic here would expect it to
                //be OXTITLE_0, add that as new field, leading to incorrect data in views later on.
                for ($i=1;$i<=$iMaxLang;$i++) {
                    $this->ensureMultiLanguageFields($sTable, $i);
                }
            }
        }
    }

    protected function ensureMultiLanguageFields($sTable, $iLanguageId)
    {
        $aFields = $this->getMultilangFields($sTable);

        $sTableSet = getLangTableName($sTable, $iLanguageId);
        if (!$this->tableExists($sTableSet)) {
            $aSql[] = $this->_getCreateTableSetSql($sTable, $iLanguageId);
        }

        if (is_array($aFields) && count($aFields) > 0) {
            foreach ($aFields as $sField) {
                $sNewFieldName = $sField . "_" . $iLanguageId;
                if ($iLanguageId > 1) {
                    $iPrevLang = $iLanguageId - 1;
                    $sPrevField = $sField . '_' . $iPrevLang;
                } else {
                    $sPrevField = $sField;
                }

                if (!$this->tableExists($sTableSet) || !$this->fieldExists($sNewFieldName, $sTableSet)) {

                    //getting add field sql
                    $aSql[] = $this->getAddFieldSql($sTable, $sField, $sNewFieldName, $sPrevField, $sTableSet);

                    //getting add index sql on added field
                    $aSql = array_merge($aSql, (array) $this->getAddFieldIndexSql($sTable, $sField, $sNewFieldName, $sTableSet));
                }
            }
        }

        $this->executeSql($aSql);
    }
}