public ExpressionKind Eat([NotNull] ISnapshot snapshot, [NotNull] IQueryClause queryClause)
{
if (snapshot == null)
{
throw new ArgumentNullException("snapshot");
}
if (queryClause == null)
{
throw new ArgumentNullException("queryClause");
}
try
{
if (queryClause is T)
{
return(Eat(snapshot, (T)queryClause));
}
throw new UnexpectedTypeOfNodeToEatException(typeof(T), this, queryClause);
}
catch (ApplicationException)
{
throw;
}
catch (Exception ex)
{
throw new EatingException("Unexpected exception", ex, this, queryClause);
}
}
private List <string> GetResultColumns(IQueryClause queryClause)
{
var ret = new List <string>();
if (queryClause.Type == QueryType.Single)
{
var singleQueryClause = (SingleQueryClause)queryClause;
foreach (var result in singleQueryClause.Results)
{
if (!result.IsTableWildcard)
{
ret.Add(((ResultExpr)result).GetAliasOrColumnName());
}
}
return(ret);
}
else if (queryClause.Type == QueryType.Bracketed)
{
return(this.GetResultColumns(((BracketedQueryClause)queryClause).Operand));
}
else if (queryClause.Type == QueryType.Compound)
{
return(this.GetResultColumns(((CompoundQueryClause)queryClause).Left));
}
else
{
throw new InvalidEnumArgumentException("Undefined QueryType is used");
}
}
public virtual void VisitQueryClause(IQueryClause value)
{
if (value is IFromClause fromClause)
{
VisitFromClause(fromClause);
}
else if (value is IWhereClause whereClause)
{
VisitWhereClause(whereClause);
}
else if (value is ILetClause letClause)
{
VisitLetClause(letClause);
}
else if (value is IJoinClause clause)
{
VisitJoinClause(clause);
}
else if (value is IOrderClause orderClause)
{
VisitOrderClause(orderClause);
}
else
{
throw new NotSupportedException();
}
}
//public SqlPredicate ConvertToExistsExpr(SqlTable correlatedTable
// , IEnumerable<Tuple<string, bool>> tableColumnNames) {
// if(this.GetStatementType() != StatementType.Select) {
// throw new NotSupportedException("相関サブクエリに変形できるのはSELECT文のみです");
// }
// // 相関サブクエリにそのテーブル別名が存在しない場合、
// // また、存在した場合でもそのテーブル別名の実テーブル名が、
// // 被相関クエリの実テーブル名に一致しない場合、処理を中断する
// string correlatedTableName = null;
// foreach(var table in this.GetSrcTables()) {
// if(table.AliasName == correlatedTable.AliasName) {
// correlatedTableName = table.Name;
// break;
// }
// }
// if(string.IsNullOrEmpty(correlatedTableName)) {
// throw new ArgumentException(
// "相関対象テーブル別名が相関クエリに存在しません", "correlatedTableAliasName");
// }
// // (0) 相関クエリのSELECT句を定数値に変更する
// this.SetConstant();
// // (1) 相関クエリのOrderBy句を削除する
// this.ClearOrderBy();
// // (2) 相関クエリのメインクエリスコープに、相関対象テーブル名(又はテーブル別名)と
// // 同じテーブル名(又はテーブル別名)が存在する場合は、相関クエリのテーブル別名を変更する
// var tableAliasNameSub = correlatedTable.AliasName + "_";
// this.RenameTableAliasName(correlatedTable.AliasName, tableAliasNameSub);
// // (3) 相関クエリのSELECT句リストを取得する
// // それと同時に相関対象テーブルの主キーを相関クエリのメインスコープに引き上げる
// var resultInfoList = this.GetResultInfoList(correlatedTableName
// , tableColumnNames
// , ResultInfoAST.PrimaryKeyCompletion.SubQueryOnly);
// // (4) 相関クエリのSELECT句リストから、結合条件を作成し付加する
// var queryClause = (IQueryClause)((SelectStmt)this.GetStmt()).Query;
// this.AddCorrelatedConditions(queryClause, resultInfoList, null, tableAliasNameSub, correlatedTable.ExplicitAliasName);
// // (5) Existsで囲んで返す
// var query = ((SelectStmt)this.GetStmt()).Query;
// return new SqlPredicate(new ExistsPredicate(query));
//}
private void AddCorrelatedConditions(IQueryClause subQueryClause
, ResultInfoList subResultInfoList
, string oldTableAliasNameOfSub
, string correlatedTableAliasName)
{
foreach (var subResultInfo in subResultInfoList)
{
// キーのみを結合条件にする
if (subResultInfo.KeyType == KeyType.None)
{
continue;
}
if (subResultInfo.Type == ResultInfoType.Query)
{
var subQueryInfo = (QueryResultInfo)subResultInfo;
if (oldTableAliasNameOfSub == subQueryInfo.SourceTable.AliasName)
{
var tableAliasNameOfSub = this.GetSourceInfoOfSingleQueryResultInfo(subResultInfo).TableAliasName;
this.AddCorrelatedCondition(subQueryClause
, subResultInfo
, tableAliasNameOfSub
, null
, correlatedTableAliasName);
}
}
else if (subResultInfo.Type == ResultInfoType.Compound)
{
}
}
}
private void ReplaceWithConstant(IQueryClause queryClause)
{
if (queryClause.Type == QueryType.Single)
{
// SELECT句を定数1に置き換える
var singleQueryClause = ((SingleQueryClause)queryClause);
var results = singleQueryClause.Results;
singleQueryClause.HasWildcard = false;
results.Clear();
results.Add(new ResultExpr(new UNumericLiteral("1")));
}
else if (queryClause.Type == QueryType.Bracketed)
{
this.ReplaceWithConstant(((BracketedQueryClause)queryClause).Operand);
}
else if (queryClause.Type == QueryType.Compound)
{
this.ReplaceWithConstant(((CompoundQueryClause)queryClause).Left);
this.ReplaceWithConstant(((CompoundQueryClause)queryClause).Right);
}
else
{
throw new InvalidEnumArgumentException("Undefined QueryType is used");
}
}
public ExpressionKind Eat(ISnapshot snapshot, IQueryClause queryClause)
{
if (queryClause == null)
throw new ArgumentNullException("queryClause");
return GetEater(queryClause).Eat(snapshot, queryClause);
}
public ExpressionKind Eat(ISnapshot snapshot, IQueryClause queryClause)
{
if (queryClause == null)
{
throw new ArgumentNullException("queryClause");
}
return(GetEater(queryClause).Eat(snapshot, queryClause));
}
internal BracketedQuery(IQueryClause operand
, OrderBy orderBy
, ILimitClause limit
, Comments comments)
: base(operand, comments)
{
this.Operand = operand;
this.OrderBy = orderBy;
this.Limit = limit;
//this.IsSubQuery = true;
}
internal CompoundQueryClause(IQueryClause left
, CompoundType operater
, IQueryClause right
, Comments comments)
{
this.Left = left;
this.Operator = operater;
this.Right = right;
this.Comments = comments;
//this.IsSubQuery = true;
}
public IQueryClauseEater GetEater(IQueryClause queryClause)
{
var eater =
_container.GetInstance <IEnumerable <IQueryClauseEater> >()
.SingleOrDefault(t => t.QueryClauseType.IsInstanceOfType(queryClause));
if (eater == null)
{
return(new StubClauseEater());
}
return(eater);
}
internal CompoundQuery(IQueryClause left
, CompoundType operater
, IQueryClause right
, OrderBy orderBy
, ILimitClause limit
, Comments comments)
: base(left, operater, right, comments)
{
this.Left = left;
this.Operator = operater;
this.Right = right;
this.OrderBy = orderBy;
this.Limit = limit;
//this.IsSubQuery = true;
}
private bool HasTableWildcard(IQueryClause query)
{
if (query.Type == QueryType.Single)
{
return(((SingleQueryClause)query).Results.HasTableWildcard());
}
else if (query.Type == QueryType.Compound)
{
return(this.HasTableWildcard(((CompoundQueryClause)query).Left));
}
else if (query.Type == QueryType.Bracketed)
{
return(this.HasTableWildcard(((BracketedQueryClause)query).Operand));
}
else
{
throw new InvalidEnumArgumentException("Undefined QueryType is used");
}
}
private static IQuery CreateQuery(IQueryClause queryClause)
{
if (queryClause.Type == QueryType.Single)
{
return(new SingleQuery((SingleQueryClause)queryClause));
}
else if (queryClause.Type == QueryType.Compound)
{
return(new CompoundQuery((CompoundQueryClause)queryClause));
}
else if (queryClause.Type == QueryType.Bracketed)
{
return(new BracketedQuery((BracketedQueryClause)queryClause));
}
else
{
throw new InvalidEnumArgumentException("Undefined QueryType is used"
, (int)queryClause.Type
, typeof(QueryType));
}
}
// 結合条件を作成し付加する
private void AddCorrelatedConditions(IQueryClause subQueryClause
, ResultInfoList subResultInfoList
, ResultInfoList mainResultInfoList
, string tableAliasNameOfMain
, string correlatedTableAliasName)
{
foreach (var subResultInfo in subResultInfoList)
{
// キーのみを結合条件にする
if (subResultInfo.KeyType == KeyType.None)
{
continue;
}
foreach (var mainResultInfo in mainResultInfoList)
{
// キーのみを結合条件にする
if (mainResultInfo.KeyType == KeyType.None)
{
continue;
}
if (correlatedTableAliasName == mainResultInfo.SourceTable.AliasName &&
subResultInfo.SourceColumnName == mainResultInfo.SourceColumnName)
{
// 相関クエリのメインクエリスコープに、相関対象テーブル名(又はテーブル別名)を
// 抽出元にもつSELECT句があればそのSELECT句のテーブル別名を取得する
var tableAliasNameOfSub = this.GetSourceInfoOfSingleQueryResultInfo(subResultInfo).TableAliasName;
// 結合条件を作成し付加する
this.AddCorrelatedCondition(subQueryClause
, subResultInfo
, tableAliasNameOfSub
, mainResultInfo
, tableAliasNameOfMain);
}
} // foreach
} // foreach
}
private void ReplaceWithCountFunc(IQueryClause queryClause)
{
if (queryClause.Type == QueryType.Single)
{
// SELECT句をCOUNT(*)に置き換える
var singleQueryClause = ((SingleQueryClause)queryClause);
var results = singleQueryClause.Results;
singleQueryClause.HasWildcard = false;
results.Clear();
results.Add(new ResultExpr(new AggregateFuncExpr("COUNT", QuantifierType.None, true, null, null)));
}
else if (queryClause.Type == QueryType.Bracketed)
{
this.ReplaceWithCountFunc(((BracketedQueryClause)queryClause).Operand);
}
else if (queryClause.Type == QueryType.Compound)
{
throw new ApplicationException("Can't replace with count(*) compound query.");
}
else
{
throw new InvalidEnumArgumentException("Undefined QueryType is used");
}
}
public override Assignments GetAssignments(int index)
{
// テーブル列名の指定がない場合は、空のAssignmentsを返す
if (this.Columns == null || this.Columns.Count == 0)
{
return(new Assignments());
}
// Compound Queryの場合は空のAssignmentsを返す
SingleQueryClause singleQuery = null;
if (this.Query.Type == QueryType.Compound)
{
return(new Assignments());
}
else if (this.Query.Type == QueryType.Bracketed)
{
IQueryClause query = ((BracketedQuery)this.Query).Operand;
// 括弧を剥ぐ
while (query.Type == QueryType.Bracketed)
{
query = ((BracketedQueryClause)query).Operand;
}
if (query.Type != QueryType.Single)
{
return(new Assignments());
}
singleQuery = (SingleQueryClause)query;
}
else
{
singleQuery = (SingleQuery)this.Query;
}
// SELECT *の場合は空のAssignmentsを返す
if (singleQuery.HasWildcard)
{
return(new Assignments());
}
// テーブル列名とSELECT句の要素数が異なる場合はエラーとする
if (this.Columns.Count != singleQuery.Results.Count)
{
throw new InvalidASTStructureError("テーブル列名とSELECT句の要素数が異なります");
}
var ret = new Assignments();
for (var i = 0; i < Columns.Count; ++i)
{
var column = new Column(this.Columns[i].Name);
var result = singleQuery.Results[i];
// SELECT句にTable WildCardが含まれる場合は、空のAssignmentsを返す
if (result.IsTableWildcard)
{
return(new Assignments());
}
var value = ((ResultExpr)result).Value;
var assignment = new Assignment(column, value);
ret.Add(assignment);
}
return(ret);
}
public virtual void VisitQueryClause(IQueryClause value)
{
if (value is IFromClause)
{
this.VisitFromClause(value as IFromClause);
return;
}
if (value is IWhereClause)
{
this.VisitWhereClause(value as IWhereClause);
return;
}
if (value is ILetClause)
{
this.VisitLetClause(value as ILetClause);
return;
}
if (value is IJoinClause)
{
this.VisitJoinClause(value as IJoinClause);
return;
}
if (value is IOrderClause)
{
this.VisitOrderClause(value as IOrderClause);
return;
}
throw new NotSupportedException();
}
///// <summary>
/////
///// </summary>
///// <param name="subQuery">相関サブクエリ文</param>
///// <param name="correlatedTableAliasName">相関対象テーブル別名</param>
///// <param name="primaryKeys">相関対象テーブルの主キー</param>
//public void AddExistsExpr(SqlBuilder subQuery
// , string correlatedTableAliasName
// , IEnumerable<string> primaryKeys) {
// // subQueryがSELECT文であること
// if(subQuery.GetStatementType() != StatementType.Select) {
// throw new ArgumentException("相関サブクエリにSELECT文以外の文が指定されました", "subQuery");
// }
// var mainTableNames = this.GetSrcTableNames();
// var mainTableAliasNames = this.GetSrcTableAliasNames();
// var mainTables = this.GetSrcTables();
// // 引数で指定されたテーブル名が被相関クエリのテーブル別名に
// // 存在しない場合、処理を中断する
// var correlatedTableAliasNameFound = false;
// foreach(var mainTable in mainTables){
// if(mainTable.AliasName == correlatedTableAliasName) {
// correlatedTableAliasNameFound = true;
// break;
// }
// }
// if(!correlatedTableAliasNameFound){
// throw new ArgumentException("相関対象テーブル別名が被相関クエリに存在しません"
// , "correlatedTableAliasName");
// }
// // 相関サブクエリにそのテーブル別名が存在しない場合、
// // また、存在した場合でもそのテーブル別名の実テーブル名が、
// // 被相関クエリの実テーブル名に一致しない場合、処理を中断する
// var correlatedTableFound = false;
// foreach(var subTable in subQuery.GetSrcTables()) {
// foreach(var mainTable in mainTables) {
// if(mainTable.Name == subTable.Name &&
// mainTable.AliasName == subTable.AliasName) {
// correlatedTableFound = true;
// break;
// }
// }
// if(correlatedTableFound) {
// break;
// }
// }
// if(!correlatedTableFound){
// throw new ArgumentException("相関対象テーブル別名が相関クエリに存在しない、" +
// "または相関対象テーブル別名が同じでも被相関クエリと相関クエリとで" +
// "実テーブルが異なっています", "correlatedTableAliasName");
// }
// // メインSQLがSELECT文の場合は相関対象テーブルの主キーが
// // 相関サブクエリから参照できるようにする
// if(this.GetStatementType() == StatementType.Select) {
// this.RaisePrimaryKey(new Dictionary<string, IEnumerable<string>> { { correlatedTableName, primaryKeys } });
// }
//}
/// <summary>
/// SELECT文をEXISTS句に変換する
/// </summary>
/// <param name="subQuery">相関サブクエリ文</param>
/// <param name="correlatedTableAliasName">相関対象テーブル別名</param>
/// <param name="primaryKeys">相関対象テーブルの主キー</param>
public SqlPredicate ConvertToExistsExpr2(SqlBuilder mainSql
, SqlTable correlatedTable
, IEnumerable <Tuple <string, bool> > tableColumnNames)
{
if (this.GetStatementType() != StatementType.Select)
{
throw new NotSupportedException("相関サブクエリに変形できるのはSELECT文のみです");
}
// 相関サブクエリにそのテーブル別名が存在しない場合、
// また、存在した場合でもそのテーブル別名の実テーブル名が、
// 被相関クエリの実テーブル名に一致しない場合、処理を中断する
string correlatedTableName = null;
foreach (var table in this.GetSrcTables())
{
if (table.AliasName == correlatedTable.AliasName)
{
correlatedTableName = table.Name;
break;
}
}
if (string.IsNullOrEmpty(correlatedTableName))
{
throw new ArgumentException(
"相関対象テーブル別名が相関クエリに存在しません", "correlatedTableAliasName");
}
// (0) 相関クエリのSELECT句を定数値に変更する
if ((((SelectStmt)this.GetStmt()).Query).Type != QueryType.Compound)
{
this.SetConstant();
}
// (1) 相関クエリのOrderBy句を削除する
this.ClearOrderBy();
// (2) 相関クエリのメインクエリスコープに、相関対象テーブル名(又はテーブル別名)と
// 同じテーブル名(又はテーブル別名)が存在する場合は、相関クエリのテーブル別名を変更する
var tableAliasNameOfSub = correlatedTable.AliasName + "_";
this.RenameTableAliasName(correlatedTable.AliasName, tableAliasNameOfSub);
// 相関クエリが集合演算クエリの場合はWHERE句が付加できるようそのクエリをSELECT *で囲む
if ((((SelectStmt)this.GetStmt()).Query).Type == QueryType.Compound)
{
// ORDER BY句は削除済みなのでtableColumns引数は指定しなくても動作する
this.WrapInSelectStar(new Dictionary <string, IEnumerable <string> >());
}
// (3) 相関クエリのSELECT句リストを取得する
// それと同時に相関対象テーブルの主キーを相関クエリのメインスコープに引き上げる
var subResultInfoList = this.GetResultInfoList(correlatedTable.Name
, tableColumnNames
, ResultInfoAST.PrimaryKeyCompletion.SubQueryOnly);
string tableAliasNameOfMain = "";
IQueryClause subQueryClause = null;
if (mainSql.GetStatementType() == StatementType.Select)
{
// 被相関クエリが集合演算クエリの場合はWHERE句が付加できるようそのクエリをSELECT *で囲む
if ((((SelectStmt)mainSql.GetStmt()).Query).Type == QueryType.Compound)
{
// ORDER BY句は削除済みなのでtableColumns引数は指定しなくても動作する
mainSql.WrapInSelectStar(new Dictionary <string, IEnumerable <string> >());
}
// (3a) 被相関クエリのSELECT句リストを取得する
// それと同時に相関対象テーブルの主キーを相関クエリのメインスコープに引き上げる
var mainResultInfoList = mainSql.GetResultInfoList(correlatedTable.Name
, tableColumnNames
, ResultInfoAST.PrimaryKeyCompletion.SubQueryOnly);
// 被相関クエリのメインクエリスコープに、相関対象テーブル名(又はテーブル別名)を
// 抽出元にもつSELECT句があればそのSELECT句のテーブル別名を取得する
foreach (var resultInfo in mainResultInfoList)
{
if (resultInfo.SourceTable != null &&
resultInfo.SourceTable.AliasName == correlatedTable.AliasName)
{
if (resultInfo.Type == ResultInfoType.Query)
{
tableAliasNameOfMain = ((AbstractSingleQueryResultInfo)resultInfo).SourceInfo.TableAliasName;
break;
}
else if (resultInfo.Type == ResultInfoType.Compound)
{
tableAliasNameOfMain = ((CompoundQueryResultInfo)resultInfo).TableAliasName;
break;
}
}
} // foreach
// (4) 相関クエリのSELECT句リストから、結合条件を作成し付加する
subQueryClause = (IQueryClause)((SelectStmt)this.GetStmt()).Query;
this.AddCorrelatedConditions(subQueryClause
, subResultInfoList
, mainResultInfoList
, tableAliasNameOfMain
, correlatedTable.AliasName);
}
else
{
// (4) 相関クエリのSELECT句リストから、結合条件を作成し付加する
subQueryClause = (IQueryClause)((SelectStmt)this.GetStmt()).Query;
this.AddCorrelatedConditions(subQueryClause
, subResultInfoList
, tableAliasNameOfSub
, correlatedTable.ExplicitAliasName);
}// if
// (5) Existsで囲んで返す
var query = ((SelectStmt)this.GetStmt()).Query;
return(new SqlPredicate(new ExistsPredicate(query)));
}
// 結合条件を作成し付加する
// 付加できた場合はtrueを返す
private bool AddCorrelatedCondition(IQueryClause subQueryClause
, IResultInfo subResultInfo
, string tableAliasNameOfSub
, IResultInfo mainResultInfo
, string tableAliasNameOfMain)
{
if (subResultInfo.Type == ResultInfoType.Query)
{
var subQueryInfo = (QueryResultInfo)subResultInfo;
//// SELECT句の抽出元テーブル情報を取得する
// 結合条件を作成する
string condition;
string subTableAliasName = subQueryInfo.SourceInfo.TableAliasName;
string primaryKeyOfSubTable = subQueryInfo.SourceInfo.ColumnAliasName;
if (mainResultInfo == null)
{
var primaryKey = this.GetSourceTableResultInfo(subQueryInfo).ColumnAliasName;
condition = tableAliasNameOfSub + "." + primaryKeyOfSubTable
+ " = " +
tableAliasNameOfMain + "." + primaryKey;
}
else
{
string primaryKeyOfMainTable = mainResultInfo.ColumnAliasName;
condition = tableAliasNameOfSub + "." + primaryKeyOfSubTable
+ " = " +
tableAliasNameOfMain + "." + primaryKeyOfMainTable;
}
// 結合条件を追加する
var visitor = new AddWherePredicateVisitor(condition, _dbmsType, _forSqlAccessor);
subQueryClause.Accept(visitor);
return(true);
}
else if (subResultInfo.Type == ResultInfoType.Compound)
{
var compoundQueryInfo = (CompoundQueryResultInfo)subResultInfo;
if (subQueryClause.Type != QueryType.Compound)
{
return(false);
}
// 集合演算での抽出元の走査は左演算子を優先する
var ret = this.AddCorrelatedCondition(((CompoundQuery)subQueryClause).Left
, compoundQueryInfo.LeftResultInfo
, tableAliasNameOfSub
, mainResultInfo
, tableAliasNameOfMain);
if (!ret)
{
ret = this.AddCorrelatedCondition(((CompoundQuery)subQueryClause).Right
, compoundQueryInfo.RightResultInfo
, tableAliasNameOfSub
, mainResultInfo
, tableAliasNameOfMain);
}
return(ret);
}
else if (subResultInfo.Type == ResultInfoType.Count)
{
return(false);
}
else if (subResultInfo.Type == ResultInfoType.Table)
{
// selectItemがTableResultInfoの場合はない
throw new ArgumentException(
"GetCorrelatedCondition()にTableResultInfoは指定できません", "selectItem");
}
else
{
throw new InvalidEnumArgumentException("Undefined ResultInfoType is used"
, (int)subResultInfo.Type
, typeof(ResultInfoType));
}
}
public virtual IQueryClauseCollection TransformQueryClauseCollection(IQueryClauseCollection value)
{
IQueryClause[] array = new IQueryClause[value.Count];
for (int i = 0; i < value.Count; i++)
{
array[i] = this.TransformQueryClause(value[i]);
}
IQueryClauseCollection target = new QueryClauseCollection();
target.AddRange(array);
return target;
}
// 指定したQueryClauseのSELECT句情報を取得する
// (Column、AS別名)
private List <Tuple <Column, Identifier> > GetResults(IQueryClause queryClause)
{
var rets = new List <Tuple <Column, Identifier> >();
if (queryClause.Type == QueryType.Single)
{
var singleQueryClause = (SingleQueryClause)queryClause;
if (singleQueryClause.HasWildcard)
{
foreach (var resultInfo in _stack.Peek())
{
rets.Add(Tuple.Create <Column, Identifier>(null, resultInfo.ColumnAliasName));
}
}
else
{
foreach (var result in singleQueryClause.Results)
{
if (result.IsTableWildcard)
{
var tableAliasName = ((TableWildcard)result).TableAliasName;
foreach (var resultInfo in _stack.Peek())
{
if (resultInfo.TableAliasName == tableAliasName)
{
rets.Add(Tuple.Create <Column, Identifier>(null, resultInfo.ColumnAliasName));
}
} // foreach
}
else
{
var resultExpr = (ResultExpr)result;
var columnAliasName = resultExpr.GetAliasOrColumnName();
if (!string.IsNullOrEmpty(columnAliasName))
{
Tuple <Column, Identifier> ret;
if (resultExpr.Value.GetType() == typeof(Column))
{
ret = Tuple.Create((Column)resultExpr.Value, columnAliasName);
}
else
{
ret = Tuple.Create <Column, Identifier>(null, columnAliasName);
}
rets.Add(ret);
}
}
} // foreach
}
return(rets);
}
else if (queryClause.Type == QueryType.Bracketed)
{
return(this.GetResults(((BracketedQueryClause)queryClause).Operand));
}
else if (queryClause.Type == QueryType.Compound)
{
return(this.GetResults(((CompoundQueryClause)queryClause).Left));
}
else
{
throw new InvalidEnumArgumentException("Undefined QueryType is used");
}
}
private void WriteQueryClause(IQueryClause value, IFormatter formatter)
{
if (value is IWhereClause)
{
this.WriteWhereClause(value as IWhereClause, formatter);
return;
}
if (value is ILetClause)
{
this.WriteLetClause(value as ILetClause, formatter);
return;
}
if (value is IFromClause)
{
this.WriteFromClause(value as IFromClause, formatter);
return;
}
if (value is IJoinClause)
{
this.WriteJoinClause(value as IJoinClause, formatter);
return;
}
if (value is IOrderClause)
{
this.WriteOrderClause(value as IOrderClause, formatter);
return;
}
throw new NotSupportedException();
}
public ExpressionKind Eat(ISnapshot snapshot, IQueryClause queryClause)
{
return(ExpressionKind.None);
}
public AliasedQuery(IQueryClause queryClause, bool hasAs, Identifier aliasName)
: this(CreateQuery(queryClause), hasAs, aliasName)
{
}
public ExpressionKind Eat(ISnapshot snapshot, IQueryClause queryClause)
{
return ExpressionKind.None;
}
public IQueryClauseEater GetEater(IQueryClause queryClause)
{
var eater =
_container.GetInstance<IEnumerable<IQueryClauseEater>>()
.SingleOrDefault(t => t.QueryClauseType.IsInstanceOfType(queryClause));
if (eater == null)
{
return new StubClauseEater();
}
return eater;
}
internal BracketedQueryClause(IQueryClause operand, Comments comments)
{
this.Operand = operand;
this.Comments = comments;
//this.IsSubQuery = true;
}
public virtual IQueryClause TransformQueryClause(IQueryClause value)
{
if (value is IWhereClause)
{
return this.TransformWhereClause(value as IWhereClause);
}
if (value is ILetClause)
{
return this.TransformLetClause(value as ILetClause);
}
if (value is IFromClause)
{
return this.TransformFromClause(value as IFromClause);
}
if (value is IJoinClause)
{
return this.TransformJoinClause(value as IJoinClause);
}
if (value is IOrderClause)
{
return this.TransformOrderClause(value as IOrderClause);
}
throw new NotSupportedException();
}
