AbstractCompiler.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Dbal\Database\SqlCompilers;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use TYPO3\CMS\Dbal\Database\DatabaseConnection;

abstract class AbstractCompiler
{
    protected $databaseConnection;

    public function __construct(DatabaseConnection $databaseConnection)
    {
        $this->databaseConnection = $databaseConnection;
    }

    public function compileSQL($components)
    {
        $query = '';
        switch ($components['type']) {
            case 'SELECT':
                $query = $this->compileSELECT($components);
                break;
            case 'UPDATE':
                $query = $this->compileUPDATE($components);
                break;
            case 'INSERT':
                $query = $this->compileINSERT($components);
                break;
            case 'DELETE':
                $query = $this->compileDELETE($components);
                break;
            case 'EXPLAIN':
                $query = 'EXPLAIN ' . $this->compileSELECT($components);
                break;
            case 'DROPTABLE':
                $query = 'DROP TABLE' . ($components['ifExists'] ? ' IF EXISTS' : '') . ' ' . $components['TABLE'];
                break;
            case 'CREATETABLE':
                $query = $this->compileCREATETABLE($components);
                break;
            case 'ALTERTABLE':
                $query = $this->compileALTERTABLE($components);
                break;
            case 'TRUNCATETABLE':
                $query = $this->compileTRUNCATETABLE($components);
                break;
        }
        return $query;
    }

    protected function compileSELECT($components)
    {
        // Initialize:
        $where = $this->compileWhereClause($components['WHERE']);
        $groupBy = $this->compileFieldList($components['GROUPBY']);
        $orderBy = $this->compileFieldList($components['ORDERBY']);
        $limit = $components['LIMIT'];
        // Make query:
        $query = 'SELECT ' . ($components['STRAIGHT_JOIN'] ?: '') . ' ' .
            $this->compileFieldList($components['SELECT']) .
            ' FROM ' . $this->compileFromTables($components['FROM']) . ($where !== '' ?
                ' WHERE ' . $where : '') . ($groupBy !== '' ?
                ' GROUP BY ' . $groupBy : '') . ($orderBy !== '' ?
                ' ORDER BY ' . $orderBy : '') . ((string)$limit !== '' ?
                ' LIMIT ' . $limit : '');
        return $query;
    }

    protected function compileUPDATE($components)
    {
        // Where clause:
        $where = $this->compileWhereClause($components['WHERE']);
        // Fields
        $fields = [];
        foreach ($components['FIELDS'] as $fN => $fV) {
            $fields[] = $fN . '=' . $fV[1] . $this->compileAddslashes($fV[0]) . $fV[1];
        }
        // Make query:
        $query = 'UPDATE ' . $components['TABLE'] . ' SET ' . implode(',', $fields) .
            ($where !== '' ? ' WHERE ' . $where : '');

        return $query;
    }

    abstract protected function compileINSERT($components);

    protected function compileDELETE($components)
    {
        // Where clause:
        $where = $this->compileWhereClause($components['WHERE']);
        // Make query:
        $query = 'DELETE FROM ' . $components['TABLE'] . ($where !== '' ? ' WHERE ' . $where : '');

        return $query;
    }

    abstract protected function compileCREATETABLE($components);

    abstract protected function compileALTERTABLE($components);

    protected function compileTRUNCATETABLE(array $components)
    {
        // Make query:
        $query = 'TRUNCATE TABLE ' . $components['TABLE'];
        // Return query
        return $query;
    }

    abstract public function compileFieldList($selectFields, $compileComments = true, $functionMapping = true);

    abstract public function compileWhereClause($clauseArray, $functionMapping = true);

    abstract protected function compileAddslashes($str);

    protected function compileJoinIdentifier($identifierParts)
    {
        if ($identifierParts['type'] === 'cast') {
            return sprintf('CAST(%s AS %s)',
                $identifierParts['table'] ? $identifierParts['table'] . '.' . $identifierParts['field'] : $identifierParts['field'],
                $identifierParts['datatype'][0]
            );
        } else {
            return $identifierParts['table'] ? $identifierParts['table'] . '.' . $identifierParts['field'] : $identifierParts['field'];
        }
    }

    public function compileFromTables($tablesArray)
    {
        // Prepare buffer variable:
        $outputParts = [];
        // Traverse the table names:
        if (is_array($tablesArray)) {
            foreach ($tablesArray as $k => $v) {
                // Set table name:
                $outputParts[$k] = $v['table'];
                // Add alias AS if there:
                if ($v['as']) {
                    $outputParts[$k] .= ' ' . $v['as_keyword'] . ' ' . $v['as'];
                }
                if (is_array($v['JOIN'])) {
                    foreach ($v['JOIN'] as $join) {
                        $outputParts[$k] .= ' ' . $join['type'] . ' ' . $join['withTable'];
                        // Add alias AS if there:
                        if (isset($join['as']) && $join['as']) {
                            $outputParts[$k] .= ' ' . $join['as_keyword'] . ' ' . $join['as'];
                        }
                        $outputParts[$k] .= ' ON ';
                        foreach ($join['ON'] as $condition) {
                            if ($condition['operator'] !== '') {
                                $outputParts[$k] .= ' ' . $condition['operator'] . ' ';
                            }
                            $outputParts[$k] .= $this->compileJoinIdentifier($condition['left']);
                            $outputParts[$k] .= $condition['comparator'];
                            if (!empty($condition['right']['value'])) {
                                $value = $condition['right']['value'];
                                $outputParts[$k] .= $value[1] . $this->compileAddslashes($value[0]) . $value[1];
                            } else {
                                $outputParts[$k] .= $this->compileJoinIdentifier($condition['right']);
                            }
                        }
                    }
                }
            }
        }
        // Return imploded buffer:
        return implode(', ', $outputParts);
    }

    protected function compileCaseStatement(array $components, $functionMapping = true)
    {
        $statement = 'CASE';
        if (isset($components['case_field'])) {
            $statement .= ' ' . $components['case_field'];
        } elseif (isset($components['case_value'])) {
            $statement .= ' ' . $components['case_value'][1] . $components['case_value'][0] . $components['case_value'][1];
        }
        foreach ($components['when'] as $when) {
            $statement .= ' WHEN ';
            $statement .= $this->compileWhereClause($when['when_value'], $functionMapping);
            $statement .= ' THEN ';
            $statement .= $when['then_value'][1] . $when['then_value'][0] . $when['then_value'][1];
        }
        if (isset($components['else'])) {
            $statement .= ' ELSE ';
            $statement .= $components['else'][1] . $components['else'][0] . $components['else'][1];
        }
        $statement .= ' END';
        return $statement;
    }
}