DALQueryParser.inc

<?php
require_once 'DAL/Exceptions/DALParserException.inc';
require_once 'DAL/Parsers/DALSelectParser.inc';
require_once 'DAL/Parsers/DALFromParser.inc';
require_once 'DAL/Parsers/DALAlterParser.inc';
require_once 'DAL/Parsers/DALSchemaParser.inc';
require_once 'DAL/Parsers/DALWithParser.inc';
require_once 'DAL/Parsers/DALDeleteParser.inc';
require_once 'DAL/Parsers/DALDropParser.inc';
require_once 'DAL/Parsers/DALInsertParser.inc';
require_once 'DAL/Parsers/DALUpdateParser.inc';
require_once 'DAL/Parsers/DALWhereParser.inc';
require_once 'DAL/Parsers/DALGroupByParser.inc';
require_once 'DAL/Parsers/DALOrderByParser.inc';
require_once 'DAL/Parsers/DALTruncateParser.inc';
require_once 'DAL/Parsers/DALUnionParser.inc';
require_once 'DAL/DALBaker.inc';
require_once 'XML/XML.inc';

class DALQueryParser
{


    private function __construct()
    {

    }//end __construct()


    public static function parse(DomElement $query)
    {
        $firstChild = $query->firstChild;
        if ($firstChild === NULL) {
            throw new DALParserException('Invalid query element.');
        }

        foreach ($query->childNodes as $childNode) {
            if ($childNode->nodeType === XML_ELEMENT_NODE) {
                $type = $childNode->tagName;
                break;
            }
        }

        $sqlArray = array();

        switch ($type) {
            case 'select' :
                DALSelectParser::validate($query);
                $sql = DALSelectParser::parse($query);
            break;
            case 'insert' :
                DALInsertParser::validate($query);
                $sql = DALInsertParser::parse($query);
            break;
            case 'update' :
                DALUpdateParser::validate($query);
                $sql = DALUpdateParser::parse($query);
            break;
            case 'delete' :
                DALDeleteParser::validate($query);
                $sql = DALDeleteParser::parse($query);
            break;
            case 'truncate' :
                DALTruncateParser::validate($query);
                $sql = DALTruncateParser::parse($query);
            break;
            case 'union' :
            case 'union-all' :
                DALUnionParser::validate($query);
                $sql = DALUnionParser::parse($query);
            break;
            case 'alter' :
                DALAlterParser::validate($query);
                $sql = DALAlterParser::parse($query);
            break;
            case 'drop' :
                DALDropParser::validate($query);
                $sql = DALDropParser::parse($query);
            break;
            case 'function' :
                $function = $query->getElementsByTagName('function')->item(0);
                self::validateFunctionTag($function);
                $sql = self::parseSqlFunction($function);
            break;
            case 'with' :
                DALWithParser::validate($query);
                $sql = DALWithParser::parse($query);
            break;
            case 'call' :
                $sql = self::parseCallQuery($query);
            break;
            case 'where' :
                $sql = DALWhereParser::parse($query);
                $sql = current($sql);
            break;
            case 'from' :
                $sql = DALFromParser::parse($query);
            break;

            default:
                throw new DALParserException('Invalid query type:'.$type);
            break;
        }//end switch

        // Add Query type.
        if (is_array($sql) === TRUE) {
            $sqlArray['query'] = $sql;
            $aliases           = array();
            self::_convertAliases($sqlArray['query'], $aliases);
            $sqlArray['query_type'] = $type;
        }

        return $sqlArray;

    }//end parse()


    private static function _convertAliases(array &$sqlArray, array &$aliases)
    {
        $vars = array();
        foreach ($sqlArray as $key => $value) {
            if (is_array($value) === FALSE) {
                continue;
            }

            if (isset($value['alias']) === TRUE) {
                $clonedArray = array();
                $clonedArray = array_merge($clonedArray, $sqlArray);
                unset($clonedArray[$key]['alias']);
                $aliases[$value['alias']] = $clonedArray;
            }

            if (array_key_exists('isalias', $value) === TRUE) {
                $sqlArray[$key] = $aliases[$value['name']];
            }

            if (is_array($value) === TRUE) {
                self::_convertAliases($sqlArray[$key], $aliases);
            }
        }

    }//end _convertAliases()


    protected static function parseLimitClause(DomElement $select)
    {
        $query = array();
        $limit = $select->getElementsByTagName('limit')->item(0);
        if ($limit !== NULL) {
            $query['LIMIT']           = array();
            $query['LIMIT']['rows']   = $limit->nodeValue;
            $query['LIMIT']['offset'] = $limit->getAttribute('offset');
        }

        return $query;

    }//end parseLimitClause()


    protected static function parseInClause(DomElement $inCond, $level=0)
    {
        $conditions = array();
        if ($inCond !== NULL) {
            $type = strtoupper($inCond->tagName);

            $conditions[$type]               = array();
            $conditions[$type]['table']      = $inCond->getAttribute('table');
            $conditions[$type]['column']     = $inCond->getAttribute('column');
            $conditions[$type]['CONDITIONS'] = array();

            // Check if this IN statement is using inner select.
            $select = $inCond->getElementsByTagName('select')->item(0);
            if ($select === NULL) {
                // Must be using values.
                // There could be a single value with no value tag.
                if (XML::hasChildElements($inCond) === FALSE) {
                    $conditions[$type]['CONDITIONS'][] = $inCond->nodeValue;
                } else {
                    foreach ($inCond->childNodes as $child) {
                        if ($child->nodeType === XML_ELEMENT_NODE) {
                            $val = self::parseSingleField($child);
                            // Add field value to the list.
                            $conditions[$type]['CONDITIONS'][] = $val;
                        }
                    }
                }
            } else {
                // Inner Select.
                $conditions[$type]['CONDITIONS'] = DALSelectParser::parse($select);
            }
        }//end if

        return $conditions;

    }//end parseInClause()


    protected static function parseExistsClause(DomElement $existsCond, $level=0)
    {
        $conditions = array();
        if ($existsCond !== NULL) {
            $type   = strtoupper($existsCond->tagName);
            $select = $existsCond->getElementsByTagName('select')->item(0);

            if ($select !== NULL) {
                // Parse the inner select for this exists clause...
                $conditions[$type] = array(
                                      'CONDITIONS' => DALSelectParser::parse($select),
                                     );
            }
        }

        return $conditions;

    }//end parseExistsClause()


    public static function parseCallQuery(DomElement $call)
    {
        $query         = array();
        $query['CALL'] = array();

        // Get the function tag.
        $function      = $call->getElementsByTagName('function')->item(0);
        $query['CALL'] = self::parseSqlFunction($function);

        return $query;

    }//end parseCallQuery()


    protected static function parseChildFields(DomElement $parent)
    {
        $fields = array();
        foreach ($parent->childNodes as $field) {
            if ($field->nodeType !== XML_ELEMENT_NODE) {
                continue;
            }

            $newField = self::parseSingleField($field);
            if ($newField !== FALSE) {
                $fields[] = $newField;
            }
        }//end foreach

        return $fields;

    }//end parseChildFields()


    protected static function parseSingleField(DomElement $fieldXML)
    {
        $field = FALSE;
        if ($fieldXML->tagName === 'field') {
            $field           = array();
            $field['table']  = $fieldXML->getAttribute('table');
            $field['column'] = $fieldXML->getAttribute('column');
            if ($fieldXML->nodeValue !== '') {
                $field['alias'] = $fieldXML->nodeValue;
            }
        } else if ($fieldXML->tagName === 'value') {
            $nodeValue = $fieldXML->nodeValue;
            if ($fieldXML->getAttribute('type') === 'integer') {
                $nodeValue = (int)$nodeValue;
            }

            if ($fieldXML->getAttribute('alias') === '') {
                $field = $nodeValue;
            } else {
                $field          = array();
                $field['alias'] = $fieldXML->getAttribute('alias');
                $field['value'] = $nodeValue;
            }
        } else if ($fieldXML->tagName === 'alias') {
            $field            = array();
            $field['name']    = $fieldXML->getAttribute('name');
            $field['isalias'] = TRUE;
        } else if ($fieldXML->tagName === 'literal') {
            $field = $fieldXML->nodeValue;
        } else if ($fieldXML->tagName === 'function') {
            $field = self::parseSqlFunction($fieldXML);
        } else if ($fieldXML->tagName === 'hook') {
            $field = DALBaker::getHookPrefix().$fieldXML->getAttribute('id');
        } else if ($fieldXML->tagName === 'math-op') {
            $field = self::parseMathOperation($fieldXML);
        } else if ($fieldXML->tagName === 'select') {
            $field = DALSelectParser::parse($fieldXML);
        }//end if

        return $field;

    }//end parseSingleField()


    protected static function parseMathOperation(DomElement $parent, $op='MATH-OP')
    {
        $query      = array();
        $query[$op] = array();
        if (($op === 'MATH-OP') && ($parent->getAttribute('alias') !== '')) {
            $query[$op]['alias'] = $parent->getAttribute('alias');
        }

        foreach ($parent->childNodes as $node) {
            if ($node->nodeType === XML_ELEMENT_NODE) {
                switch ($node->tagName) {
                    case 'add'     :
                    case 'divide'  :
                    case 'subtract':
                    case 'multiply':
                        $query[$op][] = self::parseMathOperation($node, strtoupper($node->tagName));
                    break;
                    default :
                        if ($node->tagName === 'select') {
                            $query[$op][] = DALSelectParser::parse($node);
                        } else {
                            $query[$op][] = self::parseSingleField($node);
                        }
                }
            }
        }

        return $query;

    }//end parseMathOperation()


    protected static function parseSqlFunction(DomElement $function)
    {
        $query = array();
        if ($function !== NULL) {
            $query['FUNCTION']             = array();
            $query['FUNCTION']['function'] = $function->getAttribute('function');
            $query['FUNCTION']['ARGS']     = array();

            if ($function->getAttribute('alias') !== '') {
                $query['FUNCTION']['alias'] = $function->getAttribute('alias');
            }

            foreach ($function->childNodes as $arg) {
                if ($arg->nodeType === XML_ELEMENT_NODE) {
                    $field = XML::getFirstChildElement($arg);
                    if ($field !== NULL) {
                        switch ($field->tagName) {
                            case 'select':
                                    $query['FUNCTION']['ARGS'][] = DALSelectParser::parse($field);
                            break;

                            default:
                                $fields                      = self::parseChildFields($arg);
                                $query['FUNCTION']['ARGS'][] = array_shift($fields);

                        }
                    } else {
                        $query['FUNCTION']['ARGS'][] = $arg->nodeValue;
                    }
                }
            }
        }//end if

        return $query;

    }//end parseSqlFunction()


    public static function validateField(DomElement $field, $allowAlias=FALSE)
    {
        // Field must have table and column attribute.
        if ($field->hasAttribute('table') === FALSE) {
            throw new DALParserException('field tag must have table attr.');
        } else if ($field->getAttribute('column') === '') {
            throw new DALParserException('field tag must have column attr.');
        } else if (($allowAlias === FALSE) && ($field->nodeValue !== '')) {
            $msg = 'alias for field is not allowed here.';
            throw new DALParserException($msg);
        }

    }//end validateField()


    protected static function validateFieldsTag(DomElement $fields)
    {
        // Fields tag must have table attribute.
        if ($fields->getAttribute('table') === FALSE) {
            $msg = 'Fields tag must have table attribute.';
            throw new DALParserException($msg);
        }

        // Make sure fields tag have field tags with values.
        $fields = $fields->getElementsByTagName('field');
        if ($fields->length === 0) {
            $msg = 'Fields tag with no field tags.';
            throw new DALParserException($msg);
        }

        // Field tags must have values.
        foreach ($fields as $field) {
            if ($field->nodeValue === '') {
                $msg = 'Field with no value.';
                throw new DALParserException($msg);
            }
        }

    }//end validateFieldsTag()


    public static function validateValuesTag(DomElement $valuesTag)
    {
        $foundValue = FALSE;
        foreach ($valuesTag->childNodes as $value) {
            if ($value->nodeType === XML_ELEMENT_NODE) {
                if ($value->tagName === 'value') {
                    $foundValue = TRUE;
                    self::validateValueTag($value);
                } else if ($value->tagName === 'select') {
                    $foundValue = TRUE;
                    DALSelectParser::validate($valuesTag);
                }
            }
        }

        if ($foundValue === FALSE) {
            $msg = 'Values tag with no value/select tags.';
            throw new DALParserException($msg);
        }

    }//end validateValuesTag()


    protected static function validateValueTag(DomElement $value)
    {
        if ($value->getAttribute('column') === '') {
            $msg = 'Update query value tags must have column attribute.';
            throw new DALParserException($msg);
        }

    }//end validateValueTag()


    protected static function getUnionTag(DomElement $parentNode)
    {
        $unionTag = $parentNode->getElementsByTagName('union')->item(0);
        if ($unionTag === NULL) {
            $unionTag = $parentNode->getElementsByTagName('union-all')->item(0);
        }

        return $unionTag;

    }//end getUnionTag()


    protected static function addHookIds(DomElement $xmlQuery)
    {
        $list = array();
        foreach ($xmlQuery->childNodes as $child) {
            if ($child->nodeType !== XML_ELEMENT_NODE) {
                continue;
            }

            if ($child->tagName === 'hook') {
                $list[] = $child->getAttribute('id');
            }
        }

        return $list;

    }//end addHookIds()


    public static function validateFunctionTag(DomElement $function)
    {
        if ($function->getAttribute('function') === '') {
            $msg = 'function tag must have \'function\' attribute.';
            throw new DALParserException($msg);
        }

    }//end validateFunctionTag()


    public static function validateHook(DomElement $hook)
    {
        // Hook must have an id attribute.
        if ($hook->getAttribute('id') === '') {
            throw new DALParserException('hook tag must have an id attribute.');
        }

    }//end validateHook()


}//end class


?>