';
$odd_row =! $odd_row;
} // end for
$this->_new_row_count = $new_row_count;
return $html_output;
}
/**
* Provides SELECT clause for building SQL query
*
* @return string Select clause
*/
private function _getSelectClause()
{
$select_clause = '';
$select_clauses = array();
for (
$column_index = 0;
$column_index < $this->_criteria_column_count;
$column_index++
) {
if (! empty($this->_curField[$column_index])
&& isset($this->_curShow[$column_index])
&& $this->_curShow[$column_index] == 'on'
) {
$select_clauses[] = $this->_curField[$column_index];
}
} // end for
if ($select_clauses) {
$select_clause = 'SELECT '
. htmlspecialchars(implode(", ", $select_clauses)) . "\n";
}
return $select_clause;
}
/**
* Provides WHERE clause for building SQL query
*
* @return string Where clause
*/
private function _getWhereClause()
{
$where_clause = '';
$criteria_cnt = 0;
for (
$column_index = 0;
$column_index < $this->_criteria_column_count;
$column_index++
) {
if (! empty($this->_curField[$column_index])
&& ! empty($this->_curCriteria[$column_index])
&& $column_index
&& isset($last_where)
&& isset($this->_curAndOrCol)
) {
$where_clause .= ' '
. /*overload*/mb_strtoupper($this->_curAndOrCol[$last_where])
. ' ';
}
if (! empty($this->_curField[$column_index])
&& ! empty($this->_curCriteria[$column_index])
) {
$where_clause .= '(' . $this->_curField[$column_index] . ' '
. $this->_curCriteria[$column_index] . ')';
$last_where = $column_index;
$criteria_cnt++;
}
} // end for
if ($criteria_cnt > 1) {
$where_clause = '(' . $where_clause . ')';
}
// OR rows ${'cur' . $or}[$column_index]
if (! isset($this->_curAndOrRow)) {
$this->_curAndOrRow = array();
}
for (
$row_index = 0;
$row_index <= $this->_criteria_row_count;
$row_index++
) {
$criteria_cnt = 0;
$qry_orwhere = '';
$last_orwhere = '';
for (
$column_index = 0;
$column_index < $this->_criteria_column_count;
$column_index++
) {
if (! empty($this->_curField[$column_index])
&& ! empty($_REQUEST['Or' . $row_index][$column_index])
&& $column_index
) {
$qry_orwhere .= ' '
. /*overload*/mb_strtoupper(
$this->_curAndOrCol[$last_orwhere]
)
. ' ';
}
if (! empty($this->_curField[$column_index])
&& ! empty($_REQUEST['Or' . $row_index][$column_index])
) {
$qry_orwhere .= '(' . $this->_curField[$column_index]
. ' '
. $_REQUEST['Or' . $row_index][$column_index]
. ')';
$last_orwhere = $column_index;
$criteria_cnt++;
}
} // end for
if ($criteria_cnt > 1) {
$qry_orwhere = '(' . $qry_orwhere . ')';
}
if (! empty($qry_orwhere)) {
$where_clause .= "\n"
. /*overload*/mb_strtoupper(
isset($this->_curAndOrRow[$row_index])
? $this->_curAndOrRow[$row_index] . ' '
: ''
)
. $qry_orwhere;
} // end if
} // end for
if (! empty($where_clause) && $where_clause != '()') {
$where_clause = 'WHERE ' . htmlspecialchars($where_clause) . "\n";
} // end if
return $where_clause;
}
/**
* Provides ORDER BY clause for building SQL query
*
* @return string Order By clause
*/
private function _getOrderByClause()
{
$orderby_clause = '';
$orderby_clauses = array();
for (
$column_index = 0;
$column_index < $this->_criteria_column_count;
$column_index++
) {
// if all columns are chosen with * selector,
// then sorting isn't available
// Fix for Bug #570698
if (empty($this->_curField[$column_index])
&& empty($this->_curSort[$column_index])
) {
continue;
}
if (/*overload*/mb_substr($this->_curField[$column_index], -2) == '.*') {
continue;
}
if (! empty($this->_curSort[$column_index])) {
$orderby_clauses[] = $this->_curField[$column_index] . ' '
. $this->_curSort[$column_index];
}
} // end for
if ($orderby_clauses) {
$orderby_clause = 'ORDER BY '
. htmlspecialchars(implode(", ", $orderby_clauses)) . "\n";
}
return $orderby_clause;
}
/**
* Provides UNIQUE columns and INDEX columns present in criteria tables
*
* @param array $all_tables Tables involved in the search
* @param array $all_columns Columns involved in the search
* @param array $where_clause_columns Columns having criteria where clause
*
* @return array having UNIQUE and INDEX columns
*/
private function _getIndexes($all_tables, $all_columns,
$where_clause_columns
) {
$unique_columns = array();
$index_columns = array();
foreach ($all_tables as $table) {
$indexes = $GLOBALS['dbi']->getTableIndexes($this->_db, $table);
foreach ($indexes as $index) {
$column = $table . '.' . $index['Column_name'];
if (isset($all_columns[$column])) {
if ($index['Non_unique'] == 0) {
if (isset($where_clause_columns[$column])) {
$unique_columns[$column] = 'Y';
} else {
$unique_columns[$column] = 'N';
}
} else {
if (isset($where_clause_columns[$column])) {
$index_columns[$column] = 'Y';
} else {
$index_columns[$column] = 'N';
}
}
}
} // end while (each index of a table)
} // end while (each table)
return array(
'unique' => $unique_columns,
'index' => $index_columns
);
}
/**
* Provides UNIQUE columns and INDEX columns present in criteria tables
*
* @param array $all_tables Tables involved in the search
* @param array $all_columns Columns involved in the search
* @param array $where_clause_columns Columns having criteria where clause
*
* @return array having UNIQUE and INDEX columns
*/
private function _getLeftJoinColumnCandidates($all_tables, $all_columns,
$where_clause_columns
) {
$GLOBALS['dbi']->selectDb($this->_db);
// Get unique columns and index columns
$indexes = $this->_getIndexes(
$all_tables, $all_columns, $where_clause_columns
);
$unique_columns = $indexes['unique'];
$index_columns = $indexes['index'];
list($candidate_columns, $needsort)
= $this->_getLeftJoinColumnCandidatesBest(
$all_tables, $where_clause_columns, $unique_columns, $index_columns
);
// If we came up with $unique_columns (very good) or $index_columns (still
// good) as $candidate_columns we want to check if we have any 'Y' there
// (that would mean that they were also found in the whereclauses
// which would be great). if yes, we take only those
if ($needsort != 1) {
return $candidate_columns;
}
$vg = array();
$sg = array();
foreach ($candidate_columns as $column => $is_where) {
$table = explode('.', $column);
$table = $table[0];
if ($is_where == 'Y') {
$vg[$column] = $table;
} else {
$sg[$column] = $table;
}
}
if (count($vg) > 0) {
$candidate_columns = $vg;
// Candidates restricted in index+where
} else {
$candidate_columns = $sg;
// None of the candidates where in a where-clause
}
return $candidate_columns;
}
/**
* Provides the main table to form the LEFT JOIN clause
*
* @param array $all_tables Tables involved in the search
* @param array $all_columns Columns involved in the search
* @param array $where_clause_columns Columns having criteria where clause
* @param array $where_clause_tables Tables having criteria where clause
*
* @return string table name
*/
private function _getMasterTable($all_tables, $all_columns,
$where_clause_columns, $where_clause_tables
) {
if (count($where_clause_tables) == 1) {
// If there is exactly one column that has a decent where-clause
// we will just use this
$master = key($where_clause_tables);
return $master;
}
// Now let's find out which of the tables has an index
// (When the control user is the same as the normal user
// because he is using one of his databases as pmadb,
// the last db selected is not always the one where we need to work)
$candidate_columns = $this->_getLeftJoinColumnCandidates(
$all_tables, $all_columns, $where_clause_columns
);
// Generally, we need to display all the rows of foreign (referenced)
// table, whether they have any matching row in child table or not.
// So we select candidate tables which are foreign tables.
$foreign_tables = array();
foreach ($candidate_columns as $one_table) {
$foreigners = PMA_getForeigners($this->_db, $one_table);
foreach ($foreigners as $key => $foreigner) {
if ($key != 'foreign_keys_data') {
if (in_array($foreigner['foreign_table'], $candidate_columns)) {
$foreign_tables[$foreigner['foreign_table']]
= $foreigner['foreign_table'];
}
continue;
}
foreach ($foreigner as $one_key) {
if (in_array($one_key['ref_table_name'], $candidate_columns)) {
$foreign_tables[$one_key['ref_table_name']]
= $one_key['ref_table_name'];
}
}
}
}
if (count($foreign_tables)) {
$candidate_columns = $foreign_tables;
}
// If our array of candidates has more than one member we'll just
// find the smallest table.
// Of course the actual query would be faster if we check for
// the Criteria which gives the smallest result set in its table,
// but it would take too much time to check this
if (!(count($candidate_columns) > 1)) {
reset($candidate_columns);
$master = current($candidate_columns); // Only one single candidate
return $master;
}
// Of course we only want to check each table once
$checked_tables = $candidate_columns;
$tsize = array();
$csize = array();
foreach ($candidate_columns as $table) {
if ($checked_tables[$table] != 1) {
$tsize[$table] = PMA_Table::countRecords(
$this->_db,
$table,
false
);
$checked_tables[$table] = 1;
}
$csize[$table] = $tsize[$table];
}
arsort($csize);
reset($csize);
$master = key($csize); // Largest
return $master;
}
/**
* Provides columns and tables that have valid where clause criteria
*
* @return array
*/
private function _getWhereClauseTablesAndColumns()
{
$where_clause_columns = array();
$where_clause_tables = array();
// Now we need all tables that we have in the where clause
for (
$column_index = 0, $nb = count($this->_criteria);
$column_index < $nb;
$column_index++
) {
$current_table = explode('.', $_POST['criteriaColumn'][$column_index]);
if (empty($current_table[0]) || empty($current_table[1])) {
continue;
} // end if
$table = str_replace('`', '', $current_table[0]);
$column = str_replace('`', '', $current_table[1]);
$column = $table . '.' . $column;
// Now we know that our array has the same numbers as $criteria
// we can check which of our columns has a where clause
if (! empty($this->_criteria[$column_index])) {
if (/*overload*/mb_substr($this->_criteria[$column_index], 0, 1) == '='
|| /*$pmaString->*/stristr($this->_criteria[$column_index], 'is')
) {
$where_clause_columns[$column] = $column;
$where_clause_tables[$table] = $table;
}
} // end if
} // end for
return array(
'where_clause_tables' => $where_clause_tables,
'where_clause_columns' => $where_clause_columns
);
}
/**
* Provides FROM clause for building SQL query
*
* @return string FROM clause
*/
private function _getFromClause()
{
$from_clause = '';
if (isset($_POST['criteriaColumn']) && count($_POST['criteriaColumn']) > 0) {
// Initialize some variables
$all_tables = $all_columns = array();
// We only start this if we have fields, otherwise it would be dumb
foreach ($_POST['criteriaColumn'] as $value) {
$parts = explode('.', $value);
if (! empty($parts[0]) && ! empty($parts[1])) {
$table = str_replace('`', '', $parts[0]);
$all_tables[$table] = $table;
$all_columns[] = $table . '.' . str_replace('`', '', $parts[1]);
}
} // end while
// Create LEFT JOINS out of Relations
if (count($all_tables) > 0) {
// Get tables and columns with valid where clauses
$valid_where_clauses = $this->_getWhereClauseTablesAndColumns();
$where_clause_tables = $valid_where_clauses['where_clause_tables'];
$where_clause_columns = $valid_where_clauses['where_clause_columns'];
// Get master table
$master = $this->_getMasterTable(
$all_tables, $all_columns,
$where_clause_columns, $where_clause_tables
);
$from_clause = PMA_Util::backquote($master)
. PMA_getRelatives($all_tables, $master);
} // end if (count($all_tables) > 0)
} // end count($_POST['criteriaColumn']) > 0
// In case relations are not defined, just generate the FROM clause
// from the list of tables, however we don't generate any JOIN
if (empty($from_clause) && isset($all_tables)) {
$from_clause = implode(', ', $all_tables);
}
return $from_clause;
}
/**
* Provides the generated SQL query
*
* @param array $cfgRelation Relation Settings
*
* @return string SQL query
*/
private function _getSQLQuery($cfgRelation)
{
$sql_query = '';
// get SELECT clause
$sql_query .= $this->_getSelectClause();
// get FROM clause
$from_clause = $this->_getFromClause();
if (! empty($from_clause)) {
$sql_query .= 'FROM ' . htmlspecialchars($from_clause) . "\n";
}
// get WHERE clause
$sql_query .= $this->_getWhereClause();
// get ORDER BY clause
$sql_query .= $this->_getOrderByClause();
return $sql_query;
}
/**
* Provides the generated QBE form
*
* @param array $cfgRelation Relation Settings
*
* @return string QBE form
*/
public function getSelectionForm($cfgRelation)
{
$html_output = '';
$html_output .= '';
return $html_output;
}
/**
* Get fields to display
*
* @return string
*/
private function _getSavedSearchesField()
{
$html_output = __('Saved bookmarked search:');
$html_output .= ' ';
$html_output .= '';
$html_output .= '';
$html_output .= '';
if (null !== $currentSearchId) {
$html_output .= '';
$html_output .= '';
}
return $html_output;
}
/**
* Initialize _criteria_column_count
*
* @return int Previous number of columns
*/
private function _initializeCriteriasCount()
{
// sets column count
$criteriaColumnCount = PMA_ifSetOr(
$_REQUEST['criteriaColumnCount'],
3,
'numeric'
);
$criteriaColumnAdd = PMA_ifSetOr(
$_REQUEST['criteriaColumnAdd'],
0,
'numeric'
);
$this->_criteria_column_count = max(
$criteriaColumnCount + $criteriaColumnAdd,
0
);
// sets row count
$rows = PMA_ifSetOr($_REQUEST['rows'], 0, 'numeric');
$criteriaRowAdd = PMA_ifSetOr($_REQUEST['criteriaRowAdd'], 0, 'numeric');
$this->_criteria_row_count = max($rows + $criteriaRowAdd, 0);
return $criteriaColumnCount;
}
/**
* Get best
*
* @param array $all_tables All tables
* @param array $where_clause_columns Columns with where clause
* @param array $unique_columns Unique columns
* @param array $index_columns Indexed columns
*
* @return array
*/
private function _getLeftJoinColumnCandidatesBest(
$all_tables, $where_clause_columns, $unique_columns, $index_columns
) {
// now we want to find the best.
if (isset($unique_columns) && count($unique_columns) > 0) {
$candidate_columns = $unique_columns;
$needsort = 1;
return array($candidate_columns, $needsort);
} elseif (isset($index_columns) && count($index_columns) > 0) {
$candidate_columns = $index_columns;
$needsort = 1;
return array($candidate_columns, $needsort);
} elseif (isset($where_clause_columns) && count($where_clause_columns) > 0) {
$candidate_columns = $where_clause_columns;
$needsort = 0;
return array($candidate_columns, $needsort);
} else {
$candidate_columns = $all_tables;
$needsort = 0;
return array($candidate_columns, $needsort);
}
}
}
?>