$con = mysql_connect(’ip’, ‘user’, ‘pass’);
mysql_select_db(”db”, $con);

// Fill in your table name and the query you want to check.
$table = “yourtable”;
$checkquery= “yourquery”;

// We should create a tiny database since it’s much faster and we don’t really need the data.
$sql=”create table test like $table”;
$result = mysql_query($sql);
$sql=”insert into test select * from $table limit 1″;
$result = mysql_query($sql);

// Here we get all of the columns from the table and create an index on each one.
$sql=”show columns from test”;
$result = mysql_query($sql);
while($row = mysql_fetch_array($result))
{
$field=$row['Field'];
$sql2=”create index $field on test($field);”;
$result2 = mysql_query($sql2);
}

// Now we run explain to see what columns (indexes) MySQL could possibly use. Here’s the trick that should get you a column list from the query.
$sql=”explain $checkquery”;
$result= mysql_query($sql);
while($row = mysql_fetch_array($result))
{
echo “Columns: ” . $row['possible_keys'] . ” are used for this query”;
}

// Clean up the mess.
$sql=”drop table test;”;
$result = mysql_query($sql);

So yeah this is really old but I stumbled upon it looking for the same thing and ended up building myself a php script to tease the info out of mysql. Not sure if this will work in every scenario but if the column isn’t a possible key you probably don’t need to index it anyway. So here it is, pretty self explanatory but I added comments in anyway. This will only work on a single table, so no joins, and it’s not prettied up but you can modify it for your needs.
[code]
[/code]

Tada! Works for me anyway.

Tada! Works for me anyway.

This would be cool. You can’t get parser to be equivalent to MySQL parser in all cases as there are different versions and even different MySQL Server settings may change things. But it should be good enough for most cases.

You can’t really write full query parser or reliably check which clauses are resolved which way.

I do not really care if it is part of explain or available some other way.

A standalone script (say written in perl or so) would be for me more interresting. This way you could give the script various queries and it will spit out suggestions for indexes needed. Of course in the longer run it would be interresting to have it also available like EXPLAIN EXTENDED or something…

You can run EXPLAIN … \G in which case number of columns is not the problem any more.

Adding two columns will be great, first listing columns which are used from the table and second listing where/on clauses applying to this table and how they are resolved, something like

SELECT count(*) FROM A,B WHERE A.ID=B.ID and A.C>5 and B.D>6;

A:
Used_Columns: ID,C
Checks: C>5(range)

B:
Used_Columns: ID,D
Checks: ID=A.ID(ref), D>6(row)

This would allow to very easy to see which of the checks are not using index which are great candidates for optimization.

I think it would be good, however I’m not sure passing query text is good idea. Might be EXPLAIN can simply feel these tables ready to use or something similar.

The problem with such solution is – it will be unlikely implemented any time soon as it not that trivial.

The other problem it may be a bit complicated to use – some people hate SHOW statements but they are much easier to use compared to information schema