vitalif
/
olap
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

New template, new mysql lib, refactoring, support PHP data generators

master
vitalif 2011-09-14 22:12:06 +00:00
parent 78fd2e11c3
commit 91d4d05161
3 changed files with 1100 additions and 457 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
lib/mysql.php
View File

@ -286,11 +286,14 @@ function mysql_tables_builder($tables)
$join = 'LEFT';
else /* if (!$join || $join == 'inne' || $join == 'join') */
$join = 'INNER';
$table = ($cfgTables[$v[1]] ? '`'.$cfgTables[$v[1]].'`' : $v[1]);
if ($t)
$t .= " $join JOIN $table $k ON ".mysql_where_builder($v[2]);
if (is_array($v[1])) // nested join (left join (A join B on ...) on ...)
$table = '('.mysql_tables_builder($v[1]).')';
else
$t = "$table $k";
$table = ($cfgTables[$v[1]] ? '`'.$cfgTables[$v[1]].'`' : $v[1]) . ' ' . $k;
if ($t)
$t .= " $join JOIN $table ON ".mysql_where_builder($v[2]);
else
$t = $table;
continue;
}
else

841
lib/template.php
View File

File diff suppressed because it is too large Load Diff

705
olap.php
View File

@ -3,7 +3,7 @@
# Простая OLAPообразная статистика
# См. http://yourcmc.ru/wiki/Общий_вид_статистики
# admin_olap.tpl, admin_olap_csv.tpl
# (c) Vitaliy Filippov 2010
# (c) Vitaliy Filippov 2010+
$is_adm = true;
require_once 'lib/templating.php';
@ -25,14 +25,16 @@ if ($modified)
exit;
}
OLAP::execute($_REQUEST);
$olap = new OLAP($_GET+$_POST);
$olap->execute();
exit;
# TODO уметь горизонтальные графики, уметь комбинировать графики с другими группировками (возможно, кроме горизонтали)
class OLAP
{
static $initialised;
static $sources;
static $current_srcid, $current_src;
static $add_spanned;
static $functions = array(
'year' => array('name' => 'Год', 'time_format' => 'Y', 'sql' => 'SUBSTR($,1,4)'),
'month' => array('name' => 'Месяц', 'time_format' => 'Y-m', 'sql' => 'SUBSTR($,1,7)'),
@ -44,13 +46,13 @@ class OLAP
'second' => array('name' => 'Секунда', 'time_format' => 'H:i:s', 'sql' => 'DATE_FORMAT($, "%k:%i:%s")'),
);
static $aggregates = array(
'count' => array('name' => 'Количество', 'sql' => 'COUNT($)'),
'sum' => array('name' => 'Сумма', 'sql' => 'SUM($)'),
'avg' => array('name' => 'Среднее', 'sql' => 'AVG($)'),
'min' => array('name' => 'Минимум', 'sql' => 'MIN($)'),
'max' => array('name' => 'Максимум', 'sql' => 'MAX($)'),
'stddev' => array('name' => 'Дисперсия', 'sql' => 'STDDEV($)'),
'n_uniq' => array('name' => 'Количество уникальных', 'sql' => 'COUNT(DISTINCT $)'),
'count' => array('name' => 'Количество', 'sql' => 'COUNT($)'),
'sum' => array('name' => 'Сумма', 'sql' => 'SUM($)'),
'avg' => array('name' => 'Среднее', 'sql' => 'AVG($)'),
'min' => array('name' => 'Минимум', 'sql' => 'MIN($)'),
'max' => array('name' => 'Максимум', 'sql' => 'MAX($)'),
'stddev' => array('name' => 'Дисперсия', 'sql' => 'STDDEV($)'),
'n_uniq' => array('name' => 'Количество уникальных', 'sql' => 'COUNT(DISTINCT $)'),
);
static $group_types = array(
'tables' => 'Несколько таблиц',
@ -59,46 +61,78 @@ class OLAP
'cell' => 'В ячейке',
'graph' => 'График',
);
static $cell = array();
static function execute($request)
var $request;
var $current_srcid, $current_src;
var $time_start, $nfields, $build, $csv;
var $where, $where_nosql, $group_fields, $cell;
var $is_html_format = true;
var $add_spanned;
var $decimal = '%.3f';
var $graph_scale = 600; /* пикселей */
var $graph_logarithmic = false;
function __construct($request)
{
$this->time_start = microtime(true);
$this->request = $request;
if (!self::$initialised)
self::initialise();
$this->parse_request();
}
static function initialise()
{
global $template;
set_time_limit(300);
$time_start = microtime(true);
$template->compiletime_functions['fformat'] = "OLAP::tpl_field_format";
$template->compiletime_functions['fformat'] = 'OLAP::tpl_field_format';
foreach (self::$sources as $k => &$s)
$s['id'] = $k;
/* выбираем источник данных */
self::$current_srcid = $request['datasource'];
self::$current_src = self::$sources[self::$current_srcid];
$template->vars('sources', array_values(self::$sources));
if (!self::$current_src)
{
$template->vars('select', true);
print $template->parse('admin_olap.tpl');
exit;
$s['id'] = $k;
if (empty($s['where']))
$s['where'] = array();
}
foreach (self::$group_types as $k => $v)
self::$group_types[$k] = array('id' => $k, 'num' => $i++, 'name' => $v);
foreach (self::$functions as $k => &$v)
$v['id'] = $k;
foreach (self::$aggregates as $k => &$v)
$v['id'] = $k;
self::$initialised = true;
}
/* задаём параметры соединения с БД из источника*/
function parse_request()
{
$request = &$this->request;
// выбираем источник данных
$this->current_srcid = $request['datasource'];
$this->current_src = self::$sources[$this->current_srcid];
if (!$this->current_src)
return;
// задаём параметры соединения с БД из источника
global $db, $dbhost, $dbuser, $dbpwd;
if (self::$current_src['db'])
list($db, $dbhost, $dbuser, $dbpwd) = self::$current_src['db'];
if (!empty($this->current_src['db']))
list($db, $dbhost, $dbuser, $dbpwd) = $this->current_src['db'];
/* дополняем всяким бредом всякий бред */
foreach (self::$current_src['fielddescs'] as $k => &$v)
// Дополняем всяким бредом всякий бред
foreach ($this->current_src['fielddescs'] as $k => &$v)
{
$v['id'] = $k;
if ($v['autofilter'])
if (!empty($v['autofilter']))
{
$f = $v['sql'];
if (!$f)
$f = $k;
$v['options'] = mysql_select(self::$current_src['tables'], "$f id, $f name", self::$current_src['where'], array('GROUP BY' => $f));
$v['options'] = mysql_select(
$this->current_src['tables'],
"$f id, $f name",
$this->current_src['where'],
array('GROUP BY' => $f)
);
}
if ($v['options'])
if (!empty($v['options']))
{
if (is_callable($v['options']))
$v['options'] = call_user_func($v['options']);
@ -106,211 +140,178 @@ class OLAP
$v['options_hash'][$o['id']] = $o['name'];
}
}
foreach (self::$functions as $k => &$v)
$v['id'] = $k;
foreach (self::$aggregates as $k => &$v)
$v['id'] = $k;
unset($v);
$i = 0;
foreach (self::$group_types as $k => $v)
self::$group_types[$k] = array('id' => $k, 'num' => $i++, 'name' => $v);
/* читаем параметры запроса */
$wh = array();
$where = array();
$group_fields = array();
// читаем параметры запроса
$this->where = array();
$this->where_nosql = array();
$this->group_fields = array();
foreach ($request as $k => $v)
{
/* условия выборки: where-ОПЕРАЦИЯ-ПОЛЕ = ЗНАЧЕНИЕ */
// условия выборки: where-ОПЕРАЦИЯ-ПОЛЕ = ЗНАЧЕНИЕ
if (substr($k, 0, 6) == 'where-')
{
list($t, $f) = explode('-', substr($k, 6), 2);
$fd = &self::$current_src['fielddescs'][$f];
$fd = &$this->current_src['fielddescs'][$f];
if (!$fd)
{
$f = str_replace('_', ' ', $f);
$fd = &self::$current_src['fielddescs'][$f];
$fd = &$this->current_src['fielddescs'][$f];
}
if (!$fd || !strlen($v))
continue;
$wh[$k] = $v;
if ($fd['is_time'])
$v = Template::timestamp($v, self::$current_src['fielddescs'][$f]['format']);
$dn = $fd['sql'];
if (!$dn)
$dn = $f;
$this->request[$k] = $v;
if (!empty($fd['is_time']))
$v = Template::timestamp($v, $this->current_src['fielddescs'][$f]['format']);
$this->where_nosql[] = array($f, $t, $v);
$dn = !empty($fd['sql']) ? $fd['sql'] : $f;
$ve = mysql_ecranize($v);
if ($t == 'eq')
{
$where[] = "$dn = $ve";
if ($fd['sql_eq'])
$this->where[] = str_replace('$', $ve, $fd['sql_eq']);
else
$this->where[] = "$dn = $ve";
if ($fd['options'])
foreach ($fd['options'] as &$o)
if ("$o[id]" === $v)
$o['selected'] = true;
}
elseif ($t == 'ge' && $fd['le_ge'])
$where[] = "$dn >= $ve";
$this->where[] = "$dn >= $ve";
elseif ($t == 'le' && $fd['le_ge'])
$where[] = "$dn <= $ve";
$this->where[] = "$dn <= $ve";
else
unset($wh[$k]);
unset($this->request[$k]);
}
/* описание группировки */
// описание группировки
elseif (substr($k, 0, 11) == 'group-type-')
{
$i = substr($k, 11);
$gf = array();
foreach(array('type', 'field', 'func', 'sort_dir', 'sort_field', 'sort_aggr', 'sort_func') as $k)
$gf[$k] = $request["group-$k-$i"];
if (self::$group_types[$gf['type']] && strlen($gf['field']) &&
($gf['type'] != 'graph' || !$request['csv']))
if ($request['csv'] && $gf['type'] == 'graph')
$gf['type'] = 'tr';
if (self::$group_types[$gf['type']] && $gf['field'] !== '')
{
$gf['num'] = count($group_fields);
$group_fields[] = $gf;
$gf['num'] = count($this->group_fields);
$this->group_fields[] = $gf;
}
}
}
usort($group_fields, 'OLAP::group_type_cmp');
usort($this->group_fields, 'OLAP::group_type_cmp');
$nfields = intval($request['field_count']);
if ($nfields <= 0)
$nfields = 5;
if (count($group_fields) > $nfields)
$nfields = count($group_fields);
// Число мест под поля группировки
$this->nfields = intval($request['field_count']);
if ($this->nfields <= 0)
$this->nfields = 5;
if (count($this->group_fields) > $this->nfields)
$this->nfields = count($this->group_fields);
/* описание показателя */
// Описание показателя
foreach(array('field', 'func', 'aggr') as $x)
self::$cell[$x] = $request["cell_$x"];
$this->cell[$x] = $request["cell_$x"];
// Запрос на построение?
$this->build = !empty($request['build']);
$this->csv = !empty($request['csv']);
if ($this->csv)
{
$this->add_spanned = true;
$this->is_html_format = false;
}
}
function execute()
{
global $template;
// Сельф
$template->vars('olap', $this);
// Если источник ещё не выбран, выдаём форму выбора
if (!$this->current_src)
{
$template->vars('sources', array_values(self::$sources));
$template->vars('select', true);
print $template->parse('admin_olap.tpl');
return;
}
$template->vars(array(
'wh' => $wh,
'group_fields' => $group_fields,
'cell' => &self::$cell,
'rpt_link' => "?".http_build_query($this->request),
'request' => $this->request,
'group_fields' => $this->group_fields,
'cell' => &$this->cell,
'field_count' => $this->nfields,
'srcid' => $this->current_srcid,
'src' => $this->current_src,
'fielddescs' => array_values($this->current_src['fielddescs']),
'group_types' => array_values(self::$group_types),
'field_count' => $nfields,
'srcid' => self::$current_srcid,
'src' => self::$current_src,
'fielddescs' => array_values(self::$current_src['fielddescs']),
'functions' => array_values(self::$functions),
'aggregates' => array_values(self::$aggregates),
));
$cell = &self::$cell;
if (!$request['build'])
if (!$this->build)
{
print $template->parse('admin_olap.tpl');
exit;
}
$fields = array();
$group_by = array();
foreach ($group_fields as $i => &$v)
// читаем сами данные, заодно наборы значений для заглавных строк таблицы,
// заодно полные наборы значений для каждого поля
// т.к. наборы значений для заглавных столбцов таблицы берутся из самих данных
$data = $tdkeys = NULL;
$tdk_group = array();
$output = array(
array('output' => &$data, 'group_by' => $this->group_fields),
array('output' => &$tdkeys, 'group_by' => &$tdk_group),
);
foreach ($this->group_fields as $i => &$v)
{
$v['sql'] = self::sql_trans_field($v['field'], $v['func']);
$v['keys'] = array();
$fields[] = $v['sql'].' f'.$i;
$group_by[] = $v['sql'];
$output[] = array('output' => &$v['keys'], 'group_by' => array($v));
if ($v['type'] == 'tables' || $v['type'] == 'td')
$tdk_group[] = $v;
}
$this->load($this->cell['field'], $this->cell['func'], $this->cell['aggr'], $output);
$cell['sql'] = self::sql_trans_field($cell['field'], $cell['func']);
if (self::$aggregates[$cell['aggr']]['sql'])
$fields[] = str_replace('$', $cell['sql'], self::$aggregates[$cell['aggr']]['sql']).' c';
else
{
/* поддерживаются агрегатные функции, вычисляемые внутри PHP, а не в базе */
$do_aggr = true;
$fields[] = $cell['sql'].' c';
$group_by[] = $cell['sql'];
}
/* сохраняем данные в $data и наборы значений для колонок в $tdkeys */
$result = mysql_select(self::$current_src['tables'], $fields, array_merge(self::$current_src['where'], $where), array('GROUP BY' => $group_by), MS_RESULT);
$data = array();
$tdkeys = array();
while ($r = mysql_fetch_assoc($result))
{
$dv = &$data;
$tdv = &$tdkeys;
foreach ($group_fields as $i => &$v)
{
$v['keys'][$r["f$i"]] = true;
$dv = &$dv[$r["f$i"]];
if ($v['type'] == 'tables' || $v['type'] == 'td')
{
if (!$tdv[$r["f$i"]])
$tdv[$r["f$i"]] = array();
$tdv = &$tdv[$r["f$i"]];
}
}
if ($do_aggr)
call_user_func_array('self::aggr_update_'.$cell['aggr'], array(&$dv, &$r['c']));
else
$dv = $r['c'];
}
/* поддерживается "завершение" вычисления агрегатных функций, которые вне базы */
if ($do_aggr && is_callable('self::aggr_finish_'.$cell['aggr']))
{
$code = '';
$upd = 'self::aggr_finish_'.$cell['aggr'].'(&$v'.(count($group_fields)-1);
foreach ($group_fields as $i => &$v)
{
$code .= 'foreach('.($i ? '$v'.($i-1) : '$data').' as $k'.$i.' => $v'.$i.') ';
$upd .= ', $k'.$i;
}
$code .= $upd;
eval($code);
}
/* читаем значения, по которым следует сортировать значения полей группировки */
foreach ($group_fields as $i => &$v)
// читаем значения, по которым следует сортировать значения полей группировки
// т.е. значения поля можно сортировать по агрегату другого поля
foreach ($this->group_fields as $i => &$v)
{
$fields = array();
$group_by = array();
$v_group = array();
if (strlen($v['sort_aggr']) && strlen($v['sort_field']))
{
$code = 'while($r = mysql_fetch_assoc($result)) { $v[\'sort\']';
foreach ($group_fields as $j => $prev)
{
if ($j > $i)
break;
/* сюда также включается само поле $v! */
if ($prev['type'] == 'tables' || $prev['type'] == $v['type'])
{
$fields[] = $prev['sql']." f$j";
$group_by[] = $prev['sql'];
$code .= "[\$r['f$j']]";
}
}
$code .= ' = $r[\'s\']; }';
$v['sort_sql'] = self::sql_trans_field($v['sort_field'], $v['sort_func']);
$fields[] = str_replace('$', $v['sort_sql'], self::$aggregates[$v['sort_aggr']]['sql']).' s';
$result = mysql_select(self::$current_src['tables'], $fields, array_merge(self::$current_src['where'], $where), array('GROUP BY' => $group_by), MS_RESULT);
eval($code);
// группировка по всем полям tables + того же типа,
// предшествующим это, включая само поле
for ($j = 0; $j <= $i; $j++)
if ($this->group_fields[$j]['type'] == 'tables' ||
$this->group_fields[$j]['type'] == $v['type'])
$v_group[] = $this->group_fields[$j];
$this->load($v['sort_field'], $v['sort_func'], $v['sort_aggr'],
array(array('output' => &$v['sort'], 'group_by' => $v_group))
);
}
$v['keys'] = array_keys($v['keys']);
if (count($group_by) <= 1)
if (count($v_group) <= 1)
self::do_sort($v['keys'], $v['sort'], $v['sort_dir']);
}
if ($request['csv'])
self::$add_spanned = true;
$vars = array(
'build' => 1,
'rpt_link' => "?".http_build_query($_GET+$_POST),
);
if ($group_fields[0]['type'] == 'graph')
$vars['graphs'] = self::build_graphs($group_fields, $data, $tdkeys);
$vars = array('build' => 1);
if ($this->group_fields[0]['type'] == 'graph')
$vars['graphs'] = $this->build_graphs($this->group_fields, $data, $tdkeys);
else
{
$vars['tables'] = self::build_tables($group_fields, $data, $tdkeys);
$vars['csv_link'] = "?csv=1&".http_build_query($_GET+$_POST);
}
$vars['tables'] = $this->build_tables($this->group_fields, $data, $tdkeys);
if (!$this->csv)
$vars['csv_link'] = "?csv=1&".http_build_query($this->request);
$vars['memory'] = file_size_string(memory_get_usage());
$vars['time_elapsed'] = sprintf("%.3f", microtime(true)-$time_start);
$vars['time_elapsed'] = sprintf("%.3f", microtime(true) - $this->time_start);
$template->vars($vars);
if ($request['csv'])
if ($this->csv)
{
header("Content-Type: text/csv; charset=windows-1251");
header("Content-Disposition: inline; filename=OLAP-".date('YmdHis').".csv");
@ -321,9 +322,141 @@ class OLAP
print $template->parse('admin_olap.tpl');
}
static $graph_scale = 600; /* пикселей */
static $graph_logarithmic = false;
static function build_graphs($fields, &$data, &$tdkeys)
// Загрузка данных из текущего источника, сама выбирает способ - SQL или программный
// $field, $func, $aggr - поле, преобразование, агрегатная функция
// $output - спецификация того, куда записать результат - массив массивов вида:
// array('output' => &$array, 'group_by' => <часть_полей_группировки>)
function load($field, $func, $aggr, $output)
{
if (!empty($this->current_src['use_pgm']) ||
!empty($this->current_src['sql_filter']))
return $this->load_pgm($field, $func, $aggr, $output);
else
return $this->load_sql($field, $func, $aggr, $output);
}
// Загрузка данных с группировкой и подсчётом показателей через SQL
// FIXME корректно вычисляется только первый, остальные по сути просто заполняются
// наборами ключей с некоторыми значениями, не равными правильным агрегатам.
function load_sql($field, $func, $aggr, $output)
{
$group_fields = $output[0]['group_by'];
$fields = array();
$group_by = array();
foreach ($group_fields as $i => &$v)
{
$v['sql'] = $this->sql_trans_field($v['field'], $v['func']);
$v['keys'] = array();
$fields[] = $v['sql'].' f'.$i;
$group_by[] = $v['sql'];
}
$sql = $this->sql_trans_field($field, $func);
$fields[] = str_replace('$', $sql, self::$aggregates[$aggr]['sql']).' c';
$code = 'while($r = mysql_fetch_assoc($result)) { ';
foreach ($output as $k => $o)
{
$asgn = '$output['.intval($k).'][\'output\']';
foreach ($o['group_by'] as $f)
$asgn .= '[$r[\'f'.$f['num'].'\']]';
$code .= $asgn . ' = $r[\'c\']; ';
}
$code .= '}';
$result = mysql_select(
$this->current_src['tables'], $fields,
array_merge($this->current_src['where'], $this->where),
array('GROUP BY' => $group_by),
MS_RESULT
);
eval($code);
}
// Загрузка данных с группировкой и подсчётом показателей в PHP
function load_pgm($field, $func, $aggr, $output)
{
$code = '';
foreach ($output as $k => $o)
{
$asgn = '$output['.intval($k).'][\'output\']';
foreach ($o['group_by'] as $f)
$asgn .= '['.$this->func_trans_field($f['field'], $f['func']).']';
$code .= "self::aggr_update_$aggr($asgn, ".$this->func_trans_field($field, $func).");\n";
}
if ($gen = $this->current_src['generator'])
{
// Загрузка данных не из базы, а из произвольной функции
$code = 'while($r = $result->fetch()) { ' . $code . '}';
}
elseif ($pipe = $this->current_src['sql_filter'])
{
// Поддержка фильтрации данных через дополнительную функцию
$code = 'while($row = mysql_fetch_assoc($result)) { foreach('.
$pipe.'($row) as $r) { '.$code.'} } '.
'foreach('.$pipe.'(NULL) as $r) { '.$code.'}';
}
else
$code = 'while($r = mysql_fetch_assoc($result)) { ' . $code . '}';
// "Завершение" вычисления агрегата
if (is_callable('self::aggr_finish_'.$aggr))
{
foreach ($output as $k => $o)
{
$var = '$output['.intval($k).'][\'output\']';
foreach ($o['group_by'] as $i => $f)
{
$code .= "foreach($var as &\$a$i) ";
$var = '$a'.$i;
}
$code .= "self::aggr_finish_$aggr($var);";
}
}
$fields = array();
foreach ($output as $k => $o)
foreach ($o['group_by'] as $f)
$fields[$f['field']] = true;
if ($field)
$fields[$field] = true;
foreach ($this->current_src['fielddescs'] as $f => $a)
if (!empty($a['mandatory']))
$fields[$f] = true;
foreach ($fields as $f => &$v)
{
$a = $this->current_src['fielddescs'][$f];
$v = $a['sql'] ? $a['sql'] . ' ' . $f : $f;
}
$fields = array_values($fields);
if ($gen = $this->current_src['generator'])
{
// Функция, принимает массив имён нужных полей и ограничения в формате
// [ поле, оператор, значение ] и должна возвращать объект, умеющий fetch()
$result = call_user_func($gen, array(
'fields' => array_keys($fields),
'fields_sql' => $fields,
'where' => $this->where_nosql,
'where_sql' => $this->where,
));
}
else
{
// SQL
$result = mysql_select(
$this->current_src['tables'], $fields,
array_merge($this->current_src['where'], $this->where),
$this->current_src['sql_options'],
MS_RESULT
);
}
eval($code);
}
// Построение "графиков" - рядом с цифрой рисуется горизонтальная полоса пропорциональной длины
function build_graphs($fields, &$data, &$tdkeys)
{
$my = array_shift($fields);
$keys = $my['sort'] ? array_keys($my['sort']) : $my['keys'];
@ -341,13 +474,13 @@ class OLAP
foreach ($fields as &$v)
if ($v['orig_sort'])
$v['sort'] = &$v['orig_sort'][$k];
$gr = self::build_graphs($fields, $data[$k], $tdkeys);
$gr = $this->build_graphs($fields, $data[$k], $tdkeys);
foreach ($gr as &$g)
{
array_unshift($g['desc'], array(
'field' => self::$current_src['fielddescs'][$my['field']]['name'],
'field' => $this->current_src['fielddescs'][$my['field']]['name'],
'func' => self::$functions[$my['func']]['name'],
'value' => self::field_format($my['field'], '', '', $k)
'value' => $this->field_format($my['field'], '', '', $k)
));
$graphs[] = $g;
}
@ -358,8 +491,8 @@ class OLAP
{
$gr = array(
'desc' => array(),
'field' => self::$current_src['fielddescs'][$my['field']]['name'],
'func' => self::$functions[$my['func']]['name'],
'field' => $this->current_src['fielddescs'][$my['field']]['name'],
'func' => self::$functions[$my['func']]['name'],
'data' => array(),
'max' => NULL,
'min' => NULL,
@ -369,7 +502,7 @@ class OLAP
if (array_key_exists($k, $data))
{
$v = $ov = floatval($data[$k]);
if (self::$graph_logarithmic)
if ($this->graph_logarithmic)
{
if ($v >= 1)
$v = 1+log($v);
@ -377,7 +510,7 @@ class OLAP
$v = -1-log(-$v);
}
$ov = str_replace('.00', '', sprintf("%.2f", $ov));
$gr['data'][] = array(self::field_format($my['field'], '', '', $k), $ov, $v, 0);
$gr['data'][] = array($this->field_format($my['field'], '', '', $k), $ov, $v, 0);
if ($gr['max'] === NULL || $gr['max'] < $v)
$gr['max'] = $v;
if ($gr['min'] === NULL || $gr['min'] > $v)
@ -396,12 +529,12 @@ class OLAP
{
if ($d[2] >= 0)
{
$d[2] = intval($d[2]/$gr['max']*self::$graph_scale/2);
$d[2] = intval($d[2]/$gr['max']*$this->graph_scale/2);
$d[3] = 0;
}
else
{
$d[3] = intval($d[2]/$gr['min']*self::$graph_scale/2);
$d[3] = intval($d[2]/$gr['min']*$this->graph_scale/2);
$d[2] = 0;
}
}
@ -409,7 +542,7 @@ class OLAP
else
{
foreach ($gr['data'] as &$d)
$d[2] = intval($d[2]/$gr['max']*self::$graph_scale);
$d[2] = intval($d[2]/$gr['max']*$this->graph_scale);
}
}
$graphs[] = $gr;
@ -417,7 +550,8 @@ class OLAP
return $graphs;
}
static function recurse_tables($fields, &$bytype, &$data, &$tdkeys)
// Рекурсивное построение набора HTML-таблиц
function recurse_tables($fields, &$bytype, &$data, &$tdkeys)
{
if ($fields && $fields[0]['type'] == 'tables')
{
@ -435,13 +569,13 @@ class OLAP
foreach ($fields as &$v)
if ($v['orig_sort'])
$v['sort'] = &$v['orig_sort'][$k];
$sub = self::recurse_tables($fields, $bytype, $data[$k], $tdkeys[$k]);
$sub = $this->recurse_tables($fields, $bytype, $data[$k], $tdkeys[$k]);
foreach ($sub as &$t)
{
array_unshift($t['desc'], array(
'field' => self::$current_src['fielddescs'][$my['field']]['name'],
'field' => $this->current_src['fielddescs'][$my['field']]['name'],
'func' => self::$functions[$my['func']]['name'],
'value' => self::field_format($my['field'], '', '', $k)
'value' => $this->field_format($my['field'], '', '', $k)
));
$tables[] = $t;
}
@ -449,9 +583,9 @@ class OLAP
}
return $tables;
}
$tdhead = self::recurse_head($bytype['td'], $tdkeys);
$trhead = self::recurse_head($bytype['tr'], $data);
$cells = self::recurse_cells($fields, $data, $tdkeys);
$tdhead = $this->recurse_head($bytype['td'], $tdkeys);
$trhead = $this->recurse_head($bytype['tr'], $data);
$cells = $this->recurse_cells($fields, $data, $tdkeys);
if (!is_array($cells))
$cells = array(array($cells));
$rows = array();
@ -516,10 +650,11 @@ class OLAP
return array($table);
}
static function recurse_cells($fields, &$data, &$tdkeys)
// Рекурсивное построение тела таблицы
function recurse_cells($fields, &$data, &$tdkeys)
{
if (!$fields)
return self::field_format(self::$cell['field'], self::$cell['func'], self::$cell['aggr'], $data);
return $this->field_format($this->cell['field'], $this->cell['func'], $this->cell['aggr'], $data);
$my = array_shift($fields);
foreach ($fields as &$v)
if ($v['sort'])
@ -536,7 +671,7 @@ class OLAP
foreach ($fields as &$v)
if ($v['type'] == $my['type'] && $v['orig_sort'])
$v['sort'] = &$v['orig_sort'][$k];
$r = self::recurse_cells($fields, $data[$k], $tdkeys);
$r = $this->recurse_cells($fields, $data[$k], $tdkeys);
if (is_array($r))
$rows = array_merge($rows, $r);
else
@ -555,7 +690,7 @@ class OLAP
foreach ($fields as &$v)
if ($v['type'] == $my['type'] && $v['orig_sort'])
$v['sort'] = &$v['orig_sort'][$k];
$r = self::recurse_cells($fields, $data[$k], $tdkeys[$k]);
$r = $this->recurse_cells($fields, $data[$k], $tdkeys[$k]);
if (is_array($r))
$cols = array_merge($cols, $r[0]);
else
@ -574,10 +709,10 @@ class OLAP
foreach ($fields as &$v)
if ($v['type'] == $my['type'] && $v['orig_sort'])
$v['sort'] = &$v['orig_sort'][$k];
$list .= '<li>'.self::field_format($my['field'], $my['func'], '', $k).':&nbsp;';
$list .= '<li>'.$this->field_format($my['field'], $my['func'], '', $k).':&nbsp;';
if ($fields)
$list .= "\n";
$sub = self::recurse_cells($fields, $data[$k], $tdkeys);
$sub = $this->recurse_cells($fields, $data[$k], $tdkeys);
$sub = str_replace('<li>', ' <li>', $sub);
$list .= $sub;
$list .= "</li>\n";
@ -588,7 +723,8 @@ class OLAP
}
}
static function recurse_head($fields, &$data)
// Рекурсивное построение заглавной строки/колонки
function recurse_head($fields, &$data)
{
$rows = array();
if (!$fields)
@ -610,7 +746,7 @@ class OLAP
$span = 0;
if ($fields)
{
$subrows = self::recurse_head($fields, $data[$k]);
$subrows = $this->recurse_head($fields, $data[$k]);
foreach ($subrows[0] as $td)
$span += $td['colspan'];
foreach ($subrows as $i => &$row)
@ -622,10 +758,10 @@ class OLAP
}
else
$span = 1;
$c = array('text' => self::field_format($my['field'], $my['func'], '', $k), 'colspan' => $span);
$c = array('text' => $this->field_format($my['field'], $my['func'], '', $k), 'colspan' => $span);
if ($my['sort_field'])
$c['sort'] = self::field_format($my['sort_field'], $my['sort_func'], $my['sort_aggr'], $my['sort'][$k]);
if (self::$add_spanned)
$c['sort'] = $this->field_format($my['sort_field'], $my['sort_func'], $my['sort_aggr'], $my['sort'][$k]);
if ($this->add_spanned)
{
$c['colspan'] = 1;
$rows[0][] = $c;
@ -640,26 +776,32 @@ class OLAP
return $rows;
}
static function array_refcopy(&$a)
{
$b = array();
foreach ($a as $k => &$v)
$b[$k] = &$v;
return $b;
}
static function build_tables($group_fields, &$data, &$tdkeys)
function build_tables($group_fields, &$data, &$tdkeys)
{
$bytype = array();
foreach ($group_fields as $gf)
$bytype[$gf['type']][] = $gf;
$tables = self::recurse_tables($group_fields, $bytype, $data, $tdkeys);
foreach ($group_fields as &$gf)
$bytype[$gf['type']][] = &$gf;
$tables = $this->recurse_tables($group_fields, $bytype, $data, $tdkeys);
return $tables;
}
static function sql_trans_field($field, $func)
function func_trans_field($field, $func)
{
$fd = &self::$current_src['fielddescs'][$field];
if ($field === '')
$field = '1';
$fd = &$this->current_src['fielddescs'][$field];
$c = "\$r['$field']";
if (!empty($fd['is_time']) && $fd['format'] == Template::TS_UNIX &&
(!self::$functions[$func] || self::$functions[$func]['time_format']))
$c = "date('Y-m-d',$c)";
if ($func)
$c = "self::fn_$func($c)";
return $c;
}
function sql_trans_field($field, $func)
{
$fd = &$this->current_src['fielddescs'][$field];
if ($field === '')
$sql = '1';
else
@ -676,6 +818,28 @@ class OLAP
return $sql;
}
function field_format($field, $func, $aggr, $value)
{
$o = &$this->current_src['fielddescs'][$field]['options_hash'];
if ($o && $o[$value] && !$aggr)
return $o[$value];
elseif (preg_match('/^-?\d+\.\d+$/s', $value))
{
$value = sprintf($this->decimal, $value);
$value = preg_replace('/\.0+$|(\.\d*?)0+$/', '\1', $value);
return $value;
}
elseif (($proc = $this->current_src['fielddescs'][$field]['format_func']) &&
is_callable($proc))
{
return $proc($value, $this->is_html_format);
}
$fn = $this->is_html_format ? 'htmlspecialchars' : 'addslashes';
return $fn($value);
}
// Сортировать значения $values по $sortvalues =
// array('значение' => 'ключ сортировки') или по самим себе
static function do_sort(&$values, &$sortvalues, &$sort_dir)
{
$fn = 'sort';
@ -703,41 +867,17 @@ class OLAP
}
static function group_type_cmp($a, $b)
{
if ($a == 'graph')
return -1;
elseif ($b == 'graph')
return 1;
$r = self::$group_types[$a['type']]['num']-self::$group_types[$b['type']]['num'];
$an = $a['type'] == 'graph' ? -1 : self::$group_types[$a['type']]['num'];
$bn = $b['type'] == 'graph' ? -1 : self::$group_types[$b['type']]['num'];
$r = $an-$bn;
if ($r == 0)
$r = $a['num']-$b['num'];
return $r;
}
static $is_html_format = true;
static $decimal = '%.3f';
static function field_format($field, $func, $aggr, $value)
{
$o = &self::$current_src['fielddescs'][$field]['options_hash'];
if ($o && $o[$value] && !$aggr)
return $o[$value];
elseif (preg_match('/^-?\d+\.\d+$/s', $value))
{
$value = sprintf(self::$decimal, $value);
$value = preg_replace('/\.0+$|(\.\d*?)0+$/', '\1', $value);
return $value;
}
elseif (($proc = self::$current_src['fielddescs'][$field]['format_func']) &&
is_callable($proc))
{
return $proc($value, self::$is_html_format);
}
$fn = self::$is_html_format ? 'htmlspecialchars' : 'addslashes';
return $fn($value);
}
static function tpl_field_format($field, $func, $aggr, $value)
{
return "OLAP::field_format($field, $func, $aggr, $value)";
return "\$tpldata['olap']->field_format($field, $func, $aggr, $value)";
}
static function o_tsformat($f, &$row, $field)
@ -747,4 +887,77 @@ class OLAP
$row[$tf] = Template::timestamp($row[$field]);
return date($f, $row[$tf]);
}
}
//// АГРЕГАТНЫЕ ФУНКЦИИ
// Количество - обновление
static function aggr_update_count(&$aggr, &$value)
{
$aggr++;
}
// Сумма - обновление
static function aggr_update_sum(&$aggr, &$value)
{
$aggr += $value;
}
// Среднее - обновление
static function aggr_update_avg(&$aggr, &$value)
{
$aggr['count']++;
$aggr['sum'] += $value;
}
// Среднее - финализация
static function aggr_finish_avg(&$aggr)
{
if ($aggr['count'])
$aggr = $aggr['sum'] / $aggr['count'];
else
$aggr = 0;
}
// Минимум - обновление
static function aggr_update_min(&$aggr, &$value)
{
if ($aggr > $value)
$aggr = $value;
}
// Максимум - обновление
static function aggr_update_max(&$aggr, &$value)
{
if ($aggr < $value)
$aggr = $value;
}
// Дисперсия - обновление
static function aggr_update_stddev(&$aggr, &$value)
{
$aggr['count']++;
$aggr['sum'] += $value;
$aggr['sum2'] += $value*$value;
}
// Дисперсия - финализация
static function aggr_finish_stddev(&$aggr)
{
if ($aggr['count'])
$aggr = sqrt(($aggr['sum2'] - $aggr['sum']*$aggr['sum']/$aggr['count']) / $aggr['count']);
else
$aggr = 0;
}
// Число уникальных - обновление
static function aggr_update_n_uniq(&$aggr, &$value)
{
$aggr[$value] = true;
}
// Число уникальных - финализация
static function aggr_finish_n_uniq(&$aggr)
{
$aggr = count($aggr);
}
}