/// <summary>
/// Expression constructor using an <see cref="Expression"/>.
/// </summary>
/// <param name="e"></param>
public Expression(Expression e)
{
_type = e.Type;
_columnType = e.ColumnType;
eArg = e.eArg;
eArg2 = e.eArg2;
cLikeEscape = e.cLikeEscape;
sSelect = e.sSelect;
fFunction = e.fFunction;
}
private Select ParseSelect()
{
Select select = new Select ();
// [email protected] begin changes from 1.50
select.limitStart = 0;
select.limitCount = cChannel.MaxRows;
// [email protected] end changes from 1.50
string token = tTokenizer.GetString ();
if (token.Equals ("DISTINCT")) {
select.bDistinct = true;
// [email protected] begin changes from 1.50
} else if (token.Equals ("LIMIT")) {
string limStart = tTokenizer.GetString ();
string limEnd = tTokenizer.GetString ();
//System.out.println( "LIMIT used from "+limStart+","+limEnd);
select.limitStart = int.Parse (limStart);
select.limitCount = int.Parse (limEnd);
// [email protected] end changes from 1.50
} else {
tTokenizer.Back ();
}
// parse column list
ArrayList vcolumn = new ArrayList ();
select.OnlyVars = true;
do {
Expression e = ParseExpression ();
token = tTokenizer.GetString ();
if (token.Equals ("AS")) {
e.Alias = tTokenizer.GetName ();
token = tTokenizer.GetString ();
} else if (tTokenizer.WasName) {
e.Alias = token;
token = tTokenizer.GetString ();
}
vcolumn.Add (e);
select.OnlyVars = select.OnlyVars & (e.Type == ExpressionType.Variable);
} while (token.Equals (","));
if (!select.OnlyVars) {
if (token.Equals ("INTO")) {
select.sIntoTable = tTokenizer.GetString ();
token = tTokenizer.GetString ();
}
if (!token.Equals ("FROM")) {
throw TracingHelper.Error (TracingHelper.UnexpectedToken, token);
}
Expression condition = null;
// parse table list
ArrayList vfilter = new ArrayList ();
vfilter.Add (ParseTableFilter (false));
while (true) {
token = tTokenizer.GetString ();
if (token.Equals ("LEFT")) {
token = tTokenizer.GetString ();
if (token.Equals ("OUTER")) {
token = tTokenizer.GetString ();
}
TracingHelper.Check (token.Equals ("JOIN"), TracingHelper.UnexpectedToken,
token);
vfilter.Add (ParseTableFilter (true));
tTokenizer.GetThis ("ON");
condition = AddCondition (condition, ParseExpression ());
} else if (token.Equals ("INNER")) {
tTokenizer.GetThis ("JOIN");
vfilter.Add (ParseTableFilter (false));
tTokenizer.GetThis ("ON");
condition = AddCondition (condition, ParseExpression ());
} else if (token.Equals (",")) {
vfilter.Add (ParseTableFilter (false));
} else {
break;
}
}
tTokenizer.Back ();
int len = vfilter.Count;
TableFilter[] filter = new TableFilter[len];
vfilter.CopyTo (filter);
select.tFilter = filter;
// expand [table.]* columns
len = vcolumn.Count;
for (int i = 0; i < len; i++) {
Expression e = (Expression)(vcolumn [i]);
if (e.Type == ExpressionType.Asterix) {
int current = i;
Table table = null;
string n = e.TableName;
for (int t = 0; t < filter.Length; t++) {
TableFilter f = filter [t];
e.Resolve (f);
if (n != null && !n.Equals (f.Name)) {
continue;
}
table = f.Table;
int col = table.ColumnCount;
for (int c = 0; c < col; c++) {
Expression ins =
new Expression (f.Name,
table.GetColumnName (c));
vcolumn.Insert (current++, ins);
// now there is one element more to parse
len++;
}
}
TracingHelper.Check (table != null, TracingHelper.TABLE_NOT_FOUND, n);
// minus the asterix element
len--;
vcolumn.RemoveAt (current);
} else if (e.Type == ExpressionType.DatabaseColumn) {
if (e.TableName == null) {
for (int filterIndex = 0; filterIndex < filter.Length; filterIndex++) {
e.Resolve (filter [filterIndex]);
}
}
}
}
select.iResultLen = len;
// where
token = tTokenizer.GetString ();
if (token.Equals ("WHERE")) {
condition = AddCondition (condition, ParseExpression ());
token = tTokenizer.GetString ();
}
select.eCondition = condition;
if (token.Equals ("GROUP")) {
tTokenizer.GetThis ("BY");
len = 0;
do {
vcolumn.Add (ParseExpression ());
token = tTokenizer.GetString ();
len++;
} while (token.Equals (","));
select.iGroupLen = len;
}
if (token.Equals ("ORDER")) {
tTokenizer.GetThis ("BY");
len = 0;
do {
Expression e = ParseExpression ();
if (e.Type == ExpressionType.Value) {
// order by 1,2,3
if (e.ColumnType == ColumnType.Integer) {
int i = Convert.ToInt32 (e.GetValue ());
e = (Expression)vcolumn [i - 1];
}
} else if (e.Type == ExpressionType.DatabaseColumn
&& e.TableName == null) {
// this could be an alias column
string s = e.ColumnName;
for (int i = 0; i < vcolumn.Count; i++) {
Expression ec = (Expression)vcolumn [i];
if (s.Equals (ec.Alias)) {
e = ec;
break;
}
}
}
token = tTokenizer.GetString ();
if (token.Equals ("DESC")) {
e.IsDescending = true;
token = tTokenizer.GetString ();
} else if (token.Equals ("ASC")) {
token = tTokenizer.GetString ();
}
vcolumn.Add (e);
len++;
} while (token.Equals (","));
select.iOrderLen = len;
}
len = vcolumn.Count;
select.eColumn = new Expression[len];
vcolumn.CopyTo (select.eColumn);
if (token.Equals ("UNION")) {
token = tTokenizer.GetString ();
if (token.Equals ("ALL")) {
select.UnionType = SelectType.UnionAll;
} else {
select.UnionType = SelectType.Union;
tTokenizer.Back ();
}
tTokenizer.GetThis ("SELECT");
select.sUnion = ParseSelect ();
} else if (token.Equals ("INTERSECT")) {
tTokenizer.GetThis ("SELECT");
select.UnionType = SelectType.Intersect;
select.sUnion = ParseSelect ();
} else if (token.Equals ("EXCEPT") || token.Equals ("MINUS")) {
tTokenizer.GetThis ("SELECT");
select.UnionType = SelectType.Except;
select.sUnion = ParseSelect ();
} else {
tTokenizer.Back ();
}
} else {
select.tFilter = new TableFilter[]{ };
int len = vcolumn.Count;
select.iResultLen = len;
select.eColumn = new Expression[len];
vcolumn.CopyTo (select.eColumn);
}
return select;
}
/// <summary>
/// Expression constructor using a <see cref="Select"/>.
/// </summary>
/// <param name="s"></param>
public Expression(Select s)
{
_type = ExpressionType.Query;
sSelect = s;
}
