/** standard constructor.
*
* @param string id of the query
* @param mixed the shared db object
* @param array the user information
*
***/
public function __construct($queryid, &$db, $userinfo, $dbSlave)
{
parent::__construct($queryid, $db, $userinfo, $dbSlave);
$this->query_type = self::QUERY_UPDATE;
$this->table_query = true;
//We need this queryid in table data
if (!array_key_exists($this->query_id, $this->table_data)) {
throw new Exception('invalid_query_definition');
}
}
/** standard constructor.
*
* @param string id of the query
* @param mixed the shared db object
* @param array the user information
*
***/
public function __construct($queryid, &$db, $userinfo, $dbSlave)
{
parent::__construct($queryid, $db, $userinfo, $dbSlave);
$this->query_type = self::QUERY_METHOD;
$this->table_query = true;
}
public function assertQuery($queryid, $params = array(), $orderby = false)
{
//make sure we have been initialized
if (!isset(self::$instance)) {
return false;
}
if ($this->debugDisplayNextQuerySql) {
$params[vB_dB_Query::DEBUG_QUERY] = 1;
}
// get the query object
$query = vB_dB_Query::getQuery($queryid, $params, self::$db, self::$userinfo, self::$dbtype, self::$dbSlave);
if (isset($params[vB_dB_Query::DEBUG_QUERY])) {
unset($params[vB_dB_Query::DEBUG_QUERY]);
}
if ($this->debugDisplayNextQuerySql) {
$this->debugDisplayNextQuerySql = false;
$query->debugDisplayNextQuerySql();
}
//set the parameters. The children will raise an error if they don't have enough data.
$check = $query->setQuery($params, $orderby);
/**If we are in development mode, record this query **/
if ($this->debug) {
$this->queryCount += 1;
/**for performance measuring- number of queries on this page **/
if (!empty($_REQUEST['querylist'])) {
$displayParams = $params;
unset($displayParams[vB_dB_Query::TYPE_KEY]);
$displayParam = var_export($displayParams, true);
if (strlen($displayParam) > 256) {
$this->queries[] = $queryid . ': ' . substr($displayParam, 0, 256) . '...';
} else {
$this->queries[] = $queryid . ': ' . $displayParam;
}
}
}
if ($this->debugLog) {
$starttime = microtime(true);
//We don't want a full trace.
$stack = array();
$trace = debug_backtrace(false);
foreach ($trace as $key => $step) {
$line = "Step {$key}: in " . $step['function'];
foreach (array('line', 'step', 'file') as $field) {
if (!empty($step[$field])) {
$line .= ' ' . $field . ' ' . $step[$field];
}
}
$stack[] = $line;
}
$info = "---------------------\nQuery: " . $queryid . "\n" . var_export($params, true) . "\n" . implode("\n", $stack) . "\n";
if (isset($params[vB_dB_Query::TYPE_KEY])) {
vB::getLogger("dbAssertor.{$queryid}." . $params[vB_dB_Query::TYPE_KEY])->info($info);
} else {
vB::getLogger("dbAssertor.{$queryid}")->info($info);
}
$result = $query->execSQL();
vB::getLogger("dbAssertor.{$queryid}")->info("time: " . (microtime(true) - $starttime));
return $result;
}
return $query->execSQL();
}
/** This loads and validates the data- ensures we have all we need
*
* @param array the data for the query
***/
public function setQuery($params, $sortorder)
{
return parent::setTableQuery($params, $sortorder);
}
/** standard constructor.
*
* @param string id of the query
* @param mixed the shared db object
* @param array the user information
*
***/
public function __construct($queryid, &$db, $userinfo)
{
parent::__construct($queryid, $db, $userinfo);
$this->query_type = self::QUERY_UPDATE;
$this->table_query = true;
}
public static function getQuery($queryid, $params, &$db, $userinfo, $dbtype, $dbSlave)
{
//init querybuilder if needed
if (!isset(self::$queryBuilders[$dbtype])) {
$config = vB::getConfig();
$queryClass = 'vB_Db_' . $dbtype . '_QueryBuilder';
self::$queryBuilders[$dbtype] = new $queryClass($db, !empty($config['Misc']['debug_sql']) or !empty($params[self::DEBUG_QUERY]));
self::$configDebug = !empty($config['Misc']['debug_sql']);
} else {
self::$queryBuilders[$dbtype]->setDebugSQL(self::$configDebug or !empty($params[self::DEBUG_QUERY]));
}
//We need the query type for what happens next. For that we need the querydefs.
if (strpos($queryid, ':')) {
$values = explode(':', $queryid);
if (count($values) > 1) {
$class_prefix = $values[0];
$queryid = $values[1];
}
}
if (isset($class_prefix)) {
$classname = $class_prefix . '_dB_' . $dbtype . "_QueryDefs";
$filename = DIR . '/packages/' . strtolower(str_replace('_', '/', $classname)) . '.php';
if (file_exists($filename)) {
include_once $filename;
}
//make sure this is valid
if (class_exists($classname, false)) {
$class = $classname;
}
} else {
$class = 'vB_Db_' . $dbtype . "_QueryDefs";
}
$querydefs = new $class();
$tableData = $querydefs->getTableData();
$queryData = $querydefs->getQueryData();
//First we need to find out what kind of query we have. If it's a table-based query
// then we have a "type" in the params array.
if (!isset($params[self::TYPE_KEY])) {
//We can still recover is this is a method or stored query.
if (!empty($queryData[$queryid])) {
$params[self::TYPE_KEY] = self::QUERY_STORED;
} else {
if (method_exists($querydefs, $queryid)) {
$params[self::TYPE_KEY] = self::QUERY_METHOD;
} else {
$params[self::TYPE_KEY] = self::QUERY_SELECT;
}
}
}
if (empty($tableData[$queryid]) and in_array($params[self::TYPE_KEY], array(self::QUERY_SELECT, self::QUERY_COUNT, self::QUERY_UPDATE, self::QUERY_INSERT, self::QUERY_INSERTIGNORE, self::QUERY_MULTIPLEINSERT, self::QUERY_DELETE, self::QUERY_REPLACE))) {
throw new vB_Exception_Api('invalid_query_definition_x', $queryid);
}
switch ($params[self::TYPE_KEY]) {
case self::QUERY_STORED:
$queryClass = 'vB_Db_Query_Stored_' . $dbtype;
break;
case self::QUERY_SELECT:
$queryClass = 'vB_Db_Query_Select_' . $dbtype;
break;
case self::QUERY_COUNT:
$queryClass = 'vB_Db_Query_Count_' . $dbtype;
break;
case self::QUERY_UPDATE:
$queryClass = 'vB_Db_Query_Update_' . $dbtype;
break;
case self::QUERY_INSERT:
$queryClass = 'vB_Db_Query_Insert_' . $dbtype;
break;
case self::QUERY_INSERTIGNORE:
$queryClass = 'vB_Db_Query_InsertIgnore_' . $dbtype;
break;
case self::QUERY_REPLACE:
$queryClass = 'vB_Db_Query_Replace_' . $dbtype;
break;
case self::QUERY_DELETE:
$queryClass = 'vB_Db_Query_Delete_' . $dbtype;
break;
case self::QUERY_MULTIPLEINSERT:
$queryClass = 'vB_Db_Query_MultipleInsert_' . $dbtype;
break;
case self::QUERY_METHOD:
$queryClass = 'vB_Db_Query_Method_' . $dbtype;
break;
case self::QUERY_CREATE:
$queryClass = 'vB_Db_Query_Create_' . $dbtype;
break;
case self::QUERY_ALTER:
$queryClass = 'vB_Db_Query_Alter_' . $dbtype;
break;
case self::QUERY_DROP:
$queryClass = 'vB_Db_Query_Drop_' . $dbtype;
break;
default:
throw new Exception('invalid_query_definition');
}
// switch
$query = new $queryClass($queryid, $db, $userinfo, $dbSlave);
$query->setQueryDefs($querydefs, $queryid);
$query->setTableData($tableData, $queryid);
$query->setQueryData($queryData);
//If we had to build the structure, let's store it and not make another query later.
if (!empty($structure)) {
$query->setStructure($structure);
}
return $query;
}
protected function __construct($queryid, &$db, $userinfo, $dbSlave)
{
parent::__construct($queryid, $db, $userinfo, $dbSlave);
//We must first find out whether we need to use the slave database.
$this->table_query = false;
}
