DALBaker.inc

<?php
require_once dirname(__FILE__).'/DAL.inc';
//require_once dirname(dirname(__FILE__)).'/Channels/Channels.inc';
//require_once dirname(dirname(__FILE__)).'/Channels/ChannelsBaker.inc';
//require_once dirname(dirname(__FILE__)).'/Libs/FileSystem/FileSystem.inc';
//require_once dirname(dirname(__FILE__)).'/Libs/XML/XML.inc';
require_once dirname(__FILE__).'/Exceptions/DALParserException.inc';
require_once dirname(__FILE__).'/Exceptions/DALBakerException.inc';
require_once dirname(__FILE__).'/Query.inc';

class DALBaker
{

    private static $_whereConditions = array(
                                        'equal'            => '=',
                                        'not-equal'        => '!=',
                                        'equal-or-greater' => '>=',
                                        'equal-or-less'    => '<=',
                                        'greater'          => '>',
                                        'less'             => '<',
                                        'like'             => 'LIKE',
                                        'not-like'         => 'NOT LIKE',
                                        'in'               => 'IN',
                                        'not-in'           => 'NOT IN',
                                        'is-null'          => 'IS NULL',
                                        'not-null'         => 'NOT NULL',
                                       );

    private static $_assertionTypes = array(
                                       'assert-true',
                                       'assert-false',
                                       'assert-empty',
                                       'assert-null',
                                       'assert-equal',
                                       'assert-greater-than',
                                       'assert-less-than',
                                      );

    private static $_forbiddenVariablecharacters = array(
                                                    "'",
                                                    "\n",
                                                    "\t",
                                                    ' ',
                                                    '_',
                                                    '-',
                                                    '[',
                                                    ']',
                                                    '$',
                                                    '"',
                                                    ';',
                                                    '!',
                                                   );


    private function __construct()
    {

    }//end __construct()


    /*
        New System Handling
    */


    public static function getSystemSchemaDocument($systemName)
    {
        // Get the system's schema data.
        $systemPath = Channels::getSystemsPath($systemName);
        $schemaXML  = $systemPath.'/DB/schema.xml';
        if (file_exists($schemaXML) === FALSE) {
            return NULL;
        }

        $doc = new DomDocument();
        $doc->load($schemaXML);

        return $doc;

    }//end getSystemSchemaDocument()


    public static function addSystemSchema($systemName)
    {
        if (ChannelsBaker::systemExists($systemName) === FALSE) {
            return FALSE;
        }

        $schemaDoc = self::getSystemSchemaDocument($systemName);
        if ($schemaDoc === NULL) {
            return FALSE;
        }

        $schemaNode = $schemaDoc->getElementsByTagName('schema');
        if ($schemaNode->length === 0) {
            return FALSE;
        }

        $schemaNode  = $schemaNode->item(0);
        $schemaArray = self::parseSchema($schemaNode);
        $converter   = self::getConverter();
        if (array_key_exists('CREATE', $schemaArray) === TRUE) {
            foreach ($schemaArray['CREATE'] as $table) {
                $tableName = $table['table'];
                // Check if table exists.
                $exists = self::_dbTableExists($tableName, $converter);
                if ($exists === FALSE) {
                    $sql = $converter->convertCreateTable($table);
                    DAL::executeQueries($sql);
                }
            }
        }

        $schemaOvenPath = DAL::getOvenPath($systemName);
        if (file_exists($schemaOvenPath) === FALSE) {
            mkdir($schemaOvenPath);
        }

        $fileName = $schemaOvenPath.'/'.$systemName.'.schema';
        file_put_contents($fileName, $schemaDoc->saveXML());

        return TRUE;

    }//end addSystemSchema()


    protected static function _dbDropTable($tableName, DALConverter $converter=NULL)
    {
        if ($converter === NULL) {
            $converter = self::getConverter();
        }

        if (self::_dbTableExists($tableName, $converter) === TRUE) {
            $sql = $converter->convertDropTable($tableName);
            DAL::executeSql($sql);
            return TRUE;
        }

        return FALSE;

    }//end _dbDropTable()


    protected static function _dbTableExists($tableName, DALConverter $converter=NULL)
    {
        if ($converter === NULL) {
            $converter = self::getConverter();
        }

        $schema = '\''.DAL::getDbName().'\'';
        $name   = '\''.$tableName.'\'';
        $sql    = $converter->handleFunctionTableExists($name, $schema);
        $result = DAL::query($sql);
        $row    = $result->fetchAll();
        $count  = (int)current(current($row));
        if ($count === 1) {
            return TRUE;
        }

        return FALSE;

    }//end _dbTableExists()


    public static function addSystemQueries($systemName)
    {
        if (ChannelsBaker::systemExists($systemName) === FALSE) {
            return FALSE;
        }

        $systemPath = Channels::getSystemsPath($systemName);
        $queryXML   = $systemPath.'/DB/queries.xml';
        if (file_exists($queryXML) === FALSE) {
            return FALSE;
        }

        $success = self::processQueriesFile($systemName, $queryXML);
        return $success;

    }//end addSystemQueries()


    public static function processQueriesFile($systemName, $fileName)
    {
        if (file_exists($fileName) === FALSE) {
            return FALSE;
        }

        $doc = new DomDocument();
        $doc->load($fileName);
        $queryNode = $doc->getElementsByTagName('queries')->item(0);

        $currentDbType = DAL::getDbType();

        foreach ($queryNode->childNodes as $child) {
            if ($child->nodeType !== 1) {
                // Text Node. Probably just whitespace or a comment. We don't
                // want to deal with it.
                continue;
            }

            if ($child->tagName === 'query') {
                if ($child->hasAttribute('id') === FALSE) {
                    $error = 'ID not specified for query in '.$systemName;
                    throw new DALBakerException($error);
                }

                if ($child->hasAttribute('databases') === TRUE) {
                    $dbString = $child->getAttribute('databases');
                    $dbString = str_replace(' ', '', $dbString);
                    $dbs      = explode(',', $dbString);
                    if (in_array($currentDbType, $dbs) === FALSE) {
                        $id = $child->getAttribute('id');
                        echo 'Skipped Query: '.$id." (not for this DB type)\n";
                        continue;
                    }
                }

                if ($child->hasAttribute('hookid') === TRUE) {
                    $hookId = $child->getAttribute('hookid');
                    if (substr_count($hookId, '.') === 1) {
                        // We have a fragment.
                        self::addQueryFragment($systemName, $child);
                    } else {
                        // We have a sub query with a three part hookid (*.*.*).
                        self::addSubQuery($systemName, $child);
                    }
                } else {
                    // New Query.
                    self::addQuery($systemName, $child);
                }
            }//end if
        }//end foreach childnodes

    }//end processQueriesFile()


    /*
        Query Merging
    */


    public static function mergeQuery($systemName, $queryName)
    {
        $doc = self::getQueryXML($systemName, $queryName);

        /*
            We want to traverse through the document, and determine what
            fragments we have. If they have assertions, they must be added
            accordingly. If they don't have assertions, then they must be
            added to the base query, as they will always be executed regardless
            of the state of the system.
        */

        $completeCode = '';

        // This is our query with no fragments attached.
        $baseQuery   = $doc->getElementsByTagname('basequery')->item(0);
        $primaryNode = $baseQuery->getElementsByTagName('primary');
        if ($primaryNode->length === 0) {
            $msg = 'No primary query found for query.';
            throw new DALBakerException($msg);
        } else if ($primaryNode->length > 1) {
            $msg = 'Multiple primary queries found in query';
            throw new DALBakerException($msg);
        }

        // We have exactly 1 primary tag in our base query. This will be the
        // SQL executed if no alternate paths are executed.
        $primaryNode    = $primaryNode->item(0);
        $alternateNodes = $baseQuery->getElementsByTagName('alternate');
        $alternatives   = XML::nodeListToArray($alternateNodes);
        $alternatives[] = $primaryNode;
        $conditions     = array();
        $alternateCount = 1;
        foreach ($alternatives as $basePath) {
            // Make sure we get down to the actual base query, without
            // assertions surrounding it.
            $queryParent  = $basePath;
            $previousNode = $queryParent;
            while ($queryParent = XML::getFirstChildElement($queryParent)) {
                if (in_array($queryParent->tagName, self::$_assertionTypes) === FALSE) {
                    $queryParent = $previousNode;
                    break;
                }

                $previousNode = $queryParent;
            }

            // Stores any fragments that have assertions wrapping them.
            $assertions = array();
            // Loop through each fragment defined for the query.
            $fragmentsNode = $doc->getElementsByTagName('fragments')->item(0);
            foreach ($fragmentsNode->childNodes as $fragment) {
                // Retrieve the assertions that exist.
                $types         = self::$_assertionTypes;
                $assertionList = XML::getElementsByTagNames($types, $fragment);
                if (count($assertionList) === 0) {
                    // No assertion found, so this should always be part of the base
                    // query.
                    $select   = $fragment->getElementsByTagName('select')->item(0);
                    $basePath = self::_combineFragment($basePath, $select);
                    $basePath = $doc->importNode($basePath, TRUE);
                } else {
                    // This assertion will be handled when the tree is constructed.
                    $assertions[] = $fragment;
                }
            }

            // Now we need to evaluate assertions.
            // So we need to get them into a tree structure.
            $assertTree = self::_recurseAddAssertion($assertions);

            // Print out each assertion in the assertion tree with each nodes'
            // SQL representation.
            $queryParent = $doc->importNode($queryParent, TRUE);
            $phpCode     = '';
            $queryBaseId = $systemName.'_'.$queryName;
            if ($queryParent->tagName !== 'primary') {
                $queryBaseId .= 'Alternate'.$alternateCount;
                $alternateCount++;
            }

            if (count($assertions) !== 0) {
                $phpCode = self::_recursePrintAssertions($assertTree, $queryParent, $queryBaseId);
            } else {
                // Just the base query to print out.
                $phpCode = self::_printNodeSql($queryParent, $queryBaseId);
            }

            $alternateCount++;

            // If it is primary with alternates, print else, otherwise print just
            // assign, otherwise it is an alternate, and we need to evaluate
            // assertions.
            if ($basePath->tagName === 'primary') {
                if (count($alternatives) > 1) {
                    $phpCode = "{\n$phpCode\n}\n";
                } else {
                    $phpCode .= "\n";
                }
            } else {
                $phpCode = self::_printAlternateAssertions($basePath, $phpCode);
            }

            $conditions[] = $phpCode;
        }//end foreach

        $completeCode = implode(' else ', $conditions);
        return $completeCode;

    }//end mergeQuery()


    /*
        Assertions
    */


    protected static function _printAlternateAssertions(DomElement $alternate, $contents)
    {
        $asserts    = XML::getElementsByTagNames(self::$_assertionTypes, $alternate);
        $assertVars = array();
        foreach ($asserts as $assertion) {
            $varName      = self::_getAssertionVariableName($assertion);
            $assertVars[] = "($varName === TRUE)";
        }

        $condition = 'if ('.implode(' && ', $assertVars).") {\n";
        return $condition.$contents."\n}";

    }//end _printAlternateAssertions()


    protected static function _recurseAddAssertion(array $assertions, array $currentStack=array())
    {
        $retval = array();
        if (empty($assertions) === TRUE) {
            return $retval;
        }

        $currentAssertion = array_shift($assertions);
        // Setup the else condition first, as it doesn't have the assertion
        // on the current level. It should just pass through the current stack.
        $elseChildren  = self::_recurseAddAssertion($assertions, $currentStack);
        $elseCondition = array(
                          'assertions' => $currentStack,
                          'children'   => $elseChildren,
                         );

        // Add the current assertion for the IF condition.
        $currentStack[] = $currentAssertion;

        $ifChildren = self::_recurseAddAssertion($assertions, $currentStack);

        $ifCondition = array(
                        'current_assertion' => $currentAssertion,
                        'assertions'        => $currentStack,
                        'children'          => $ifChildren,
                       );

        $retval['if_condition']   = $ifCondition;
        $retval['else_condition'] = $elseCondition;

        return $retval;

    }//end _recurseAddAssertion()


    protected static function _recursePrintAssertions(array $tree, DomElement $baseQuery, $baseQueryId, $level=0)
    {
        $contents = '';
        if (empty($tree) === TRUE) {
            return '';
        }

        $ifCondition   = $tree['if_condition'];
        $elseCondition = $tree['else_condition'];
        $currentAssert = $ifCondition['current_assertion'];

        // Find the assertion, and determine what variable to test for in the
        // if condition.
        $types            = self::$_assertionTypes;
        $assertionList    = XML::getElementsByTagNames($types, $currentAssert);
        $assertionNode    = array_shift($assertionList);
        $assertionChannel = $assertionNode->getAttribute('channel');
        $assertVariable   = self::_getAssertionVariableName($assertionNode);

        // Add the code to the string, for the if and else contents.
        $contents .= "\nif ($assertVariable === TRUE) {\n";
        if (empty($ifCondition['children']) === TRUE) {
            // Empty children, we need to print out the query.
            $fragments = $ifCondition['assertions'];
            $ifQuery   = self::_mergeAllAssertions($baseQuery, $fragments);
            $idParts   = array();
            foreach ($fragments as $queryPart) {
                $idParts[] = $queryPart->getAttribute('id');
            }

            $contents .= self::_printNodeSql($ifQuery, $baseQueryId, $idParts);
        } else {
            // It has children, we need to recurse again.
            $contents .= self::_recursePrintAssertions($ifCondition['children'], $baseQuery, $baseQueryId, ($level + 1));
        }

        $contents .= "\n} else {\n";
        if (empty($ifCondition['children']) === TRUE) {
            // Empty children, we need to print out the query.
            $fragments = $elseCondition['assertions'];
            $elseQuery = self::_mergeAllAssertions($baseQuery, $fragments);
            $idParts   = array();
            foreach ($fragments as $queryPart) {
                $idParts[] = $queryPart->getAttribute('id');
            }

            $contents .= self::_printNodeSql($elseQuery, $baseQueryId, $idParts);
        } else {
            // It has children, we need to recurse again.
            $contents .= self::_recursePrintAssertions($elseCondition['children'], $baseQuery, $baseQueryId, ($level + 1));
        }

        $indentSpace = '    ';
        $contents    = str_replace("\n", "\n$indentSpace", $contents);
        $contents   .= "}\n";
        return $contents;

    }//end _recursePrintAssertions()


    protected static function _mergeAllAssertions(DomElement $baseQuery, array $assertions)
    {
        $doc = new DomDocument();
        // We want a new copy of the base node, that we can add all assertions
        // to, without altering the original.
        $returnQuery = $doc->importNode($baseQuery, TRUE);
        foreach ($assertions as $fragment) {
            // Add each fragment to the query, making sure we only pass the
            // select part of the fragment to _combineFragment().
            $select      = $fragment->getElementsByTagName('select')->item(0);
            $returnQuery = self::_combineFragment($returnQuery, $select);
        }

        return $returnQuery;

    }//end _mergeAllAssertions()


    protected static function _getQueryAssertions($systemName, $queryName)
    {
        $doc = self::getQueryXML($systemName, $queryName);

        // Find a list of all assertions and return their array.
        $types      = self::$_assertionTypes;
        $assertions = XML::getElementsByTagNames($types, $doc);

        return $assertions;

    }//end _getQueryAssertions()


    protected static function _getAssertionVariableName(DomElement $assertion)
    {
        $channelName  = '';
        $variableName = '';
        if ($assertion->hasAttribute('channel') === TRUE) {
            $channelName = $assertion->getAttribute('channel');
            if (trim($channelName) === '') {
                throw new DALBakerException('Channel name is empty');
            }

            list($system, $event) = explode('::', $channelName);
            $variableName = '$'.strtolower($system).ucfirst($event);
        } else if ($assertion->hasAttribute('data') === TRUE) {
            $variableName  = '$'.$assertion->getAttribute('data').'ChannelData';
            $variableName .= str_replace('assert-', '', $assertion->tagName);
            // Shorten the value if need be.
            $value = strval($assertion->getAttribute('value'));
            if (strlen($value) > 5) {
                $value = substr($value, 0, 5);
            }

            $variableName .= $value;
        } else {
            $functionCall = $assertion->getElementsByTagName('function-call');
            if ($functionCall->length === 0) {
                $error = 'No function call specified for assertion.';
                throw new DALBakerException($error);
            }

            $functionCall = $functionCall->item(0);
            $argList      = $functionCall->getElementsByTagName('arg');
            $variableName = $functionCall->getAttribute('function');
            foreach ($argList as $argNode) {
                // Get the text and replace any forbidden characters.
                $argText = $argNode->nodeValue;
                $replace = self::$_forbiddenVariablecharacters;
                $argText = str_replace($replace, ' ', $argText);
                $argText = str_replace(' ', '', ucwords($argText));
                // Add the text to the variable name.
                $variableName .= ucfirst($argText);
            }

            $variableName = '$'.$variableName;
        }//end if

        return $variableName;

    }//end _getAssertionVariableName()


    /*
        XML Handling
    */


    public static function generateQueryXML($systemName, $queryName)
    {
        $systemPath = dirname(__FILE__).'/Oven/'.$systemName;
        $fileName   = $systemPath.'/'.$queryName.'.xml';

        if (file_exists($systemPath) === FALSE) {
            mkdir($systemPath);
        }

        $contents  = '<querychannel system="'.$systemName.'" query="';
        $contents .= $queryName.'">';
        $contents .= '<basequery />';
        $contents .= '<fragments />';
        $contents .= '<sub-queries />';
        $contents .= '</querychannel>';

        return file_put_contents($fileName, $contents);

    }//end generateQueryXML()


    public static function queryXMLExists($systemName, $queryName)
    {
        $systemPath = dirname(__FILE__).'/Oven/'.$systemName;
        $fileName   = $systemPath.'/'.$queryName.'.xml';

        return file_exists($fileName);

    }//end queryXMLExists()


    public static function getQueryXML($systemName, $queryName)
    {
        $systemPath = dirname(__FILE__).'/Oven/'.$systemName;
        $fileName   = $systemPath.'/'.$queryName.'.xml';

        if (self::queryXMLExists($systemName, $queryName) === FALSE) {
            self::generateQueryXML($systemName, $queryName);
        }

        $doc = new DomDocument();
        $doc->load($fileName);
        return $doc;

    }//end getQueryXML()


    public static function saveQueryXML($system, $queryName, DomDocument $doc)
    {
        $systemPath = dirname(__FILE__).'/Oven/'.$system;
        $fileName   = $systemPath.'/'.$queryName.'.xml';

        if (file_exists($fileName)) {
            unlink($fileName);
        }

        $doc->save($fileName);

    }//end saveQueryXML()


    /*
        Adding Query Fragments
    */


    public static function addQuery($systemName, DomElement $query)
    {
        $queryId = $query->getAttribute('id');

        //if (self::queryXMLExists($systemName, $queryId) === FALSE) {
        self::generateQueryXML($systemName, $queryId);
        //}

        $doc       = self::getQueryXML($systemName, $queryId);
        $queryNode = $doc->getElementsByTagName('basequery')->item(0);

        if ($queryNode !== NULL) {
            if ($queryNode->getElementsByTagName('query')->length !== 0) {
                return FALSE;
            }
        }

        // Extract and replace any hard-coded news in the query, with place
        // holder variables, after setting the system for use by the
        // _prepareFragment() method.
        $query->setAttribute('system', $systemName);
        $importedNode = self::_prepareFragment($query);
        // Import the node to the document.
        $importedNode = $doc->importNode($importedNode, TRUE);

        $queryNode->appendChild($importedNode);
        self::saveQueryXML($systemName, $queryId, $doc);

        return TRUE;

    }//end addQuery()


    public static function addQueryFragment($systemName, DomElement $fragment)
    {
        // We need to add the originating system to the fragment, so that we
        // know where it comes from when it's out in the wild.
        $fragment->setAttribute('system', $systemName);

        // We need to parse this fragment, and convert all hard coded values to
        // placeholders.
        $fragment = self::_prepareFragment($fragment);

        $hookId = $fragment->getAttribute('hookid');
        list($targetSystem, $targetQuery) = explode('.', $hookId);

        //if (self::queryXMLExists($targetSystem, $targetQuery) === FALSE) {
        self::generateQueryXML($targetSystem, $targetQuery);
        //}

        $doc           = self::getQueryXML($targetSystem, $targetQuery);
        $fragmentsNode = $doc->getElementsByTagName('fragments')->item(0);

        /*
            Have to check if the query fragment exists. If it does, remove it.
        */

        // Import the node to the document.
        $importedNode = $doc->importNode($fragment, TRUE);
        $fragmentsNode->appendChild($importedNode);
        self::saveQueryXML($targetSystem, $targetQuery, $doc);

    }//end addQueryFragment()


    public static function addSubQuery($systemName, DomElement $subQuery)
    {
        // We need to add the originating system to the fragment, so that we
        // know where it comes from when it's out in the wild.
        $subQuery->setAttribute('system', $systemName);

        // We need to parse this sub-query, and convert all hard coded values to
        // placeholders.
        $subQuery = self::_prepareFragment($subQuery);

        $hookId = $subQuery->getAttribute('hookid');
        list($targetSystem, $targetQuery) = explode('.', $hookId);

        //if (self::queryXMLExists($targetSystem, $targetQuery) === FALSE) {
        self::generateQueryXML($targetSystem, $targetQuery);
        //}

        $doc            = self::getQueryXML($targetSystem, $targetQuery);
        $subQueriesNode = $doc->getElementsByTagName('sub-queries')->item(0);

        /*
            Have to check if the query fragment exists. If it does, remove it.
        */

        // Import the node to the document.
        $importedNode = $doc->importNode($subQuery, TRUE);
        $subQueriesNode->appendChild($importedNode);
        self::saveQueryXML($targetSystem, $targetQuery, $doc);

    }//end addSubQuery()


    protected static function _combineFragment(DomElement $query, DomElement $fragment)
    {
        $doc = new DomDocument();
        // Import both nodes, so we are working in the same document.
        $query    = $doc->importNode($query, TRUE);
        $fragment = $doc->importNode($fragment, TRUE);

        foreach ($fragment->childNodes as $section) {
            if ($section->nodeType !== 1) {
                // Text node, disregard.
                continue;
            }

            // See if the existing query has the same section that we can add
            // our new data too.
            $currentNode = $query->getElementsByTagName($section->tagName);
            if ($currentNode->length === 0) {
                // We don't have this section in our base query yet, we can go
                // ahead and clone it over.
                $select = $query->getElementsByTagName('select')->item(0);
                $clone  = $section->cloneNode(TRUE);
                $select->appendChild($clone);
            } else {
                $currentNode = $currentNode->item(0);
                // Existing section, traverse the nodes of the fragment and
                // import them under the existing section.
                foreach ($section->childNodes as $condition) {
                    if ($condition->nodeType !== 1) {
                        continue;
                    }

                    // Clone the node and append it to the query's Element.
                    // Cloning is done, as appending the original element seems
                    // to stuff up the loop we are in.
                    $copy = $condition->cloneNode(TRUE);
                    $currentNode->appendChild($copy);
                }
            }//end if
        }//end foreach

        return $query;

    }//end _combineFragment()


    protected static function _prepareFragment(DomElement $query)
    {
        $doc = new DomDocument();

        // Import the node into our new doc.
        $returnQuery = $doc->importNode($query, TRUE);
        // Extract any hardcoded values that are in the query.
        $returnQuery = self::_extractPlaceHolders($returnQuery);
        $returnQuery = self::_extractKeywords($returnQuery);
        // Extract any bindings that are in the query.
        $returnQuery = self::_extractBindings($returnQuery);
        $returnQuery = $doc->importNode($returnQuery, TRUE);

        return $returnQuery;

    }//end _prepareFragment()


    /*
        PHP Code Handling
    */


    public static function bakeQueriesFile($systemName)
    {
        if (trim($systemName) === '') {
            throw new DALBakerException('System name is empty');
        }

        // Write the file.
        $ovenDir = dirname(__FILE__).'/Oven/'.$systemName;

        if (file_exists($ovenDir) === FALSE) {
            mkdir($ovenDir);
        }

        $fileName = $ovenDir.'/'.$systemName.'Queries.inc';

        $contents  = '<?'."php\n\n";
        $contents .= "require_once dirname(dirname(dirname(__FILE__))).'/DAL.inc';\n";
        $contents .= "class $systemName"."Queries\n{\n\n";
        // Determine what XML files are present in the oven directory for this
        // system, and print out the method for each.
        $types    = array('.xml');
        $xmlFiles = FileSystem::listDirectory($ovenDir, $types, TRUE, FALSE);
        foreach ($xmlFiles as $queryName) {
            $queryName = basename($queryName, '.xml');
            $contents .= self::bakeQueryMethod($systemName, $queryName);
        }

        $contents .= "\n\n}\n?>";

        file_put_contents($fileName, $contents);

    }//end bakeQueriesFile()


    public static function bakeQueryMethod($systemName, $queryName)
    {
        // Output the method signature.
        $methodName = 'prepare'.ucwords($queryName).'Query';
        $contents   = "public static function $methodName(array \$data, \$bind)\n{\n";
        // Print out the initialisation of hard coded values.
        $contents .= self::_printPlaceHolderVariables($systemName, $queryName);
        // Get the values required for our assertions.
        $contents .= "try {\n";
        // Loop through each assertion, and output a call that assigns its
        // value to a variable.
        $assertions = self::_getQueryAssertions($systemName, $queryName);
        // Print out the code for including the assertions systems and
        // initialising their values.
        $contents .= self::_printAssertionCalls($assertions);
        $contents .= "} catch (ChannelException \$e) {\n";
        $contents .= "    // Exception thrown in the called channel.\n";
        $contents .= "}\n";

        // Get all the conditions that represent all of the query's
        // combinations, and add it to the contents.
        $queryBody  = self::mergeQuery($systemName, $queryName);
        $contents  .= $queryBody;
        $subQueries = self::printSubQueries($systemName, $queryName);
        $contents  .= $subQueries;
        $contents  .= self::_printKeywords($systemName, $queryName);
        $contents  .= self::_printBindings($systemName, $queryName);
        $contents  .= "\n}//end $methodName()\n";

        return $contents;

    }//end bakeQueryMethod()


    protected static function _printAssertionCalls(array $assertions)
    {
        // Will hold the return value.
        $contents = '';
        // Holds the assignment calls.
        $assignments = "\n// Initialise values for use in the conditions\n";
        // Holds the calls to include the appopriate system files for assertion
        // plug calls.
        $includes = '';
        // Keep a track of what files we have included, so we don't print the
        // call twice.
        $includedFiles = array();

        foreach ($assertions as $assertion) {
            $assignments .= self::_printAssertionInitialisation($assertion)."\n";
            if ($assertion->hasAttribute('channel') === TRUE) {
                // This has a file that needs to be included, and we have to
                // investigate the node and find the system it requires.
                $channel = $assertion->getAttribute('channel');
                list($system, $methodName) = explode('::', $channel);
                // Add the require for the system if it hasn't been done by a
                // previous assertion.
                if (in_array($system, $includedFiles) === FALSE) {
                    // Add the include for the system.
                    $includes .= "Channels::includeSystem('$system');\n";
                    // Actually include the file for our use in this method.
                    Channels::requireSystemActions($system);
                    $includedFiles[] = $system;
                }
            }
        }//end foreach

        $comment = "\n// Include required files for the assertion values.\n";
        if ($includes !== '') {
            $includes = $comment.$includes;
        }

        $contents = $includes.$assignments;
        return $contents;

    }//end _printAssertionCalls()


    protected static function _printAssertionInitialisation(DomElement $assertion)
    {
        $methodCall = '';
        if ($assertion->hasAttribute('channel') === TRUE) {
            // Standard assertion, with a call to a channel to exectute.
            $channel = $assertion->getAttribute('channel');
            list($system, $methodName) = explode('::', $channel);

            // Use the actions.xml file for the system to work out parameters.
            $actionsPath  = Channels::getSystemsPath($system);
            $actionsPath .= '/actions.xml';

            $eventDoc = new DomDocument();
            $eventDoc->load($actionsPath);

            $parentNode = NULL;

            $actionNodes = $eventDoc->getElementsByTagName('action');
            foreach ($actionNodes as $node) {
                // Attempt to find the xml defninition for this channel.
                if ($node->getAttribute('name') === $methodName) {
                    $parentNode = $node;
                    break;
                }
            }

            $query  = $parentNode->getElementsByTagName('query');
            $params = $parentNode->getElementsByTagName('param');

            // $paramIndexes holds references to this data in the "$data" array.
            $paramIndexes = array();
            foreach ($params as $param) {
                $paramIndexes[] = '$data[\''.$param->getAttribute('name').'\']';
            }

            // Construct the method call for the channel.
            $paramString = '('.implode(', ', $paramIndexes).')';
            $methodCall  = $channel.$paramString;

            // Maybe query channel :-) Query object itself isn't very useful..
            if ($query->length > 0) {
                $methodCall = 'DAL::executeDALQuery('.$methodCall.')';
            }
        } else if ($assertion->hasAttribute('data') === TRUE) {
            // Has a channel data index specified.
            $methodCall = '$data[\''.$assertion->getAttribute('data').'\']';
        } else {
            // This is probably a function call (no channel specified) so the
            // method call has to be extracted.
            $functionCall = $assertion->getElementsByTagName('function-call');
            if ($functionCall->length === 0) {
                // No channel, and no function call. Nothing to assert.
                $error = 'No function call specified for assertion';
                throw new DALBakerException($error);
            }

            $functionCall = $functionCall->item(0);

            if ($functionCall->hasAttribute('function') === FALSE) {
                // No function specified for the function-call, which makes it
                // pretty tough to do anything.
                $error = 'No function call specified for assertion';
                throw new DALBakerException($error);
            }

            $functionName = $functionCall->getAttribute('function');
            $argList      = $functionCall->getElementsByTagName('arg');
            $args         = array();
            foreach ($argList as $argNode) {
                $args[] = self::_printAssertionArgument($argNode);
            }

            $argString  = implode(', ', $args);
            $methodCall = "$functionName($argString)";
        }//end if

        $initCode = '';

        // Add the assignment call to the contents.
        switch ($assertion->tagName) {
            case 'assert-true':
                $methodCall = "($methodCall === TRUE)";
            break;
            case 'assert-false':
                $methodCall = "($methodCall === FALSE)";
            break;
            case 'assert-null':
                $methodCall = "($methodCall === NULL)";
            break;
            case 'assert-empty':
                // Can't call empty on function return value, do extra stuffs.
                $initCode   = '$empty = '.$methodCall.';'."\n";
                $methodCall = '(empty($empty) === TRUE)';
            break;
            case 'assert-equal':
            case 'assert-greater-than':
            case 'assert-less-than':
                if ($assertion->hasAttribute('value') === FALSE) {
                    $msg = 'No value specified for comparison assertion.';
                    throw new DALBakerException($msg);
                }

                $assertValue = $assertion->getAttribute('value');
                if ($assertion->tagName === 'assert-equal') {
                    $operator = '===';
                } else if ($assertion->tagName === 'assert-greater-than') {
                    $operator = '>';
                } else {
                    $operator = '<';
                }

                $methodCall = "($methodCall $operator $assertValue)";
            break;
            default:
                $error = 'Unknown Assertion Type: '.$assertion->tagName;
                throw new DALBakerException($error);
        }//end switch

        $variableName = self::_getAssertionVariableName($assertion);

        return $initCode.$variableName.' = '.$methodCall.';';

    }//end _printAssertionInitialisation()


    protected static function _printAssertionArgument(DomElement $argNode)
    {
        $type    = $argNode->getAttribute('type');
        $data    = $argNode->nodeValue;
        $argText = '';

        switch ($type) {
            case 'string':
                $argText = "'$data'";
            break;
            default:
                $argText = "$data";
        }

        return $argText;

    }//end _printAssertionArgument()


    protected static function _printNodeSql(DomElement $query, $baseId='', array $idParts=array())
    {
        // Call the DAL to convert the XML to SQL.
        sort($idParts);
        $sqlArray = self::constructSql($query);
        $sql      = self::convertToSql($query, $sqlArray);
        $id       = $baseId.md5(implode('_', $idParts));
        self::_writeQueryObject($id, $sqlArray, $sql);
        $returnQuery = "\$query = DAL::getQueryObject('$id');\n";
        return $returnQuery;

    }//end _printNodeSql()


    protected static function _writeQueryObject($id, array $sqlArray, $sql)
    {
        $queryObj = new Query($id, $sqlArray, $sql);
        $objData  = serialize($queryObj);
        $fileName = $id.'.qob';
        $path     = DAL::getQueryStorePath().'/'.$fileName;
        if (file_exists($path) === TRUE) {
            if (unlink($path) === FALSE) {
                throw new DALException('Query object already exists, and was unable to be removed');
            }
        }

        file_put_contents($path, $objData);

    }//end _writeQueryObject()


    protected static function _printPlaceHolderVariables($systemName, $queryName)
    {
        $doc = self::getQueryXML($systemName, $queryName);

        $contents = "\n// Values that were hard-coded in query definitions.\n";

        $placeHolders = $doc->getElementsByTagName('placeholder');
        foreach ($placeHolders as $element) {
            $varName   = substr($element->getAttribute('var_name'), 1);
            $varValue  = $element->getAttribute('value');
            $contents .= "\$$varName = '$varValue';\n";
        }

        $contents .= "\n";
        return $contents;

    }//end _printPlaceHolderVariables()


    public static function printSubQueries($systemName, $queryName)
    {
        $hookIds = self::_generateHookArray($systemName, $queryName);
        return self::_printHookCode($hookIds);

    }//end printSubQueries()


    protected static function _generateHookArray($systemName, $queryName)
    {
        $doc = self::getQueryXML($systemName, $queryName);

        $hookIds = array();
        $hooks   = $doc->getElementsByTagName('hook');
        foreach ($hooks as $hook) {
            $id                          = $hook->getAttribute('id');
            $hooksIds[$id]               = array();
            $parent                      = $hook->parentNode;
            $hookIds[$id]['parent-type'] = $parent->tagName;
            $hookIds[$id]['sub-queries'] = array();
        }

        $subNode = $doc->getElementsByTagName('sub-queries')->item(0);
        $queries = $subNode->getElementsByTagName('query');
        foreach ($queries as $subQuery) {
            $origHookId = $subQuery->getAttribute('hookid');
            $hookSys    = $subQuery->getAttribute('system');
            $hookId     = substr($origHookId, (strrpos($origHookId, '.') + 1));
            // Check this hook exists.
            if (array_key_exists($hookId, $hookIds) === FALSE) {
                throw new DALBakerException('Hook: '.$hookId.' does not exist');
            }

            // Setup an array to hold our sub-query data.
            $subData = array(
                        'assertion_var' => '',
                        'sub-query'     => NULL,
                       );

            // Get any assertions, along with the actual SQL query.
            $assertions = XML::getElementsByTagNames(self::$_assertionTypes, $subQuery);
            $select     = $subQuery->getElementsByTagName('select')->item(0);

            if ($select === NULL) {
                $select = $subQuery->getElementsByTagName('hookQuery')->item(0);
                $select = XML::getFirstChildElement($select);
            }

            if (count($assertions) !== 0) {
                // Assertion present, so we only add it if the assertion var is
                // true.
                // Determine the assertion var to be used.
                $assertionVar = self::_getAssertionVariableName($assertions[0]);
                // Add the data to our subData array.
                $subData['assertion_var'] = $assertionVar;
            }

            // We need to add a temporary parent for our select, as convertToSql
            // expects the select to be the first child of the passed element.
            $tempDoc = new DomDocument();
            $newSub  = "<query hookid=\"$origHookId\" system=\"$hookSys\">";
            $newSub .= $doc->saveXML($select).'</query>';
            $tempDoc->loadXML($newSub);
            $queryNode = $tempDoc->getElementsByTagName('query')->item(0);
            // Add the newly created node, containing the sub-query, into the
            // array.
            $subData['sub-query'] = $queryNode;
            // Add the data for this sub-query to the array for the whole query
            // here.
            $hookIds[$hookId]['sub-queries'][] = $subData;
        }//end foreach

        return $hookIds;

    }//end _generateHookArray()


    protected static function _printHookCode(array $hookIds)
    {
        // Print out the contents.
        $contents = '';

        // For each hook id that we have, we need to determine the parent type
        // and how to seperate each SQL fragment. We also need to add each of
        // the sub-queries to the array that will be imploded with this
        // seperator.
        foreach ($hookIds as $id => $hookData) {
            $codeId    = self::getHookCodeId($id);
            $arrayId   = self::getHookArrayId($id);
            $contents .= "\n// Setting up hook data for $id.\n\n";
            $contents .= "$arrayId = array();\n";
            foreach ($hookData['sub-queries'] as $subQuery) {
                // Store a query object for this sub query.
                $subQueryNode = $subQuery['sub-query'];
                $subQueryId   = $subQueryNode->getAttribute('id');
                $subQuerySys  = $subQueryNode->getAttribute('system');
                $subQueryHook = $subQueryNode->getAttribute('hookid');
                $subObjectId  = 'subquery_'.$id.'_';
                $subObjectId .= md5($subQuerySys.$subQueryId.$subQueryHook);
                if ($subQuery['assertion_var'] !== '') {
                    $assertionVar = $subQuery['assertion_var'];
                    $contents    .= "if ($assertionVar === TRUE) {\n    ";
                }

                $sqlArray = self::constructSql($subQuery['sub-query']);
                $sql      = self::convertToSql($subQuery['sub-query'], $sqlArray);
                self::_writeQueryObject($subObjectId, $sqlArray, $sql);
                $contents .= $arrayId."[] =  DAL::getQueryObject('$subObjectId');\n";

                if ($subQuery['assertion_var'] !== '') {
                    $contents .= "}\n";
                }
            }//end foreach

            // Implode the data and add seperators.
            $contents .= "\$query->subQueries('$id', $arrayId);\n";

        }//end foreach

        return $contents;

    }//end _printHookCode()


    public static function getHookCodeId($hookId)
    {
        return 'HOOKID:'.$hookId;

    }//end getHookCodeId()


    public static function getHookArrayId($hookId)
    {
        $str = ucwords(str_replace('_', ' ', $hookId));
        return '$'.str_replace(' ', '', $str).'Array';

    }//end getHookArrayId()


    public static function getSeperator($tagName)
    {
        // All tags will use a comma, unless specified in the switch below.
        $seperator = ', ';

        switch (strtolower($tagName)) {
            case 'union-all':
                $seperator = '\nUNION-ALL\n';
            break;
            case 'and':
                $seperator = '\nAND\n';
            break;
            case 'or':
                $seperator = '\nOR\n';
            break;
            default:
        }

        return $seperator;

    }//end getSeperator()


    protected static function _printKeywords($systemName, $queryName)
    {
        $doc       = self::getQueryXML($systemName, $queryName);
        $keywords  = $doc->getElementsByTagName('keyword');
        $processed = array();
        $arrayInit = FALSE;
        $suffix    = '';
        $contents  = '';
        foreach ($keywords as $keyword) {
            if (in_array($keyword->nodeValue, $processed) === FALSE) {
                if ($arrayInit === FALSE) {
                    // Initialise array.
                    $contents  = "\$queryKeywordsArray = array();\n";
                    $suffix    = "\$query->keywords(\$queryKeywordArray);\n";
                    $arrayInit = TRUE;
                }

                $processed[] = $keyword->nodeValue;
                $contents   .= '$queryKeywordArray[\''.$keyword->nodeValue.'\'] = $data[\''.$keyword->nodeValue."'];\n";
            }
        }

        // If a keyword is printed.
        $contents .= $suffix;

        return $contents;

    }//end _printKeywords()


    protected static function _printBindings($systemName, $queryName, $printBindings=TRUE)
    {
        $doc      = self::getQueryXML($systemName, $queryName);
        $contents = '';

        $bindingList = $doc->getElementsByTagName('binding');
        // Create an array containing our place holder names, so we can easily
        // find if a variable name has been generated by the system.
        $placeHolders     = array();
        $placeHoldersList = $doc->getElementsByTagName('placeholder');
        foreach ($placeHoldersList as $element) {
            $varName                = $element->getAttribute('var_name');
            $varValue               = $element->getAttribute('value');
            $placeHolders[$varName] = $varValue;
        }

        $usedNames = array();
        foreach ($bindingList as $binding) {
            $bindName = $binding->getAttribute('name');

            // We need to determine what data type the column is.
            $columnType = $binding->getAttribute('column_type');
            if ($columnType !== '') {
                $dataType = self::_getPdoDataType($system, $table, $column, $columnType);
            } else {
                $column   = $binding->getAttribute('column');
                $table    = $binding->getAttribute('table');
                $system   = $binding->getAttribute('system');
                $dataType = self::_getPdoDataType($system, $table, $column);
            }

            $varName = '';
            $index   = substr($bindName, 1);
            // Check if the binding is a hard coded value. If it is, set its'
            // variable to be the same as defined in _printPlaceHoldersVariables
            // otherwise print an index into the $data array.
            if (isset($placeHolders[$bindName]) === TRUE) {
                // This is a place holder for a hard-coded value.
                $varName = '$'.substr($bindName, 1);
            } else {
                // This is not hard-coded, so should be referenced in the $data
                // array.
                $varName = "\$data['$index']";
            }

            if ($printBindings === TRUE) {
                // Add check for array values.
                $bindCall = '';
                if (isset($placeHolders[$bindName]) === FALSE) {
                    $bindCall = "\nif (array_key_exists('$index',\$data) === TRUE) {\n";
                }

                $bindCall .= "\$query->bind('$bindName', $varName, $dataType);\n";

                if (isset($placeHolders[$bindName]) === FALSE) {
                    $bindCall .= "}\n\n";
                }

                // Add this binding to the contents.
                $contents .= $bindCall;
            }

        }//end foreach

        $contents .= "return \$query;\n";

        return $contents;

    }//end _printBindings()


    protected static function _extractBindings(DomElement $fragment)
    {
        $doc   = new DomDocument();
        $query = $doc->importNode($fragment, TRUE);
        // Add the bindings element to the the base query element.
        $bindingsParent = $doc->createElement('bindings');
        $query->appendChild($bindingsParent);
        $systemName = $fragment->getAttribute('system');
        // Get the XML contents, and determine if there are any bindings used.
        $xmlString = $doc->saveXML($query);
        $matches   = array();
        preg_match_all('/:[a-zA-Z\d_]+/i', $xmlString, $matches);
        $bindings      = $matches[0];
        $bindingsCount = count($bindings);
        if ($bindingsCount === 0) {
            // None present.
            return $query;
        }

        // There are some bindings needed in the query, we need to determine
        // where.
        $allElements = $query->getElementsByTagName('*');
        foreach ($allElements as $element) {
            if ($element->childNodes->length === 1) {
                // One child node, see if the nodeValue is a place-holder.
                $nodeValue   = trim($element->nodeValue);
                $bindMatches = array();
                preg_match('/:[a-zA-Z\d_]+/i', $nodeValue, $bindMatches);
                if (empty($bindMatches) === FALSE) {
                    // Check if this is really just a text node with a binding,
                    // or it could still get here if this is a <value></value>
                    // tag. If it is a value tag, we will get it on the next
                    // iteration. Using the firstChild rather than nodeValue
                    // is used here, as if nodeValue will fail this test always.
                    $fullTagValue = $doc->saveXML($element->firstChild);
                    if (substr(trim($fullTagValue), 0, 1) !== ':') {
                        continue;
                    }

                    // Setup variables from the attributes, and create a new
                    // binding element representing this data.
                    $bindColumn     = '';
                    $bindColumnType = '';
                    $bindTable      = '';
                    $bindSystem     = $systemName;
                    $bindName       = $bindMatches[0];

                    $targetNode = NULL;
                    // If this node is a field or another element that doesn't
                    // have a table specified, we need to determine where it
                    // is targeted, so that we can set its' data type.
                    if ($element->hasAttribute('table') === FALSE) {
                        if ($element->parentNode->hasAttribute('table') === TRUE) {
                            $targetNode = $element->parentNode;
                        } else if ($element->tagName === 'value') {
                            // Values only have column specified, so we need to
                            // find the fields node, underneath our parent.
                            $parent    = $element->parentNode->parentNode;
                            $fieldNode = $parent->getElementsByTagName('fields');
                            if ($fieldNode->length !== 0) {
                                $targetNode = $fieldNode->item(0);
                            }
                        }
                    } else {
                        // Element has its' table attribute specified.
                        $targetNode = $element;
                    }

                    $bindColumnType = $element->getAttribute('column_type');

                    if ($targetNode !== NULL) {
                        $bindColumn = $targetNode->getAttribute('column');
                        if ($bindColumn === '') {
                            $bindColumn = $element->getAttribute('column');
                        }

                        $bindTable = $targetNode->getAttribute('table');
                    }

                    // Create the binding element, set its' attributes and
                    // append it to the bindings tag of the fragment.
                    $newBinding = $doc->createElement('binding');
                    $newBinding->setAttribute('table', $bindTable);
                    $newBinding->setAttribute('column', $bindColumn);
                    $newBinding->setAttribute('column_type', $bindColumnType);

                    $newBinding->setAttribute('system', $bindSystem);
                    $newBinding->setAttribute('name', $bindName);
                    $bindingsParent->appendChild($newBinding);
                }//end if $bindMatches not empty
            }//end if childNodes->length === 1
        }//end foreach $allElements

        return $query;

    }//end _extractBindings()


    protected static function _extractKeywords(DomElement $fragment)
    {
        $doc   = new DomDocument();
        $query = $doc->importNode($fragment, TRUE);

        // Add the placeholder element to the the base query element.
        $keywordParent = $doc->createElement('keywords');
        $query->appendChild($keywordParent);
        $xmlString = $doc->saveXML($query);
        $matches   = array();

        preg_match_all('/\[([a-zA-Z0-9]+)\]/m', $xmlString, $matches);

        if (isset($matches[1]) === TRUE && empty($matches[1]) === FALSE) {
            foreach ($matches[1] as $keyword) {
                $newKeyword            = $doc->createElement('keyword');
                $newKeyword->nodeValue = $keyword;
                $keywordParent->appendChild($newKeyword);
            }
        }

        return $query;

    }//end _extractKeywords()


    protected static function _extractPlaceHolders(DomElement $fragment)
    {
        $doc   = new DomDocument();
        $query = $doc->importNode($fragment, TRUE);
        // Add the placeholder element to the the base query element.
        $placeParent = $doc->createElement('placeholders');
        $query->appendChild($placeParent);
        $systemName = $fragment->getAttribute('system');
        $queryId    = $fragment->getAttribute('id');

        $allElements = $query->getElementsByTagName('value');
        foreach ($allElements as $element) {
            if ($element->childNodes->length === 1) {
                // One child node, see if the nodeValue is a place-holder.
                $nodeValue = trim($element->nodeValue);
                if ($nodeValue === '') {
                    continue;
                }

                if ($element->tagName === 'table') {
                    continue;
                }

                if (substr($nodeValue, 0, 1) === ':') {
                    // This is already a binding.
                    continue;
                }

                if (substr($nodeValue, 0, 1) === '[') {
                    // This is a keyword.
                    continue;
                }

                // Setup variables from the attributes, and create a new
                // binding element representing this data.
                $placeColumn = '';
                $placeTable  = '';
                $targetNode  = NULL;
                // If this node is a field or another element that doesn't
                // have a table specified, we need to determine where it
                // is targeted, so that we can set its' data type.
                if ($element->hasAttribute('table') === FALSE) {
                    if ($element->parentNode->hasAttribute('table') === TRUE) {
                        $targetNode = $element->parentNode;
                    } else if ($element->tagName === 'value') {
                        // Values only have column specified, so we need to
                        // find the fields node, underneath our parent.
                        $parent    = $element->parentNode->parentNode;
                        $fieldNode = $parent->getElementsByTagName('fields');
                        if ($fieldNode->length !== 0) {
                            $targetNode = $fieldNode->item(0);
                        }
                    } else if ($element->tagName === 'table') {
                        $placeTable = $nodeValue;
                        $targetNode = $element;
                    }
                } else {
                    // Element has its' table attribute specified.
                    $targetNode = $element;
                }

                if ($targetNode === NULL) {
                    continue;
                }

                if ($placeColumn === '') {
                    if ($targetNode->hasAttribute('column') === TRUE) {
                        $placeColumn = $targetNode->getAttribute('column');
                    } else {
                        // Column not specified, use the query name instead.
                        $placeColumn = $queryId;
                    }
                }

                if ($placeTable === '') {
                    if ($targetNode->hasAttribute('table') === TRUE) {
                        $placeTable = $targetNode->getAttribute('table');
                    } else {
                        // Table not specified, use the system name instead.
                        $placeTable = $systemName;
                    }
                }

                // Create the binding element, set its' attributes and
                // append it to the bindings tag of the fragment.
                $newPlaceHolder = $doc->createElement('placeholder');
                $varName        = $placeTable.' '.$placeColumn;
                $varName        = ucwords(str_replace('_', ' ', $varName));
                $varName        = ':'.str_replace(' ', '', $varName);
                $newPlaceHolder->setAttribute('value', $element->nodeValue);
                $newPlaceHolder->setAttribute('var_name', $varName);
                $placeParent->appendChild($newPlaceHolder);
                // Now replace the original node with the new var name.
                $element->nodeValue = $varName;
            }//end if childNodes->length === 1
        }//end foreach $allElements

        return $query;

    }//end _extractPlaceHolders()


    protected static function _getPdoDataType($systemId, $table, $column, $dataType=NULL)
    {
        if ($dataType === NULL) {
            $dataType = self::getTableColumnTypes($systemId, $table, $column);
        }

        switch (strtoupper($dataType)) {
            case 'NUMERIC':
            case 'DECIMAL':
            case 'INTEGER':
            case 'SMALLINT':
            case 'REAL':
            case 'DOUBLE PRECISION':
            case 'FLOAT':
                $pdoType = 'PDO::PARAM_INT';
            break;
            case 'BOOLEAN':
                $pdoType = 'PDO::PARAM_BOOL';
            break;
            default:
                $pdoType = 'PDO::PARAM_STR';
        }

        return $pdoType;

    }//end _getPdoDataType()


    public static function parseSchema(DomElement $schema)
    {
        require_once 'DAL/Parsers/DALSchemaParser.inc';

        return DALSchemaParser::parse($schema);

    }//end parseSchema()


    /*
        VALIDATE SQL QUERY
    */


    public static function validateQueries(DomElement $queries)
    {
        // Queries tag must have system attribute.
        if ($queries->getAttribute('system') === '') {
            throw new DALParserException('queries tag must have system attr.');
        }

        // Check that each query in this sytem have unique id.
        $ids = array();
        $qs  = $queries->getElementsByTagName('query');
        foreach ($qs as $query) {
            $id = $query->getAttribute('id');
            if (in_array($id, $ids) === TRUE) {
                throw new DALParserException('Query must have a unique id.');
            }

            $ids[] = $id;
        }

    }//end validateQueries()


    public static function queryIdIsUnique(DomDocument $doc, DomElement $query)
    {
        $xp    = new DOMXPath($doc);
        $qry   = '//query[@id = "'.$query->getAttribute('id').'"]';
        $nodes = $xp->query($qry);

        foreach ($nodes as $node) {
            if ($node !== $query) {
                return FALSE;
            }
        }

        return TRUE;

    }//end queryIdIsUnique()


    public static function validateQuery(DomElement $query)
    {
        $doc     = $query->ownerDocument;
        $queryId = $query->getAttribute('id');
        // Query must have id attribute.
        if ($queryId === '') {
            throw new DALParserException('Query must have id attribute.');
        } else if (self::queryIdIsUnique($doc, $query) === FALSE) {
            $msg  = 'Query must have a unique id. Id "'.$queryId;
            $msg .= '" already used by another query.';
            throw new DALParserException($msg);
        }

        $type = self::getQueryType($query);
        $fn   = 'validate'.ucwords($type).'Query';
        if (method_exists('DALBaker', $fn) === FALSE) {
            throw new DALParserException('Invalid validate query. Type:'.$type);
        } else {
            self::$fn($query);
        }

    }//end validateQuery()


    public static function getQueryType(DomElement $query)
    {
        foreach ($query->childNodes as $child) {
            if ($child->nodeType !== XML_ELEMENT_NODE) {
                continue;
            }

            return $child->tagName;
        }

    }//end getQueryType()


    public static function fragmentExists($system, $queryid, $hookid)
    {
        // Get hooks XML.
        list($hsysid, $hqid) = explode('.', $hookid);

        $doc = self::loadBakedQuery($hsysid, $hqid);
        if ($doc === NULL) {
            return FALSE;
        }

        $queries = $doc->getElementsByTagName('query');

        foreach ($queries as $query) {
            if ($query->getAttribute('id') === $queryid) {
                if ($query->getAttribute('system') === $system) {
                    return TRUE;
                }
            }
        }

        return FALSE;

    }//end fragmentExists()


    public static function convertToSql(DomElement $xmlQuery, array $sqlArray=array())
    {
        if (empty($sqlArray) === TRUE) {
            $sqlArray = self::constructSql($xmlQuery);
        }

        $converter = self::getConverter();
        return $converter->convertToSql($sqlArray['query']);

    }//end convertToSql()


    public static function getConverter($dbType=NULL)
    {
        if ($dbType === NULL) {
            $dbType = ucfirst(self::getDatabaseType());
        }

        // If there is no database type returned, the processing will still be
        // able to proceed, as the base type: "DALConverter" will be used.
        $converterClass = 'DAL'.$dbType.'Converter';
        require_once 'Converters/'.$converterClass.'.inc';
        // Here we will get the current DB type and use its converter class.
        $converter = eval("return new DAL$dbType".'Converter();');
        return $converter;

    }//end getConverter()


    public static function getTableColumnTypes($systemid, $table, $column=NULL)
    {
        if ($column === NULL) {
            $types = array();
        } else {
            $column = strtolower($column);
            $types  = NULL;
        }

        $doc = self::loadSystemSchemaXML($systemid);
        if ($doc === NULL) {
            return NULL;
        }

        // Find the table that we are looking for.
        $tables = $doc->getElementsByTagName('table');
        foreach ($tables as $currTable) {
            if ($currTable->getAttribute('name') === $table) {
                // Get table columns tag.
                $colsTag = $currTable->getElementsByTagName('columns')->item(0);
                $cols    = $colsTag->getElementsByTagName('column');
                foreach ($cols as $col) {
                    if ($column === strtolower($col->nodeValue)) {
                        return $col->getAttribute('type');
                    } else if ($column === NULL) {
                        $types[strtolower($col->nodeValue)] = $col->getAttribute('type');
                    }
                }

                return $types;
            }
        }//end foreach

        return NULL;

    }//end getTableColumnTypes()


    public static function getQuerySource($systemid, $queryid)
    {
        $queriesXML = self::loadQueriesXML($systemid);

        if ($queriesXML !== NULL) {
            // Get all query tags and check their id attr.
            $queries = $queriesXML->getElementsByTagName('query');
            foreach ($queries as $query) {
                if ($query->getAttribute('id') === $queryid) {
                    return $query;
                }
            }
        }

        return NULL;

    }//end getQuerySource()


    public static function createSystemOvenPath($system)
    {
        $ovenPath = DAL::getOvenPath($system);
        if (file_exists($ovenPath) === TRUE) {
            return FALSE;
        } else {
            if (mkdir($ovenPath, 0775, TRUE) === FALSE) {
                $msg = 'Could not create directory: '.$ovenPath;
                throw new ChannelException($msg);
            }
        }

        return TRUE;

    }//end createSystemOvenPath()


    public static function loadQueriesXML($systemid)
    {
        $fileName = Channels::getSystemsPath($systemid).'/DB/queries.xml';
        if (file_exists($fileName) === FALSE) {
            return NULL;
        }

        $doc = new DOMDocument();
        $doc->load($fileName);

        return $doc;

    }//end loadQueriesXML()


    public static function getBakedQueryFileName($systemid, $queryid)
    {
        $fileName = DAL::getOvenPath($systemid).'/'.$queryid.'.xml';
        return $fileName;

    }//end getBakedQueryFileName()


    public static function loadBakedQuery($systemid, $queryid)
    {
        $fileName = self::getBakedQueryFileName($systemid, $queryid);
        if (file_exists($fileName) === FALSE) {
            return NULL;
        }

        $doc = new DOMDocument();
        $doc->load($fileName);

        return $doc;

    }//end loadBakedQuery()


    public static function loadSystemSchemaXML($systemid)
    {
        $fileName = Channels::getSystemsPath($systemid).'/DB/schema.xml';
        if (file_exists($fileName) === FALSE) {
            return NULL;
        }

        $doc = new DOMDocument();
        $doc->load($fileName);

        return $doc;

    }//end loadSystemSchemaXML()


    /*
        XQD to PHP Query Conversions
    */


    public static function constructSql(DomElement $query)
    {
        $sql = array();

        // Require parser..
        require_once dirname(__FILE__).'/Parsers/DALQueryParser.inc';

        // Parse.
        $sql = DALQueryParser::parse($query);

        return $sql;

    }//end constructSql()


    public static function getHookPrefix()
    {
        $prefix = 'HOOKID:';
        return $prefix;

    }//end getHookPrefix()


    public static function getComparisonOperators($type=NULL)
    {
        if ($type !== NULL) {
            if (isset(self::$_whereConditions[$type]) === TRUE) {
                return self::$_whereConditions[$type];
            } else {
                return '';
            }
        }

        return self::$_whereConditions;

    }//end getComparisonOperators()


    public static function getDatabaseType($dsn=NULL)
    {
        if ($dsn === NULL) {
            $dbType = DAL::getDbType();
        } else {
            $dbType = $dsn['type'];
        }

        switch ($dbType) {
            case 'pgsql':
                $fullType = 'postgres';
            break;
            case 'oci':
                $fullType = 'oracle';
            break;
            case 'odbc':
                $fullType = 'db2';
            break;
            case 'dblib':
                $fullType = 'mssql';
            break;
            case 'mysql':
                $fullType = $dbType;
            break;
            default:
                $fullType = '';
        }

        return $fullType;

    }//end getDatabaseType()


}//end class

?>