private SoqlExpression ParseBooleanPredicate()
{
if (tokenizer.IsKeyword("exists"))
{
SoqlQueryExpression query;
tokenizer.GetNextToken();
tokenizer.Expect(SoqlTokenType.LeftParen);
if (tokenizer.IsKeyword("select"))
{
query = ParseQuery();
}
else
{
query = new SoqlQueryExpression();
query.SelectExpressions.Add(new SoqlAsteriskExpression(null));
query.SelectAliases.Add(String.Empty);
ParseFrom(query);
tokenizer.ExpectKeyword("where");
query.WhereClause = ParseBooleanExpression();
}
tokenizer.Expect(SoqlTokenType.RightParen);
return(new SoqlExistsExpression(query));
}
return(ParseBooleanRelation());
}
private void ParseFrom(SoqlQueryExpression query)
{
for (;;)
{
string tableName = tokenizer.EatKeyword();
string alias;
if (tokenizer.IsKeyword("as"))
{
tokenizer.EatKeyword();
alias = tokenizer.EatKeyword();
}
else if (tokenizer.IsEOF() || tokenizer.IsKeyword("where") || tokenizer.IsKeyword("group") || tokenizer.IsKeyword("order") || tokenizer.IsKeyword("having") || tokenizer.TokenType == SoqlTokenType.Comma)
{
alias = String.Empty;
}
else
{
alias = tokenizer.EatKeyword();
}
query.From.Add(tableName);
query.FromAliases.Add(alias);
if (!tokenizer.IsToken(SoqlTokenType.Comma))
{
break;
}
tokenizer.GetNextToken();
}
}
private void ParseSelectExpressions(SoqlQueryExpression query)
{
for (;;)
{
SoqlExpression expr = ParseExpression();
string alias;
if (tokenizer.IsKeyword("as"))
{
tokenizer.EatKeyword();
alias = tokenizer.EatKeyword();
}
else
{
alias = String.Empty;
}
query.SelectExpressions.Add(expr);
query.SelectAliases.Add(alias);
if (!tokenizer.IsToken(SoqlTokenType.Comma))
{
break;
}
tokenizer.GetNextToken();
}
}
private void ParseOrderByExpressions(SoqlQueryExpression query)
{
tokenizer.ExpectKeyword("order");
tokenizer.ExpectKeyword("by");
for (;;)
{
SoqlExpression expr = ParseExpression();
string order = "asc";
if (tokenizer.IsKeyword("asc"))
{
order = "asc";
tokenizer.GetNextToken();
}
else if (tokenizer.IsKeyword("desc"))
{
order = "desc";
tokenizer.GetNextToken();
}
query.OrderByExpressions.Add(expr);
query.OrderByOrder.Add(order);
if (!tokenizer.IsToken(SoqlTokenType.Comma))
{
break;
}
tokenizer.GetNextToken();
}
}
private SoqlQueryExpression ParseSimplifiedQuery(string fromClass, string alias)
{
SoqlQueryExpression query = new SoqlQueryExpression();
query.From.Add(fromClass);
query.FromAliases.Add(String.Empty);
tokenizer.ExpectKeyword("where");
query.WhereClause = ParseBooleanExpression();
return query;
}
public static void ParseOrderBy(SoqlQueryExpression query, string expr)
{
SoqlParser parser = new SoqlParser(expr);
parser.ParseOrderByExpressions(query);
if (!parser.tokenizer.IsEOF())
{
throw new SoqlException("Unexpected token: " + parser.tokenizer.TokenValue, parser.tokenizer.TokenPosition);
}
}
private SoqlQueryExpression ParseSimplifiedQuery(string fromClass, string alias)
{
SoqlQueryExpression query = new SoqlQueryExpression();
query.From.Add(fromClass);
query.FromAliases.Add(String.Empty);
tokenizer.ExpectKeyword("where");
query.WhereClause = ParseBooleanExpression();
return(query);
}
private SoqlQueryExpression ParseQuery()
{
SoqlQueryExpression query = new SoqlQueryExpression();
tokenizer.ExpectKeyword("select");
if (tokenizer.IsKeyword("top"))
{
tokenizer.EatKeyword();
query.PageCount = Convert.ToInt32(tokenizer.TokenValue);
tokenizer.GetNextToken();
}
if (tokenizer.IsKeyword("skip"))
{
tokenizer.EatKeyword();
query.StartIdx = Convert.ToInt32(tokenizer.TokenValue);
tokenizer.GetNextToken();
}
if (tokenizer.IsKeyword("distinct"))
{
tokenizer.EatKeyword();
query.Distinct = true;
}
ParseSelectExpressions(query);
tokenizer.ExpectKeyword("from");
ParseFrom(query);
if (tokenizer.IsKeyword("where"))
{
tokenizer.EatKeyword();
query.WhereClause = ParseBooleanExpression();
}
if (tokenizer.IsKeyword("group"))
{
ParseGroupByExpressions(query);
}
if (tokenizer.IsKeyword("having"))
{
tokenizer.EatKeyword();
query.Having = ParseBooleanExpression();
}
if (tokenizer.IsKeyword("order"))
{
ParseOrderByExpressions(query);
}
return(query);
}
public static SoqlQueryExpression ParseQuery(string expr)
{
SoqlParser parser = new SoqlParser(expr);
SoqlQueryExpression q = parser.ParseQuery();
if (!parser.tokenizer.IsEOF())
{
throw new SoqlException("Unexpected token: " + parser.tokenizer.TokenValue, parser.tokenizer.TokenPosition);
}
return(q);
}
public override IDataReader ExecuteQuery(Sooda.QL.SoqlQueryExpression query, SchemaInfo schema, object[] parameters)
{
try
{
string queryText = SoqlToSql(query, schema, false);
return(ExecuteRawQuery(queryText, parameters));
}
catch (Exception ex)
{
logger.Error("Exception in ExecuteQuery: {0}", ex);
throw;
}
}
public void GetInvolvedClasses(SoqlQueryExpression query)
{
foreach (SoqlExpression expr in query.SelectExpressions)
expr.Accept(this);
if (query.WhereClause != null)
query.WhereClause.Accept(this);
if (query.Having != null)
query.Having.Accept(this);
foreach (SoqlExpression expr in query.GroupByExpressions)
expr.Accept(this);
foreach (SoqlExpression expr in query.OrderByExpressions)
expr.Accept(this);
}
protected virtual SoqlQueryExpression BuildDataQuery(ListInfo li, SoqlBooleanExpression whereClause, IList<string> theQueryParameters, int startIndex, int topCount, string orderBy, IList<string> selectAliases)
{
SoqlQueryExpression theQuery;
theQuery = new SoqlQueryExpression();
theQuery.SelectExpressions = new SoqlExpressionCollection();
theQuery.SelectAliases = new StringCollection();
theQuery.TopCount = topCount;
theQuery.From.Add(li.RecordClass);
theQuery.FromAliases.Add(String.Empty);
if (orderBy != null)
{
//ParseOrderBy(theQuery, orderBy, columns, theQueryParameters);
}
// special columns - class Name and key and label
theQuery.SelectExpressions.Add(new SoqlSoodaClassExpression());
theQuery.SelectAliases.Add(String.Empty);
ClassInfo ci = DatabaseSchema.FindClassByName(li.RecordClass);
Sooda.Schema.FieldInfo key_fi = ci.GetPrimaryKeyFields()[0]; // ci.GetPrimaryKeyField();
//theQuery.SelectExpressions.Add(new SoqlPathExpression(key_fi.Name));
//theQuery.SelectAliases.Add(String.Empty);
foreach (ListColumnInfo lci in li.Columns)
{
string alias = lci.DataField;
alias = alias.Replace('.', '_');
if (lci.DataExpression != null)
{
theQuery.SelectExpressions.Add(SoqlParser.ParseExpression(lci.DataExpression));
}
else
{
theQuery.SelectExpressions.Add(SoqlParser.ParseExpression(lci.DataField));
}
theQuery.SelectAliases.Add(alias);
//selectAliases.Add(alias);
}
theQuery.WhereClause = whereClause;
return theQuery;
}
public static SoqlBooleanExpression CollectionFor(CollectionManyToManyInfo coll, SoodaObject parent)
{
SoqlPathExpression needle = new SoqlPathExpression(coll.GetItemClass().GetFirstPrimaryKeyField().Name);
RelationInfo relation = coll.GetRelationInfo();
SoqlQueryExpression query = new SoqlQueryExpression();
query.SelectExpressions.Add(new SoqlPathExpression(relation.Table.Fields[coll.MasterField].Name));
query.SelectAliases.Add(string.Empty);
query.From.Add(relation.Name);
query.FromAliases.Add(string.Empty);
query.WhereClause = FieldEquals(relation.Table.Fields[1 - coll.MasterField].Name, parent);
SoqlExpressionCollection haystack = new SoqlExpressionCollection();
haystack.Add(query);
return(new SoqlBooleanInExpression(needle, haystack));
}
private void ParseGroupByExpressions(SoqlQueryExpression query)
{
tokenizer.ExpectKeyword("group");
tokenizer.ExpectKeyword("by");
for (;;)
{
SoqlExpression expr = ParseExpression();
query.GroupByExpressions.Add(expr);
if (!tokenizer.IsToken(SoqlTokenType.Comma))
{
break;
}
tokenizer.GetNextToken();
}
}
void Sooda.QL.ISoqlVisitor.Visit(SoqlQueryExpression v)
{
if (v.From.Count != 1)
{
throw new NotImplementedException();
}
IFieldContainer outerClass = _rootClass;
_rootClass = _rootClass.Schema.FindContainerByName(v.From[0]);
try
{
GetInvolvedClasses(v);
}
finally
{
_rootClass = outerClass;
}
}
public void RawExpression()
{
using (SoodaTransaction tran = new SoodaTransaction())
{
SoqlQueryExpression query = new SoqlQueryExpression();
query.From.Add("Contact");
query.FromAliases.Add(string.Empty);
query.SelectExpressions.Add(new SoqlRawExpression("COUNT(*)"));
query.SelectAliases.Add(string.Empty);
SoodaDataSource ds = tran.OpenDataSource("default");
using (IDataReader r = ds.ExecuteQuery(query, tran.Schema))
{
bool b = r.Read();
Assert.IsTrue(b);
int c = r.GetInt32(0);
Assert.AreEqual(7, c);
}
}
}
public void GetInvolvedClasses(SoqlQueryExpression query)
{
foreach (SoqlExpression expr in query.SelectExpressions)
{
expr.Accept(this);
}
if (query.WhereClause != null)
{
query.WhereClause.Accept(this);
}
if (query.Having != null)
{
query.Having.Accept(this);
}
foreach (SoqlExpression expr in query.GroupByExpressions)
{
expr.Accept(this);
}
foreach (SoqlExpression expr in query.OrderByExpressions)
{
expr.Accept(this);
}
}
void OutputOrderBy(SoqlQueryExpression v)
{
Output.Write("order by ");
if (v.OrderByExpressions.Count > 0)
{
_generatingOrderBy = true;
for (int i = 0; i < v.OrderByExpressions.Count; ++i)
{
if (i > 0)
Output.Write(", ");
OutputScalar(v.OrderByExpressions[i]);
Output.Write(' ');
Output.Write(v.OrderByOrder[i]);
}
_generatingOrderBy = false;
}
else
{
FieldInfo[] pkfis = Schema.FindClassByName(v.From[0]).GetPrimaryKeyFields();
for (int i = 0; i < pkfis.Length; i++)
{
if (i > 0)
Output.Write(", ");
OutputColumn(ActualFromAliases[0], pkfis[i]);
}
}
}
void DoVisit(SoqlQueryExpression v)
{
IndentLevel++;
try
{
WriteSelect();
if (v.StartIdx != 0 || v.PageCount != -1)
{
if (_builder.TopSupport == SqlTopSupportMode.OracleRowNum || _builder.TopSupport == SqlTopSupportMode.MSSQLRowNum)
{
GenerateUniqueAliases = true;
OutputColumns(v, true);
StartClause();
Output.Write("from (");
IndentLevel++;
WriteSelect();
Output.Write(' ');
if (_builder.TopSupport == SqlTopSupportMode.OracleRowNum)
{
Output.Write("rownum as rownum_, pgo.* from (");
IndentLevel++;
WriteSelect();
Output.Write(' ');
}
UniqueColumnId = 0;
}
}
if (v.Distinct)
Output.Write("distinct ");
OutputColumns(v, false);
if (v.StartIdx != 0 || v.PageCount != -1)
{
if (_builder.TopSupport == SqlTopSupportMode.MSSQLRowNum)
{
Output.Write(", ROW_NUMBER() over (");
OutputOrderBy(v);
Output.Write(") as rownum_");
}
}
StringWriter sw = new StringWriter();
TextWriter oldOutput = Output;
Output = sw;
if (v.GroupByExpressions.Count > 0)
{
StartClause();
Output.Write("group by ");
for (int i = 0; i < v.GroupByExpressions.Count; ++i)
{
if (i > 0)
Output.Write(", ");
OutputScalar(v.GroupByExpressions[i]);
}
}
if (v.Having != null)
{
StartClause();
Output.Write("having ");
v.Having.Accept(this);
}
if (v.OrderByExpressions.Count > 0
&& ((v.StartIdx == 0 && v.PageCount == -1) || _builder.TopSupport != SqlTopSupportMode.MSSQLRowNum))
{
StartClause();
OutputOrderBy(v);
}
if (_builder.TopSupport == SqlTopSupportMode.MSSQL2012 && (v.StartIdx != 0 || v.PageCount != -1))
{
if (v.OrderByExpressions.Count == 0)
{
StartClause();
OutputOrderBy(v);
}
StartClause();
Output.Write("offset ");
Output.Write(v.StartIdx);
Output.Write(" rows");
if (v.PageCount != -1)
{
Output.Write(" fetch next ");
Output.Write(v.PageCount);
Output.Write(" rows only");
}
}
if (v.PageCount != -1 && _builder.TopSupport == SqlTopSupportMode.MySqlLimit)
{
StartClause();
Output.Write("limit ");
Output.Write(v.StartIdx);
Output.Write(",");
Output.Write(v.PageCount);
}
StringWriter whereSW = new StringWriter();
Output = whereSW;
SoqlBooleanExpression limitedWhere = v.WhereClause;
for (int i = 0; i < v.From.Count; ++i)
{
Sooda.Schema.ClassInfo ci = Schema.FindClassByName(v.From[i]);
if (ci == null)
continue;
SoqlBooleanExpression restriction = Soql.ClassRestriction(new SoqlPathExpression(ActualFromAliases[i]), Schema, ci);
if (restriction != null)
{
limitedWhere = limitedWhere == null ? restriction : new SoqlBooleanAndExpression(limitedWhere, restriction);
}
}
if (limitedWhere != null || WhereJoins.Count > 0)
{
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
Output.Write("where ");
}
else
{
Output.Write(" where ");
}
bool first = true;
if (limitedWhere != null)
{
limitedWhere.Accept(this);
first = false;
}
foreach (string s in WhereJoins)
{
if (!first)
Output.Write(" and ");
Output.Write(s);
first = false;
}
}
Output = oldOutput;
if (IndentOutput)
{
// output FROM here
Output.WriteLine();
WriteIndentString();
Output.Write("from ");
}
else
{
Output.Write(" from ");
}
for (int i = 0; i < v.From.Count; ++i)
{
if (i > 0)
{
if (IndentOutput)
{
Output.WriteLine(',');
WriteIndentString();
Output.Write(" ");
}
else
{
Output.Write(',');
}
}
TableInfo tbl = Schema.FindContainerByName(v.From[i]).GetAllFields()[0].Table;
OutputTableFrom(tbl, ActualFromAliases[i]);
foreach (string s in FromJoins[i])
{
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
Output.Write(" ");
}
else
{
Output.Write(' ');
}
Output.Write(s);
}
}
Output.Write(whereSW.ToString());
Output.Write(sw.ToString());
if (v.StartIdx != 0 || v.PageCount != -1)
{
if (_builder.TopSupport == SqlTopSupportMode.OracleRowNum || _builder.TopSupport == SqlTopSupportMode.MSSQLRowNum)
{
if (_builder.TopSupport == SqlTopSupportMode.OracleRowNum)
{
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
}
Output.Write(") pgo ");
IndentLevel--;
}
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
}
Output.Write(") pg where rownum_ ");
if (v.PageCount != -1)
{
Output.Write("between ");
Output.Write(v.StartIdx + 1);
Output.Write(" and ");
Output.Write(v.StartIdx + v.PageCount);
}
else
{
Output.Write("> ");
Output.Write(v.StartIdx);
}
IndentLevel--;
}
}
}
finally
{
IndentLevel--;
}
}
public override void Visit(SoqlQueryExpression v)
{
SoqlToSqlConverter conv = this;
if (this.Query != null)
{
Output.Write('(');
if (IndentOutput)
Output.WriteLine();
conv = CreateSubconverter();
}
conv.Init(v);
conv.DoVisit(v);
if (conv != this)
Output.Write(')');
}
public void PrintQuery(SoqlQueryExpression expr)
{
expr.Accept(this);
}
void OutputColumns(SoqlQueryExpression v, bool onlyAliases)
{
if (v.SelectExpressions.Count == 0)
{
// simplified query - emit the primary key here
Sooda.Schema.ClassInfo ci = Schema.FindClassByName(v.From[0]);
bool first = true;
foreach (FieldInfo pkfi in ci.GetPrimaryKeyFields())
{
if (!first)
Output.Write(", ");
if (!onlyAliases)
OutputColumn(ActualFromAliases[0], pkfi);
if (GenerateColumnAliases || GenerateUniqueAliases)
{
if (!onlyAliases)
Output.Write(" as ");
Output.Write(_builder.QuoteIdentifier(pkfi.Name));
}
first = false;
}
}
else
{
for (int i = 0; i < v.SelectExpressions.Count; ++i)
{
if (i > 0)
{
if (IndentOutput)
{
Output.WriteLine(',');
WriteIndentString();
Output.Write(" ");
}
else
{
Output.Write(',');
}
}
SoqlExpression expr = v.SelectExpressions[i];
if (!onlyAliases)
OutputScalar(expr);
if (v.SelectAliases[i].Length > 0)
{
if (!onlyAliases)
Output.Write(" as ");
Output.Write(_builder.QuoteIdentifier(v.SelectAliases[i]));
}
else if (GenerateColumnAliases)
{
ISoqlSelectAliasProvider aliasProvider = expr as ISoqlSelectAliasProvider;
if (aliasProvider != null)
{
if (!onlyAliases)
Output.Write(" as ");
aliasProvider.WriteDefaultSelectAlias(Output);
}
}
else if (GenerateUniqueAliases)
{
if (!onlyAliases)
Output.Write(" as");
Output.Write(String.Format(" col_{0}", UniqueColumnId++));
}
}
}
}
private SoqlExpression ParseBooleanPredicate()
{
if (tokenizer.IsKeyword("exists"))
{
SoqlQueryExpression query;
tokenizer.GetNextToken();
tokenizer.Expect(SoqlTokenType.LeftParen);
if (tokenizer.IsKeyword("select"))
{
query = ParseQuery();
}
else
{
query = new SoqlQueryExpression();
query.SelectExpressions.Add(new SoqlAsteriskExpression(null));
query.SelectAliases.Add(String.Empty);
ParseFrom(query);
tokenizer.ExpectKeyword("where");
query.WhereClause = ParseBooleanExpression();
}
tokenizer.Expect(SoqlTokenType.RightParen);
return new SoqlExistsExpression(query);
}
return ParseBooleanRelation();
}
private string GetLoadingSelectStatement(ClassInfo classInfo, TableInfo tableInfo, out TableInfo[] loadedTables)
{
TableLoadingCache cache;
if (tableLoadingCache.TryGetValue(tableInfo, out cache))
{
loadedTables = cache.LoadedTables;
return cache.SelectStatement;
}
Queue<_QueueItem> queue = new Queue<_QueueItem>();
List<TableInfo> additional = new List<TableInfo>();
additional.Add(tableInfo);
SoqlQueryExpression queryExpression = new SoqlQueryExpression();
queryExpression.From.Add(classInfo.Name);
queryExpression.FromAliases.Add("");
foreach (FieldInfo fi in tableInfo.Fields)
{
SoqlPathExpression pathExpr = new SoqlPathExpression(fi.Name);
queryExpression.SelectExpressions.Add(pathExpr);
queryExpression.SelectAliases.Add("");
if (fi.ReferencedClass != null && fi.PrefetchLevel > 0)
{
_QueueItem item = new _QueueItem();
item.classInfo = fi.ReferencedClass;
item.level = fi.PrefetchLevel;
item.prefix = pathExpr;
queue.Enqueue(item);
}
}
// TODO - add prefetching
while (queue.Count > 0)
{
_QueueItem it = queue.Dequeue();
foreach (TableInfo ti in it.classInfo.UnifiedTables)
{
additional.Add(ti);
foreach (FieldInfo fi in ti.Fields)
{
// TODO - this relies on the fact that path expressions
// are never reconstructed or broken. We simply share previous prefix
// perhaps it's cleaner to Clone() the expression here
SoqlPathExpression extendedExpression = new SoqlPathExpression(it.prefix, fi.Name);
queryExpression.SelectExpressions.Add(extendedExpression);
queryExpression.SelectAliases.Add("");
if (it.level >= 1 && fi.PrefetchLevel > 0 && fi.ReferencedClass != null)
{
_QueueItem newItem = new _QueueItem();
newItem.classInfo = fi.ReferencedClass;
newItem.prefix = extendedExpression;
newItem.level = it.level - 1;
queue.Enqueue(newItem);
}
}
}
}
queryExpression.WhereClause = null;
int parameterPos = 0;
foreach (FieldInfo fi in tableInfo.Fields)
{
if (fi.IsPrimaryKey)
{
SoqlBooleanRelationalExpression expr = Soql.FieldEqualsParam(fi.Name, parameterPos);
if (parameterPos == 0)
{
queryExpression.WhereClause = expr;
}
else
{
queryExpression.WhereClause = new SoqlBooleanAndExpression(queryExpression.WhereClause, expr);
}
parameterPos++;
}
}
string query = SoqlToSql(queryExpression, tableInfo.OwnerClass.Schema, false);
// logger.Debug("Loading statement for table {0}: {1}", tableInfo.NameToken, query);
loadedTables = additional.ToArray();
tableLoadingCache[tableInfo] = new TableLoadingCache(query, loadedTables);
return query;
}
public override IDataReader LoadObjectList(SchemaInfo schemaInfo, ClassInfo classInfo, SoodaWhereClause whereClause, SoodaOrderBy orderBy, int startIdx, int pageCount, SoodaSnapshotOptions options, out TableInfo[] tables)
{
try
{
Queue<_QueueItem> queue = new Queue<_QueueItem>();
List<TableInfo> tablesArrayList = new List<TableInfo>(classInfo.UnifiedTables.Count);
SoqlQueryExpression queryExpression = new SoqlQueryExpression();
queryExpression.StartIdx = startIdx;
queryExpression.PageCount = pageCount;
queryExpression.From.Add(classInfo.Name);
queryExpression.FromAliases.Add("");
foreach (TableInfo ti in classInfo.UnifiedTables)
{
tablesArrayList.Add(ti);
foreach (FieldInfo fi in ti.Fields)
{
SoqlPathExpression pathExpr = new SoqlPathExpression(fi.Name);
queryExpression.SelectExpressions.Add(pathExpr);
queryExpression.SelectAliases.Add("");
if (fi.ReferencedClass != null && fi.PrefetchLevel > 0 && ((options & SoodaSnapshotOptions.PrefetchRelated) != 0))
{
_QueueItem item = new _QueueItem();
item.classInfo = fi.ReferencedClass;
item.level = fi.PrefetchLevel;
item.prefix = pathExpr;
queue.Enqueue(item);
}
}
}
while (queue.Count > 0)
{
_QueueItem it = queue.Dequeue();
foreach (TableInfo ti in it.classInfo.UnifiedTables)
{
tablesArrayList.Add(ti);
foreach (FieldInfo fi in ti.Fields)
{
// TODO - this relies on the fact that path expressions
// are never reconstructed or broken. We simply share previous prefix
// perhaps it's cleaner to Clone() the expression here
SoqlPathExpression extendedExpression = new SoqlPathExpression(it.prefix, fi.Name);
queryExpression.SelectExpressions.Add(extendedExpression);
queryExpression.SelectAliases.Add("");
if (it.level >= 1 && fi.PrefetchLevel > 0 && fi.ReferencedClass != null)
{
_QueueItem newItem = new _QueueItem();
newItem.classInfo = fi.ReferencedClass;
newItem.prefix = extendedExpression;
newItem.level = it.level - 1;
queue.Enqueue(newItem);
}
}
}
}
if (whereClause != null && whereClause.WhereExpression != null)
{
queryExpression.WhereClause = whereClause.WhereExpression;
}
if (orderBy != null)
{
queryExpression.SetOrderBy(orderBy);
}
string query = SoqlToSql(queryExpression, schemaInfo, false);
IDbCommand cmd = Connection.CreateCommand();
try
{
cmd.CommandTimeout = CommandTimeout;
}
catch (NotSupportedException e)
{
logger.Debug("CommandTimeout not supported. {0}", e.Message);
}
if (Transaction != null)
cmd.Transaction = this.Transaction;
SqlBuilder.BuildCommandWithParameters(cmd, false, query, whereClause.Parameters, false);
tables = tablesArrayList.ToArray();
return TimedExecuteReader(cmd);
}
catch (Exception ex)
{
logger.Error("Exception in LoadObjectList: {0}", ex);
throw;
}
}
protected string SoqlToSql(SoqlQueryExpression expr, SqlDataSource ds)
{
using (StringWriter sw1 = new StringWriter())
{
SoqlToSqlConverter converter = new SoqlToSqlConverter(sw1, this.DatabaseSchema, ds.SqlBuilder);
log.Trace("Converting: {0}", expr);
converter.ConvertQuery(expr);
log.Trace("Converted: {0}", sw1);
return sw1.ToString();
}
}
public void ConvertQuery(SoqlQueryExpression expr)
{
expr.Accept(this);
}
private void ParseFrom(SoqlQueryExpression query)
{
for (;;)
{
string tableName = tokenizer.EatKeyword();
string alias;
if (tokenizer.IsKeyword("as"))
{
tokenizer.EatKeyword();
alias = tokenizer.EatKeyword();
}
else if (tokenizer.IsEOF() || tokenizer.IsKeyword("where") || tokenizer.IsKeyword("group") || tokenizer.IsKeyword("order") || tokenizer.IsKeyword("having") || tokenizer.TokenType == SoqlTokenType.Comma)
{
alias = String.Empty;
}
else
{
alias = tokenizer.EatKeyword();
}
query.From.Add(tableName);
query.FromAliases.Add(alias);
if (!tokenizer.IsToken(SoqlTokenType.Comma))
break;
tokenizer.GetNextToken();
}
}
private void ParseGroupByExpressions(SoqlQueryExpression query)
{
tokenizer.ExpectKeyword("group");
tokenizer.ExpectKeyword("by");
for (;;)
{
SoqlExpression expr = ParseExpression();
query.GroupByExpressions.Add(expr);
if (!tokenizer.IsToken(SoqlTokenType.Comma))
break;
tokenizer.GetNextToken();
}
}
void Sooda.QL.ISoqlVisitor.Visit(SoqlQueryExpression v)
{
if (v.From.Count != 1)
throw new NotImplementedException();
IFieldContainer outerClass = _rootClass;
_rootClass = _rootClass.Schema.FindContainerByName(v.From[0]);
try
{
GetInvolvedClasses(v);
}
finally
{
_rootClass = outerClass;
}
}
public static SoqlBooleanExpression CollectionFor(CollectionManyToManyInfo coll, SoodaObject parent)
{
SoqlPathExpression needle = new SoqlPathExpression(coll.GetItemClass().GetFirstPrimaryKeyField().Name);
RelationInfo relation = coll.GetRelationInfo();
SoqlQueryExpression query = new SoqlQueryExpression();
query.SelectExpressions.Add(new SoqlPathExpression(relation.Table.Fields[coll.MasterField].Name));
query.SelectAliases.Add(string.Empty);
query.From.Add(relation.Name);
query.FromAliases.Add(string.Empty);
query.WhereClause = FieldEquals(relation.Table.Fields[1 - coll.MasterField].Name, parent);
SoqlExpressionCollection haystack = new SoqlExpressionCollection();
haystack.Add(query);
return new SoqlBooleanInExpression(needle, haystack);
}
public override IDataReader LoadMatchingPrimaryKeys(SchemaInfo schemaInfo, ClassInfo classInfo, SoodaWhereClause whereClause, SoodaOrderBy orderBy, int startIdx, int pageCount)
{
try
{
SoqlQueryExpression queryExpression = new SoqlQueryExpression();
foreach (FieldInfo fi in classInfo.GetPrimaryKeyFields())
{
queryExpression.SelectExpressions.Add(new SoqlPathExpression(fi.Name));
queryExpression.SelectAliases.Add("");
}
if (schemaInfo.GetSubclasses(classInfo).Count > 0)
{
queryExpression.SelectExpressions.Add(new SoqlPathExpression(classInfo.SubclassSelectorField.Name));
queryExpression.SelectAliases.Add("");
}
queryExpression.StartIdx = startIdx;
queryExpression.PageCount = pageCount;
queryExpression.From.Add(classInfo.Name);
queryExpression.FromAliases.Add("");
if (whereClause != null && whereClause.WhereExpression != null)
{
queryExpression.WhereClause = whereClause.WhereExpression;
}
if (orderBy != null)
{
queryExpression.SetOrderBy(orderBy);
}
string query = SoqlToSql(queryExpression, schemaInfo, false);
IDbCommand cmd = Connection.CreateCommand();
try
{
cmd.CommandTimeout = CommandTimeout;
}
catch (NotSupportedException e)
{
logger.Debug("CommandTimeout not supported. {0}", e.Message);
}
if (Transaction != null)
cmd.Transaction = this.Transaction;
SqlBuilder.BuildCommandWithParameters(cmd, false, query, whereClause.Parameters, false);
return TimedExecuteReader(cmd);
}
catch (Exception ex)
{
logger.Error("Exception in LoadMatchingPrimaryKeys: {0}", ex);
throw;
}
}
public SoqlExistsExpression(SoqlQueryExpression query)
{
this.Query = query;
}
private string SoqlToSql(SoqlQueryExpression queryExpression, SchemaInfo schemaInfo, bool generateColumnAliases)
{
StringWriter sw = new StringWriter();
SoqlToSqlConverter converter = new SoqlToSqlConverter(sw, schemaInfo, SqlBuilder);
converter.IndentOutput = this.IndentQueries;
converter.GenerateColumnAliases = generateColumnAliases;
converter.UpperLike = this.UpperLike;
//logger.Trace("Converting {0}", queryExpression);
converter.ConvertQuery(queryExpression);
string query = sw.ToString();
//logger.Trace("Converted as {0}", query);
return query;
}
SoqlQueryExpression CreateCollectionQuery(ClassInfo currentClass, string p, CollectionOnetoManyInfo col1n, SoqlExpression selectExpression, SoqlExpression needle)
{
SoqlBooleanExpression where = new SoqlBooleanRelationalExpression(
new SoqlPathExpression(col1n.ForeignField2.Name),
new SoqlPathExpression(new SoqlPathExpression(p.Split('.')), currentClass.GetFirstPrimaryKeyField().Name),
SoqlRelationalOperator.Equal);
if (col1n.Where != null && col1n.Where.Length > 0)
where &= SoqlParser.ParseWhereClause(col1n.Where);
string fromAlias = string.Empty;
if (needle != null)
{
SoqlQueryExpression nq = needle as SoqlQueryExpression;
if (nq != null
&& nq.StartIdx == 0 && nq.PageCount == -1 && nq.SelectExpressions.Count == 0
&& nq.From.Count == 1 && nq.From[0] == col1n.ClassName
&& nq.Having == null && nq.GroupByExpressions.Count == 0)
{
fromAlias = nq.FromAliases[0];
if (nq.WhereClause != null)
where &= nq.WhereClause;
}
else
{
if (col1n.Class.GetPrimaryKeyFields().Length >= 2)
throw new NotSupportedException("Contains() with composite primary key");
SoqlExpressionCollection collection = new SoqlExpressionCollection();
collection.Add(needle);
where &= new SoqlBooleanInExpression(
new SoqlPathExpression(col1n.Class.GetFirstPrimaryKeyField().Name),
collection);
}
}
SoqlQueryExpression query = new SoqlQueryExpression();
query.SelectExpressions.Add(selectExpression);
query.SelectAliases.Add("");
query.From.Add(col1n.ClassName);
query.FromAliases.Add(fromAlias);
query.WhereClause = where;
return query;
}
public SoqlExistsExpression(SoqlQueryExpression query)
{
this.Query = query;
}
private void ParseSelectExpressions(SoqlQueryExpression query)
{
for (;;)
{
SoqlExpression expr = ParseExpression();
string alias;
if (tokenizer.IsKeyword("as"))
{
tokenizer.EatKeyword();
alias = tokenizer.EatKeyword();
}
else
{
alias = String.Empty;
}
query.SelectExpressions.Add(expr);
query.SelectAliases.Add(alias);
if (!tokenizer.IsToken(SoqlTokenType.Comma))
break;
tokenizer.GetNextToken();
}
}
public virtual void Visit(SoqlQueryExpression v)
{
Output.Write('(');
if (IndentOutput)
{
Output.WriteLine();
}
IndentLevel++;
try
{
if (v.SelectExpressions.Count > 0)
{
WriteIndentString();
Output.Write("select ");
if (v.Distinct)
{
Output.Write("distinct ");
}
for (int i = 0; i < v.SelectExpressions.Count; ++i)
{
if (i > 0)
{
if (IndentOutput)
{
Output.WriteLine(',');
WriteIndentString();
Output.Write(" ");
}
else
{
Output.Write(',');
}
}
if (v.SelectExpressions[i] is SoqlQueryExpression)
{
Output.Write('(');
}
v.SelectExpressions[i].Accept(this);
if (v.SelectExpressions[i] is SoqlQueryExpression)
{
Output.Write(')');
}
if (v.SelectAliases[i].Length > 0)
{
Output.Write(" as ");
Output.Write(v.SelectAliases[i]);
}
}
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
Output.Write("from ");
}
else
{
Output.Write(" from ");
}
}
else
{
WriteIndentString();
}
for (int i = 0; i < v.From.Count; ++i)
{
if (i > 0)
{
if (IndentOutput)
{
Output.WriteLine(',');
WriteIndentString();
Output.Write(" ");
}
else
{
Output.Write(',');
}
}
Output.Write(v.From[i]);
if (v.FromAliases[i].Length > 0)
{
Output.Write(" as ");
Output.Write(v.FromAliases[i]);
}
}
if (v.WhereClause != null)
{
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
Output.Write("where ");
}
else
{
Output.Write(" where ");
}
v.WhereClause.Accept(this);
}
if (v.GroupByExpressions != null && v.GroupByExpressions.Count > 0)
{
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
}
else
{
Output.Write(' ');
}
Output.Write("group by ");
for (int i = 0; i < v.GroupByExpressions.Count; ++i)
{
if (i > 0)
{
Output.Write(", ");
}
v.GroupByExpressions[i].Accept(this);
}
}
if (v.Having != null)
{
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
}
else
{
Output.Write(' ');
}
Output.Write("having ");
v.Having.Accept(this);
}
if (v.OrderByExpressions != null && v.OrderByExpressions.Count > 0)
{
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
}
else
{
Output.Write(' ');
}
Output.Write("order by ");
for (int i = 0; i < v.OrderByExpressions.Count; ++i)
{
if (i > 0)
{
Output.Write(", ");
}
v.OrderByExpressions[i].Accept(this);
Output.Write(' ');
Output.Write(v.OrderByOrder[i]);
}
}
}
finally
{
IndentLevel--;
}
Output.Write(')');
}
private void ParseOrderByExpressions(SoqlQueryExpression query)
{
tokenizer.ExpectKeyword("order");
tokenizer.ExpectKeyword("by");
for (;;)
{
SoqlExpression expr = ParseExpression();
string order = "asc";
if (tokenizer.IsKeyword("asc"))
{
order = "asc";
tokenizer.GetNextToken();
}
else if (tokenizer.IsKeyword("desc"))
{
order = "desc";
tokenizer.GetNextToken();
}
query.OrderByExpressions.Add(expr);
query.OrderByOrder.Add(order);
if (!tokenizer.IsToken(SoqlTokenType.Comma))
break;
tokenizer.GetNextToken();
}
}
public virtual void Visit(SoqlQueryExpression v)
{
Output.Write('(');
if (IndentOutput)
Output.WriteLine();
IndentLevel++;
try
{
if (v.SelectExpressions.Count > 0)
{
WriteIndentString();
Output.Write("select ");
if (v.Distinct)
Output.Write("distinct ");
for (int i = 0; i < v.SelectExpressions.Count; ++i)
{
if (i > 0)
{
if (IndentOutput)
{
Output.WriteLine(',');
WriteIndentString();
Output.Write(" ");
}
else
{
Output.Write(',');
}
}
if (v.SelectExpressions[i] is SoqlQueryExpression)
Output.Write('(');
v.SelectExpressions[i].Accept(this);
if (v.SelectExpressions[i] is SoqlQueryExpression)
Output.Write(')');
if (v.SelectAliases[i].Length > 0)
{
Output.Write(" as ");
Output.Write(v.SelectAliases[i]);
}
}
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
Output.Write("from ");
}
else
{
Output.Write(" from ");
}
}
else
{
WriteIndentString();
}
for (int i = 0; i < v.From.Count; ++i)
{
if (i > 0)
{
if (IndentOutput)
{
Output.WriteLine(',');
WriteIndentString();
Output.Write(" ");
}
else
{
Output.Write(',');
}
}
Output.Write(v.From[i]);
if (v.FromAliases[i].Length > 0)
{
Output.Write(" as ");
Output.Write(v.FromAliases[i]);
}
}
if (v.WhereClause != null)
{
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
Output.Write("where ");
}
else
{
Output.Write(" where ");
}
v.WhereClause.Accept(this);
}
if (v.GroupByExpressions != null && v.GroupByExpressions.Count > 0)
{
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
}
else
{
Output.Write(' ');
}
Output.Write("group by ");
for (int i = 0; i < v.GroupByExpressions.Count; ++i)
{
if (i > 0)
Output.Write(", ");
v.GroupByExpressions[i].Accept(this);
}
}
if (v.Having != null)
{
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
}
else
{
Output.Write(' ');
}
Output.Write("having ");
v.Having.Accept(this);
}
if (v.OrderByExpressions != null && v.OrderByExpressions.Count > 0)
{
if (IndentOutput)
{
Output.WriteLine();
WriteIndentString();
}
else
{
Output.Write(' ');
}
Output.Write("order by ");
for (int i = 0; i < v.OrderByExpressions.Count; ++i)
{
if (i > 0)
Output.Write(", ");
v.OrderByExpressions[i].Accept(this);
Output.Write(' ');
Output.Write(v.OrderByOrder[i]);
}
}
}
finally
{
IndentLevel--;
}
Output.Write(')');
}
private SoqlQueryExpression ParseQuery()
{
SoqlQueryExpression query = new SoqlQueryExpression();
tokenizer.ExpectKeyword("select");
if (tokenizer.IsKeyword("top"))
{
tokenizer.EatKeyword();
query.PageCount = Convert.ToInt32(tokenizer.TokenValue);
tokenizer.GetNextToken();
}
if (tokenizer.IsKeyword("skip"))
{
tokenizer.EatKeyword();
query.StartIdx = Convert.ToInt32(tokenizer.TokenValue);
tokenizer.GetNextToken();
}
if (tokenizer.IsKeyword("distinct"))
{
tokenizer.EatKeyword();
query.Distinct = true;
}
ParseSelectExpressions(query);
tokenizer.ExpectKeyword("from");
ParseFrom(query);
if (tokenizer.IsKeyword("where"))
{
tokenizer.EatKeyword();
query.WhereClause = ParseBooleanExpression();
}
if (tokenizer.IsKeyword("group"))
{
ParseGroupByExpressions(query);
}
if (tokenizer.IsKeyword("having"))
{
tokenizer.EatKeyword();
query.Having = ParseBooleanExpression();
}
if (tokenizer.IsKeyword("order"))
{
ParseOrderByExpressions(query);
}
return query;
}
public void PrintQuery(SoqlQueryExpression expr)
{
expr.Accept(this);
}
public static void ParseOrderBy(SoqlQueryExpression query, string expr)
{
SoqlParser parser = new SoqlParser(expr);
parser.ParseOrderByExpressions(query);
if (!parser.tokenizer.IsEOF())
throw new SoqlException("Unexpected token: " + parser.tokenizer.TokenValue, parser.tokenizer.TokenPosition);
}
public void Init(SoqlQueryExpression query)
{
this.Query = query;
StringCollection killPrefixes = new StringCollection();
for (int i = 0; i < query.From.Count; ++i)
{
FromJoins.Add(new StringCollection());
string table = query.From[i];
string alias = query.FromAliases[i];
if (alias.Length == 0)
{
alias = GetNextTablePrefix();
}
ActualFromAliases.Add(alias);
if (!ExpressionPrefixToTableAlias.ContainsKey(alias))
{
ExpressionPrefixToTableAlias.Add(alias, alias);
}
else
{
killPrefixes.Add(alias);
}
if (!ExpressionPrefixToTableAlias.ContainsKey(table))
{
ExpressionPrefixToTableAlias.Add(table, alias);
}
else
{
killPrefixes.Add(table);
}
if (!TableAliases.ContainsKey(alias))
{
TableAliases.Add(alias, table);
}
if (!TableAliases.ContainsKey(table))
{
TableAliases.Add(table, table);
}
}
foreach (string s in killPrefixes)
{
TableAliases.Remove(s);
ExpressionPrefixToTableAlias.Remove(s);
}
}
