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(); }