/**
* execute a between operation
*
* @param sql
* @param qr QueryResult to execute on it
* @param expression
* @param row row of resultset to execute
* @return result
* @throws PageException
*/
private Object executeBetween(PageContext pc, SQL sql, Query qr, ZExpression expression, int row)
throws PageException {
Object left = executeExp(pc, sql, qr, expression.getOperand(0), row);
Object right1 = executeExp(pc, sql, qr, expression.getOperand(1), row);
Object right2 = executeExp(pc, sql, qr, expression.getOperand(2), row);
return ((Operator.compare(left, right1) <= 0) && (Operator.compare(left, right2) >= 0))
? Boolean.TRUE
: Boolean.FALSE;
}
/**
* execute a greater than or equal operation
*
* @param sql
* @param qr QueryResult to execute on it
* @param expression
* @param row row of resultset to execute
* @return result
* @throws PageException
*/
private Object executeIn(PageContext pc, SQL sql, Query qr, ZExpression expression, int row)
throws PageException {
int len = expression.nbOperands();
Object left = executeExp(pc, sql, qr, expression.getOperand(0), row);
for (int i = 1; i < len; i++) {
if (Operator.compare(left, executeExp(pc, sql, qr, expression.getOperand(i), row)) == 0)
return Boolean.TRUE;
}
return Boolean.FALSE;
}
private Query testExecute(PageContext pc, SQL sql, Query qr, ZQuery query, int maxrows)
throws PageException {
int recCount = qr.getRecordcount();
Vector vSelects = query.getSelect();
int selCount = vSelects.size();
Map selects = new HashTable();
boolean isSMS = false;
// headers
for (int i = 0; i < selCount; i++) {
ZSelectItem select = (ZSelectItem) vSelects.get(i);
if (select.isWildcard()
|| (isSMS = select.getColumn().equals(SQLPrettyfier.PLACEHOLDER_ASTERIX))) {
if (!isSMS && !select.getColumn().equals("*"))
throw new DatabaseException(
"can't execute this type of query at the moment", null, sql, null);
String[] keys = qr.keysAsString();
for (int y = 0; y < keys.length; y++) {
selects.put(keys[y], keys[y]);
}
isSMS = false;
} else {
// if(SQLPrettyfier.PLACEHOLDER_COUNT.equals(select.getAlias())) select.setAlias("count");
// if(SQLPrettyfier.PLACEHOLDER_COUNT.equals(select.getColumn())) select.setExpression(new
// ZConstant("count",ZConstant.COLUMNNAME));
String alias = select.getAlias();
String column = select.getColumn();
if (alias == null) alias = column;
alias = alias.toLowerCase();
selects.put(alias, select);
}
}
String[] headers = (String[]) selects.keySet().toArray(new String[selects.size()]);
// aHeaders.toArray(new String[aHeaders.size()]);
QueryImpl rtn = new QueryImpl(headers, 0, "query");
rtn.setSql(sql);
// loop records
Vector orders = query.getOrderBy();
ZExp where = query.getWhere();
// print.out(headers);
// int newRecCount=0;
boolean hasMaxrow = maxrows > -1 && (orders == null || orders.size() == 0);
for (int row = 1; row <= recCount; row++) {
sql.setPosition(0);
if (hasMaxrow && maxrows <= rtn.getRecordcount()) break;
boolean useRow = where == null || Caster.toBooleanValue(executeExp(pc, sql, qr, where, row));
if (useRow) {
rtn.addRow(1);
for (int cell = 0; cell < headers.length; cell++) {
Object value = selects.get(headers[cell]);
rtn.setAt(
headers[cell], rtn.getRecordcount(), getValue(pc, sql, qr, row, headers[cell], value)
// executeExp(qr, selects[cell].getExpression(),row)
);
}
}
}
// Group By
if (query.getGroupBy() != null)
throw new DatabaseException("group by are not supported at the moment", null, sql, null);
// Order By
if (orders != null && orders.size() > 0) {
int len = orders.size();
for (int i = len - 1; i >= 0; i--) {
ZOrderBy order = (ZOrderBy) orders.get(i);
ZConstant name = (ZConstant) order.getExpression();
rtn.sort(
name.getValue().toLowerCase(),
order.getAscOrder() ? Query.ORDER_ASC : Query.ORDER_DESC);
}
if (maxrows > -1) {
rtn.cutRowsTo(maxrows);
}
}
// Distinct
if (query.isDistinct()) {
String[] keys = rtn.getColumns();
QueryColumn[] columns = new QueryColumn[keys.length];
for (int i = 0; i < columns.length; i++) {
columns[i] = rtn.getColumn(keys[i]);
}
int i;
outer:
for (int row = rtn.getRecordcount(); row > 1; row--) {
for (i = 0; i < columns.length; i++) {
if (!Operator.equals(columns[i].get(row), columns[i].get(row - 1), true)) continue outer;
}
rtn.removeRow(row);
}
}
// UNION // TODO support it
ZExpression set = query.getSet();
if (set != null) {
ZExp op = set.getOperand(0);
if (op instanceof ZQuery)
throw new DatabaseException("union is not supported at the moment", null, sql, null);
// getInvokedTables((ZQuery)op, tablesNames);
}
return rtn;
}
/**
* execute a equal operation
*
* @param sql
* @param qr QueryResult to execute on it
* @param expression
* @param row row of resultset to execute
* @return result
* @throws PageException
*/
private int executeCompare(PageContext pc, SQL sql, Query qr, ZExpression expression, int row)
throws PageException {
return Operator.compare(
executeExp(pc, sql, qr, expression.getOperand(0), row),
executeExp(pc, sql, qr, expression.getOperand(1), row));
}
/**
* Executes a Expression
*
* @param sql
* @param qr
* @param expression
* @param row
* @return result
* @throws PageException
*/
private Object executeExpression(
PageContext pc, SQL sql, Query qr, ZExpression expression, int row) throws PageException {
String op = StringUtil.toLowerCase(expression.getOperator());
int count = expression.nbOperands();
if (op.equals("and")) return executeAnd(pc, sql, qr, expression, row);
else if (op.equals("or")) return executeOr(pc, sql, qr, expression, row);
if (count == 0 && op.equals("?")) {
int pos = sql.getPosition();
if (sql.getItems().length <= pos)
throw new DatabaseException("invalid syntax for SQL Statment", null, sql, null);
sql.setPosition(pos + 1);
return sql.getItems()[pos].getValueForCF();
}
// 11111111111111111111111111111111111111111111111111111
else if (count == 1) {
Object value = executeExp(pc, sql, qr, expression.getOperand(0), row);
// Functions
switch (op.charAt(0)) {
case 'a':
if (op.equals("abs")) return new Double(MathUtil.abs(Caster.toDoubleValue(value)));
if (op.equals("acos")) return new Double(Math.acos(Caster.toDoubleValue(value)));
if (op.equals("asin")) return new Double(Math.asin(Caster.toDoubleValue(value)));
if (op.equals("atan")) return new Double(Math.atan(Caster.toDoubleValue(value)));
break;
case 'c':
if (op.equals("ceiling")) return new Double(Math.ceil(Caster.toDoubleValue(value)));
if (op.equals("cos")) return new Double(Math.cos(Caster.toDoubleValue(value)));
break;
case 'e':
if (op.equals("exp")) return new Double(Math.exp(Caster.toDoubleValue(value)));
break;
case 'f':
if (op.equals("floor")) return new Double(Math.floor(Caster.toDoubleValue(value)));
break;
case 'i':
if (op.equals("is not null")) return Boolean.valueOf(value != null);
if (op.equals("is null")) return Boolean.valueOf(value == null);
break;
case 'u':
if (op.equals("upper") || op.equals("ucase")) return Caster.toString(value).toUpperCase();
break;
case 'l':
if (op.equals("lower") || op.equals("lcase")) return Caster.toString(value).toLowerCase();
if (op.equals("ltrim")) return StringUtil.ltrim(Caster.toString(value), null);
if (op.equals("length")) return new Double(Caster.toString(value).length());
break;
case 'r':
if (op.equals("rtrim")) return StringUtil.rtrim(Caster.toString(value), null);
break;
case 's':
if (op.equals("sign")) return new Double(MathUtil.sgn(Caster.toDoubleValue(value)));
if (op.equals("sin")) return new Double(Math.sin(Caster.toDoubleValue(value)));
if (op.equals("soundex")) return StringUtil.soundex(Caster.toString(value));
if (op.equals("sin")) return new Double(Math.sqrt(Caster.toDoubleValue(value)));
break;
case 't':
if (op.equals("tan")) return new Double(Math.tan(Caster.toDoubleValue(value)));
if (op.equals("trim")) return Caster.toString(value).trim();
break;
}
}
// 22222222222222222222222222222222222222222222222222222
else if (count == 2) {
if (op.equals("=") || op.equals("in")) return executeEQ(pc, sql, qr, expression, row);
else if (op.equals("!=") || op.equals("<>")) return executeNEQ(pc, sql, qr, expression, row);
else if (op.equals("<")) return executeLT(pc, sql, qr, expression, row);
else if (op.equals("<=")) return executeLTE(pc, sql, qr, expression, row);
else if (op.equals(">")) return executeGT(pc, sql, qr, expression, row);
else if (op.equals(">=")) return executeGTE(pc, sql, qr, expression, row);
else if (op.equals("-")) return executeMinus(pc, sql, qr, expression, row);
else if (op.equals("+")) return executePlus(pc, sql, qr, expression, row);
else if (op.equals("/")) return executeDivide(pc, sql, qr, expression, row);
else if (op.equals("*")) return executeMultiply(pc, sql, qr, expression, row);
else if (op.equals("^")) return executeExponent(pc, sql, qr, expression, row);
Object left = executeExp(pc, sql, qr, expression.getOperand(0), row);
Object right = executeExp(pc, sql, qr, expression.getOperand(1), row);
// Functions
switch (op.charAt(0)) {
case 'a':
if (op.equals("atan2"))
return new Double(Math.atan2(Caster.toDoubleValue(left), Caster.toDoubleValue(right)));
break;
case 'b':
if (op.equals("bitand"))
return new Double(
Operator.bitand(Caster.toDoubleValue(left), Caster.toDoubleValue(right)));
if (op.equals("bitor"))
return new Double(
Operator.bitor(Caster.toDoubleValue(left), Caster.toDoubleValue(right)));
break;
case 'c':
if (op.equals("concat")) return Caster.toString(left).concat(Caster.toString(right));
break;
case 'l':
if (op.equals("like")) return executeLike(pc, sql, qr, expression, row);
break;
case 'm':
if (op.equals("mod"))
return new Double(
Operator.modulus(Caster.toDoubleValue(left), Caster.toDoubleValue(right)));
break;
}
throw new DatabaseException("unsopprted sql statement [" + op + "]", null, sql, null);
}
// 3333333333333333333333333333333333333333333333333333333333333333333
else if (count == 3) {
if (op.equals("between")) return executeBetween(pc, sql, qr, expression, row);
}
if (op.equals("in")) return executeIn(pc, sql, qr, expression, row);
/*
addCustomFunction("cot",1);
addCustomFunction("degrees",1);
addCustomFunction("log",1);
addCustomFunction("log10",1);
addCustomFunction("pi",0);
addCustomFunction("power",2);
addCustomFunction("radians",1);
addCustomFunction("rand",0);
addCustomFunction("round",2);
addCustomFunction("roundmagic",1);
addCustomFunction("truncate",2);
addCustomFunction("ascii",1);
addCustomFunction("bit_length",1);
addCustomFunction("char",1);
addCustomFunction("char_length",1);
addCustomFunction("difference",2);
addCustomFunction("hextoraw",1);
addCustomFunction("insert",4);
addCustomFunction("left",2);
addCustomFunction("locate",3);
addCustomFunction("octet_length",1);
addCustomFunction("rawtohex",1);
addCustomFunction("repeat",2);
addCustomFunction("replace",3);
addCustomFunction("right",2);
addCustomFunction("space",1);
addCustomFunction("substr",3);
addCustomFunction("substring",3);
addCustomFunction("curdate",0);
addCustomFunction("curtime",0);
addCustomFunction("datediff",3);
addCustomFunction("dayname",1);
addCustomFunction("dayofmonth",1);
addCustomFunction("dayofweek",1);
addCustomFunction("dayofyear",1);
addCustomFunction("hour",1);
addCustomFunction("minute",1);
addCustomFunction("month",1);
addCustomFunction("monthname",1);
addCustomFunction("now",0);
addCustomFunction("quarter",1);
addCustomFunction("second",1);
addCustomFunction("week",1);
addCustomFunction("year",1);
addCustomFunction("current_date",1);
addCustomFunction("current_time",1);
addCustomFunction("current_timestamp",1);
addCustomFunction("database",0);
addCustomFunction("user",0);
addCustomFunction("current_user",0);
addCustomFunction("identity",0);
addCustomFunction("ifnull",2);
addCustomFunction("casewhen",3);
addCustomFunction("convert",2);
//addCustomFunction("cast",1);
addCustomFunction("coalesce",1000);
addCustomFunction("nullif",2);
addCustomFunction("extract",1);
addCustomFunction("position",1);
*/
// print(expression);
throw new DatabaseException(
"unsopprted sql statement (op-count:" + expression.nbOperands() + ";operator:" + op + ") ",
null,
sql,
null);
}