I'm writing a database class for my site based on a fluent interface. First, I collect all the meaningful terms then put them into the "stack", which is basically an array. Then, I sort them in order that they would appear in an actual SQL query.
const stmt_select = 1;
const stmt_insert = 2;
const stmt_delete = 3;
const sql_select = 10;
const sql_from = 11;
const sql_into = 12;
const sql_where = 13;
const sql_join = 14;
const sql_group = 15;
const sql_order = 16;
const sql_limit = 17;
For example, the query below (although in a total rubbish order, and purposely trying to throw the class off):
Query::Select('name', 'age', 'height')
->Order('a')
->From('table')
->From('asd')
->Group('a')
->Execute();
.. produces:
Array
(
[0] => Array
(
[0] => 10
[1] => Array
(
[0] => name
[1] => age
[2] => height
)
)
[1] => Array
(
[0] => 11
[1] => asd
)
[2] => Array
(
[0] => 11
[1] => table
)
[3] => Array
(
[0] => 15
[1] => a
)
[4] => Array
(
[0] => 15
[1] => a
)
)
The problem I have is that some array members I want to merge together (for example multiple ->Selects()/->Where() clauses) and some array members I want to delete entirely if there are multiple instances because it isn't possible for there to be more than one (for example ->Limit(), ->Order()), however I'm not entirely sure what the easiest way to do this is.
I was thinking something along the lines of a function I could call for each subkey;
DeleteDuplicates(sql_order);
Merge(sql_select);
Not sure how to write these without a massive performance hit per query.
Your class should handle duplicates as early as possible. E.g., each call to select() should not add another item to the main array, but all calls to select() should be collected in the same stack item.