SWAT/model2/SQuery.php5

<?php

class SQuery extends SObject {
    const MODE_SINGLE = 0;
    const MODE_TABLE_PREFIX = 1;
    const MODE_PREFIX = 2;
    const MODE_MULTI = 3;

    private $baseClass = null;
    private $mode = self::MODE_SINGLE;
    private $prefix = 'Base';
    private $depth = 1;
    private $criteria = array();
    private $limit = array();
    private $order = array();
    private $count = false;
    private $groupBy = array();
    private $having = array();

    private $extraJoins = array();
    private $extraAttrs = array();
    private $extraTables = array();

    // generated
    private $mapping = null;
    private $attributeList = null;
    private $query = '';

    public function __construct() {
        parent::__construct();
    }

    public function setBaseClass($cl) { $this->baseClass = $cl; }
    public function getBaseClass() { return $this->baseClass; }

    public function setMode($mode) {
        if($mode < 0 || $mode > 3)
            $this->setError("Invalid mode specified: " . htmlentities($mode));
        else
            $this->mode = $mode;
    }
    public function getMode() { return $this->mode; }

    public function setPrefix($prefix) {
        if(!is_string($prefix) || $prefix == "")
            $this->setError("Invalid prefix specified: " . htmlentities($prefix));
        else
            $this->prefix = $prefix;
    }
    public function getPrefix() { return $this->prefix; }

    public function setDepth($depth) {
        if(!ctype_digit((string)$depth) || $depth < 0 || $depth > 100)
            $this->setError("Invalid depth specified: '" . htmlentities($depth) . "'");
        else
            $this->depth = $depth;
    }
    public function getDepth() { return $this->depth; }

    public function setCriteria($criteria) {
        if(!is_array($criteria) && !is_string($criteria) && !is_numeric($criteria))
            $this->setError("Invalid criteria specified: " . htmlentities($criteria));
        else
            $this->criteria = $criteria;
    }
    public function getCriteria() { return $this->criteria; }

    public function setLimit($limit) {
        if(!is_array($limit))
            $this->setError("Invalid limit specified: " . htmlentities($limit));
        else
            $this->limit = $limit;
    }
    public function getLimit() { return $this->limit; }

    public function setOrder($order) {
        if(!is_array($order) && !is_string($order))
            $this->setError("Invalid order specified: " . htmlentities($order));
        else
            $this->order = $order;
    }
    public function getOrder() { return $this->order; }

    public function setCount($count) {
        if($count !== false && $count !== true)
            $this->setError("Invalid count specified: " . htmlentities($count));
        else
            $this->count = $count;
    }
    public function isCount() { return $this->count; }

    public function setGroupBy($groupBy) {
        if(!is_array($groupBy))
            $this->setError("Invalid group by specified: " . htmlentities($groupBy));
        else
            $this->groupBy = $groupBy;
    }
    public function getGroupBy() { return $this->groupBy; }

    public function setHaving($having) {
        if(!is_array($having) && !is_string($having) && !is_numeric($having))
            $this->setError("Invalid having specified: " . htmlentities($having));
        else
            $this->having = $having;
    }
    public function getHaving() { return $this->having; }

    public function setExtraJoins($extra) {
        if(!is_array($extra))
            $this->setError("Invalid extra joins specified: " . htmlentities($extra));
        else
            $this->extraJoins = $extra;
    }
    public function getExtraJoins() { return $this->extraJoins; }

    public function setExtraAttrs($extra) {
        if(!is_array($extra))
            $this->setError("Invalid extra attrs specified: " . htmlentities($extra));
        else
            $this->extraAttrs = $extra;
    }
    public function getExtraAttrs() { return $this->extraAttrs; }

    public function setExtraTables($extra) {
        if(!is_array($extra))
            $this->setError("Invalid extra tables specified: " . htmlentities($extra));
        else
            $this->extraTables = $extra;
    }
    public function getExtraTables() { return $this->extraTables; }

    public function getMapping() { return $this->mapping; }
    public function getAttributeList() { return $this->attributeList; }
    public function getQuery() { return $this->query; }

    public function buildMapping() {
        $class = $this->baseClass;
        $mode = $this->mode;
        $multiDepth = $this->depth;

        $attrArray = array();
        $attrMap = array();

        if($mode !== self::MODE_MULTI) {
            $attrs = call_user_func(array($class, 'getAttributesStatic'));
            $table = call_user_func(array($class, 'getTableNameStatic'));
            foreach($attrs as $attr => $info) {
                if($info['type'] != 'int' && $info['type'] != 'string' && $info['type'] != 'float' && $info['type'] != 'time')
                    continue;
                if(isset($info['commit']) && $info['commit'] == SModel2::COMMIT_NOSOURCE)
                    continue;
                if($mode === self::MODE_SINGLE) {
                    $attrArray[] = "$table.$attr AS $attr";
                    $attrMap[$attr] = "$table.$attr";
                }
                else if($mode === self::MODE_TABLE_PREFIX) {
                    $attrArray[] = "$table.$attr AS `$table.$attr`";
                    $attrMap["$table.$attr"] = "$table.$attr";
                    $attrMap[$attr] = "$table.$attr";
                }
                else if($mode == self::MODE_PREFIX) {
                    $attrArray[] = "`$this->prefix`.$attr AS `$this->prefix.$attr`";
                    $attrMap["$this->prefix.$attr"] = "`$this->prefix`.$attr";
                    $attrMap[$attr] = "`$this->prefix`.$attr";
                }
            }

            $this->mapping = array(
                $this->prefix => array(
                    $table, 'FROM ' . $table .
                        ($mode !== self::MODE_SINGLE && $mode !== self::MODE_TABLE_PREFIX ? " AS $this->prefix" : ''),
                    $attrArray, $attrMap
                )
            );

            $this->attributeList = implode(', ', $attrArray);
        }
        else {
            $childAttrs = call_user_func(array($class, 'getAttributesStatic'));
            $childName = call_user_func(array($class, 'getTableNameStatic'));
            $childAttrArray = array();
            $childAttrMap = array();
            foreach($childAttrs as $attr => $attrInfo) {
                if(SDatabaseModel::isDatabaseAttributeStatic($attrInfo)) {
                    $childAttrArray[] = "`$this->prefix`.$attr AS `$this->prefix.$attr`";
                    $childAttrMap["$this->prefix.$attr"] = "`$this->prefix`.$attr";
                    $childAttrMap[$attr] = "`$this->prefix`.$attr";
                }
            }
            $this->attributeList = implode(', ', $childAttrArray);
            $mapping = array();
            $mapping[$this->prefix] = array($childName, 'FROM ' . $childName . ' AS `' . $this->prefix . '`', $childAttrArray, $childAttrMap);

            $deps = eval("return $class" . "::\$DEPENDENCIES;");

            if($multiDepth > 0)
                $this->genAttrsRec($this->prefix, $class, $this->prefix, $deps, $mapping, $depsSeen, $multiDepth);

            if(count($this->extraTables) > 0) {
                foreach($this->extraTables as $prefix => $class) {
                    $clAttrs = call_user_func(array($class, 'getAttributesStatic'));
                    $table = call_user_func(array($class, 'getTableNAmeStatic'));
                    $attrs = array();
                    $attrMaps = array();
                    foreach($clAttrs as $a => $info) {
                        if(SDatabaseModel::isDatabaseAttributeStatic($info)) {
                            $attrs[] = "`$prefix`.$a AS `$prefix.$a`";
                            $attrMaps["$prefix.$a"] = "`$prefix`.$a";
                        }
                    }
                    $mapping[$prefix] = array($table, null, $attrs, $attrMaps);
                }
            }

            ksort($mapping);
            $this->mapping = $mapping;
        }
    }

    private function genAttrsRec($prefix, $curTable, $curName, $deps, &$mapping, &$depsSeen, $depth) {
        // generate child table listing and alias mappings
        if(!isset($deps[$curTable]))
            return;

        $toDo = array();

        $parAttrs = call_user_func(array($curTable, 'getAttributesStatic'));
        foreach($deps[$curTable] as $child => $parentRef) {
            $childName = call_user_func(array($child, 'getTableNameStatic'));
            $fAttrInfo = $parAttrs[$parentRef];

            if($prefix == '')
                $newPrefix = $fAttrInfo['foreign']['object'];
            else
                $newPrefix = $prefix . '.' . $fAttrInfo['foreign']['object'];

            if(isset($depsSeen[$curTable . $child]))
                continue;

            $depsSeen[$curTable . $child] = true;

            $mapping[$newPrefix] = array(
                $fAttrInfo['foreign']['table'],
                "LEFT JOIN {$fAttrInfo['foreign']['table']} AS `$newPrefix` ON `$newPrefix`.id = `$prefix`.$parentRef"
            );

            $childAttrArray = array();
            $childAttrMap = array();
            $childAttrs = call_user_func(array($child, 'getAttributesStatic'));

            foreach($childAttrs as $attr => $attrInfo) {
                if(SDatabaseModel::isDatabaseAttributeStatic($attrInfo)) {
                    $childAttrArray[] = "`$newPrefix`.$attr AS `$newPrefix.$attr`";
                    $childAttrMap["$newPrefix.$attr"] = "`$newPrefix`.$attr";
                }
            }

            $this->attributeList += ', ' . implode(', ', $childAttrArray);

            $mapping[$newPrefix][] = $childAttrArray;
            $mapping[$newPrefix][] = $childAttrMap;

            $toDo[] = array($newPrefix, $child, $childName);
        }

        $depth--;
        if($depth > 0) {
            foreach($toDo as $item) {
                $this->genAttrsRec($item[0], $item[1], $item[2], $deps, $mapping, $depsSeen, $depth);
            }
        }
    }

    public function buildQuery() {
        STimer::start('buildQuery');

        if($this->mapping == null)
            $this->buildMapping();

        $mapping = $this->mapping;

        $attrs = array();
        $attrMaps = array();
        $joins = '';

        foreach($mapping as $prefix => $info) {
            if(!$this->count)
                $attrs[] = implode(',', $info[2]);
            if($info[1] != null)
                $joins .= "\n" . $info[1];
            if($info[3] !== null)
                $attrMaps += $info[3];
        }

        if(count($this->extraAttrs) > 0) {
            foreach($this->extraAttrs as $a => $b) {
                if(ctype_digit((string)$a)) {
                    $attrs[] = "`$b`";
                    $attrMaps["$b"] = $b;
                }
                else {
                    $attrs[] = "$a AS `$b`";
                    $attrMaps["$b"] = "`$b`";
                }
            }
        }

        if($this->count)
            $query = 'SELECT COUNT(*) ' . $joins;
        else
            $query = 'SELECT ' . implode(",\n", $attrs) . $joins;

        if(count($this->extraJoins) > 0)
            $query .= ' ' . implode(' ', $this->extraJoins);

        if(count($this->criteria) > 0) {
            $criteriaStr = DBI2::criteriaToString($this->criteria, count($attrMaps) > 0 ? $attrMaps : null);
            if($criteriaStr === false)
                return false;
            if($criteriaStr != '')
                $query .= " WHERE $criteriaStr";
        }

        if(count($this->groupBy) > 0)
            $query .= ' GROUP BY ' . implode(',', $this->groupBy);

        if(count($this->having) > 0) {
            $havingStr = DBI2::criteriaToString($this->having, count($attrMaps) > 0 ? $attrMaps : null);
            if($havingStr === false)
                return false;
            if($havingStr != '')
                $query .= ' HAVING ' . $havingStr;
        }

        if(count($this->order) > 0) {
            $orderStr = DBI2::orderToString($this->order, count($attrMaps) > 0 ? $attrMaps : null);
            if($orderStr === false)
                return false;
            if($orderStr != '')
                $query .= $orderStr;
        }

        if(count($this->limit) > 0) {
            $limitStr = DBI2::limitToString($this->limit);
            if($limitStr === false)
                return false;
            if($limitStr != '')
                $query .= $limitStr;
        }

        if($this->count && count($this->groupBy) > 0)
            $query = "SELECT COUNT(*) FROM ($query) AS t";

//      print "Query: $query<br />";

        STimer::end('buildQuery');

        $this->query = $query;
        return $query;
    }
}

?>

---