Hallo,
ich bin gerade dabei eine Klasse zu programmieren mit der ein ein SQL Statement zusammenbasteln kann.
Bislang sieht das ganze so aus.
Der Aufruf sieht beispielsweise so aus.
Ich habe mir in letzter Zeit angewöhnt das ich immer erst alle Daten sammel und dann verarbeite. In diesem Falle wäre es meiner Meinung nach "einfacher" wenn ich bei jeden Methodenaufruf ein String erweitere.
Was ist eure Meinung nach sauberer? Erst Daten sammeln und dann verarbeiten oder sofort Daten verarbeiten?
ich bin gerade dabei eine Klasse zu programmieren mit der ein ein SQL Statement zusammenbasteln kann.
Bislang sieht das ganze so aus.
PHP-Code:
final class SQLAssembler
{
/**
*
*
* @var <array>
*/
private $arrTables = array();
/**
*
*
* @var <array>
*/
private $arrJoinTables = array();
/**
*
*
* @var <array>
*/
private $arrFields = array();
/**
*
* @var <array>
*/
private $arrJoins = array();
/**
*
*
* @var <array>
*/
private $arrWhereConditions = array();
/**
*
*
* @var <array>
*/
private $arrOrderByConditions = array();
/**
*
*
* @var <array>
*/
private $arrGroupByConditions = array();
/**
*
*
* @var <array>
*/
private $arrBlocks = array();
/**
*
*
* @var <array>
*/
private $arrConnectors = array();
/**
*
*
* @var <integer>
*/
private $intElementsCount = 0;
public function __get($strKey)
{
$blnSuccess = false;
switch ($strKey)
{
case 'or':
case 'xor':
case 'and':
$this->arrConnectors[$this->intElementsCount + 1] = mb_strtoupper($strKey);
$blnSuccess = true;
break;
case 'blockStart':
$this->arrBlocks[$this->intElementsCount + 1] = '(';
$blnSuccess = true;
break;
case 'blockEnd':
$this->arrBlocks[$this->intElementsCount + 1] = ')';
$blnSuccess = true;
break;
}
if ($blnSuccess === true)
{
++$this->intElementsCount;
}
return ($this);
}
/**
*
*
* @param <string> $strTableName Tabellenname
* @param <string|optional> $strAliasName Tabellenalias
*
* @return <object>
*/
public function addTable($strTableName, $strAliasName = null)
{
$strTable = '';
if (!empty($strTableName) &&
is_string($strTableName))
{
$strTable = '`' . $strTableName . '`';
}
if (!empty($strTable) &&
!empty($strAliasName) &&
is_string($strAliasName))
{
$strTable .= ' AS `' . $strAliasName . '`';
}
if (!empty($strTable))
{
$this->arrTables[] = $strTable;
}
return ($this);
}
/**
*
*
* @param <string> $strFieldName Feldname
* @param <string|optional> $strFieldAlias Feldalias
* @param <string|optional> $strFieldFunction Funktionsname
* @param <string|optional> $strFieldFunctionArguments Funktionsargumente
*
* @return <object>
*/
public function addField($strFieldName, $strFieldAlias = null, $strFieldFunction = null, $strFieldFunctionArguments = null)
{
$strField = '';
if (empty($strFieldFunction))
{
$strField = '`' . $strFieldName . '`';
}
else if (!empty($strFieldFunction))
{
$arrValidFunctions = array
(
'DATE_FORMAT'
);
}
if (!empty($strField) &&
!empty($strFieldAlias))
{
$strField .= ' AS `' . $strFieldAlias . '`';
}
if (!empty($strField))
{
$this->arrFields[] = $strField;
}
return ($this);
}
public function addWhere($strField, $strCondition, $mixValue)
{
$this->arrWhereConditions[$this->intElementsCount + 1] = '`' . $strField . '` ' . $strCondition . ' ' . $mixValue;
++$this->intElementsCount;
return ($this);
}
/**
*
*
* @param <string> $strOrderByName Feldname
* @param <string|optional> $strOrderBySort Sortierreihenfolge
*
* @return <object>
*/
public function addOrderBy($strOrderByName, $strOrderBySort = 'desc')
{
$strOrderBy = '';
if (!empty($strOrderByName) &&
is_string($strOrderByName))
{
$strOrderBy = '`' . $strOrderByName . '`';
}
if (!empty($strOrderBy) &&
!empty($strOrderBySort) &&
in_array($strOrderBySort, array('asc', 'desc')))
{
$strOrderBy .= ' ' . mb_strtoupper($strOrderBySort);
}
if (!empty($strOrderBy))
{
$this->arrOrderByConditions[] = $strOrderBy;
}
return ($this);
}
/**
*
*
* @param <sring> $strGroupByName Feldname
*
* @return <object>
*/
public function addGroupBy($strGroupByName)
{
$strGroupBy = '';
if (!empty($strGroupByName) &&
is_string($strGroupByName))
{
$strGroupBy = '`' . $strGroupByName . '`';
}
if (!empty($strGroupBy))
{
$this->arrGroupByConditions[] = $strGroupBy;
}
return ($this);
}
private function generateStatement()
{
$strTables = implode(', ', $this->arrTables);
$strFields = implode(', ', $this->arrFields);
$strWhere = '';
$arrWhereKeys = array_merge(array_keys($this->arrWhereConditions), array_keys($this->arrBlocks), array_keys($this->arrConnectors));
$arrWhereValues = array_merge($this->arrWhereConditions, $this->arrBlocks, $this->arrConnectors);
$arrWhereCondition = array_combine($arrWhereKeys, $arrWhereValues);
ksort($arrWhereCondition);
$strWhere = implode(' ', $arrWhereCondition);
$strGroupBy = implode(', ', $this->arrGroupByConditions);
$strOrderBy = implode(', ', $this->arrOrderByConditions);
$strQuery = $strFields . ' FROM ' . $strTables;
if (!empty($strWhere))
{
$strQuery .= ' WHERE ' . $strWhere;
}
if (!empty($strGroupBy))
{
$strQuery .= ' GROUP BY ' . $strGroupBy;
}
if (!empty($strOrderBy))
{
$strQuery .= ' ORDER BY ' . $strOrderBy;
}
return ($strQuery);
}
public function getQuery($blnForceGenerate = false)
{
static $strStatement;
if (empty($strStatement) ||
$blnForceGenerate === true)
{
$strStatement = $this->generateStatement();
}
return ($strStatement);
}
}
PHP-Code:
$SQLAssembler = new SQLAssembler();
$SQLAssembler ->addField('Id')
->addField('Title', 'NewTitle')
->addTable('tabelle1', 'tabelleas1')
->addTable('tabelle2')
->addWhere('Id', '=', 5)
->and
->blockStart
->blockStart
->addWhere('Name', '!=', 'name1')
->or
->addWhere('Name', '!=', 'name2')
->blockEnd
->xor
->blockStart
->addWhere('Name', '!=', 'name3')
->or
->addWhere('Name', '!=', 'name4')
->blockEnd
->blockEnd
->addGroupBy('Id')
->addOrderBy('Name', 'asc')
->addOrderBy('Id', 'desc');
Was ist eure Meinung nach sauberer? Erst Daten sammeln und dann verarbeiten oder sofort Daten verarbeiten?
Kommentar