/// Implements <Query> ::= SELECT <TypeIdentifier> WHERE <Expression>
public Reduction CreateRULE_QUERY_SELECT_WHERE(Reduction reduction)
{
//selectType can be one of the following depending on the query text: -
//1. A plain string that is the name of Type; we can build IsOfTypePredicate from this.
//2. AggregateFunctionPredicate that has IsOfTypePredicate set as its ChildPredicate // cant be this, grammer changed
//3. IsOfTypePredicate
object selectType = ((Reduction)reduction.GetToken(1).Data).Tag;
Predicate lhs = null;
Predicate rhs = (Predicate)((Reduction)reduction.GetToken(3).Data).Tag;
Predicate selectTypePredicate = selectType as Predicate;
Predicate result = null;
//1. selectType is string
if (selectTypePredicate == null)
{
lhs = new IsOfTypePredicate(selectType.ToString());
result = ExpressionBuilder.CreateLogicalAndPredicate(lhs, rhs);
}
////2. selectType is AggregateFunctionPredicate
//3. selectType is IsOfTypePredicate
else
{
lhs = selectTypePredicate;
result = ExpressionBuilder.CreateLogicalAndPredicate(lhs, rhs);
}
reduction.Tag = result;
if (NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_QUERY_SELECT_WHERE");
return null;
}
public ParseMessage Parse(string query)
{
NCQLParser parser = new NCQLParser(ResourceName, _ncacheLog);
System.IO.TextReader tr = new System.IO.StringReader(query);
ParseMessage message = parser.Parse(tr, true);
_currentReduction = parser.CurrentReduction;
return message;
}
/// Pops the specified number of tokens from the stack and adds them
/// to the specified <c>Reduction</c>.
public void PopTokensInto(Reduction p_reduction, int p_count)
{
int start = m_items.Count - p_count;
int end = m_items.Count;
for (int i = start; i < end; i++)
p_reduction.AddToken((Token)m_items[i]);
m_items.RemoveRange(start, p_count);
}
/// Pops the specified number of tokens from the stack and adds them
/// to the specified <c>Reduction</c>.
public void PopTokensInto(Reduction p_reduction, int p_count)
{
int start = m_items.Count - p_count;
int end = m_items.Count;
for (int i = start; i < end; i++)
{
p_reduction.AddToken((Token)m_items[i]);
}
m_items.RemoveRange(start, p_count);
}
/// Implements <Query> ::= SELECT <TypeIdentifier>
public Reduction CreateRULE_QUERY_SELECT(Reduction reduction)
{
object selectType = ((Reduction)((Token)reduction.GetToken(1)).Data).Tag;
Predicate selectTypePredicate = selectType as Predicate;
if (selectTypePredicate == null)
reduction.Tag = new IsOfTypePredicate(selectType.ToString());
else
reduction.Tag = selectTypePredicate;
if(NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_QUERY_SELECT");
return null;
}
/// <summary>Produces a reduction.</summary>
/// <remarks>Removes as many tokens as members in the rule and pushes a
/// non-terminal token.</remarks>
private ParseResult Reduce(Rule p_rule)
{
ParseResult result;
Token head;
if (m_trimReductions && p_rule.ContainsOneNonTerminal)
{
// The current rule only consists of a single nonterminal and can be trimmed from the
// parse tree. Usually we create a new Reduction, assign it to the Data property
// of Head and push it on the stack. However, in this case, the Data property of the
// Head will be assigned the Data property of the reduced token (i.e. the only one
// on the stack). In this case, to save code, the value popped of the stack is changed
// into the head.
head = m_tempStack.PopToken();
head.SetParent(p_rule.RuleNonTerminal);
result = ParseResult.ReduceEliminated;
}
else
{
Reduction reduction = new Reduction();
reduction.ParentRule = p_rule;
m_tempStack.PopTokensInto(reduction, p_rule.SymbolCount);
head = new Token();
head.Data = reduction;
head.SetParent(p_rule.RuleNonTerminal);
m_haveReduction = true;
result = ParseResult.ReduceNormal;
}
int index = m_tempStack.PeekToken().State;
LRAction action = m_LalrTables[index].GetActionForSymbol(p_rule.RuleNonTerminal.TableIndex);
if (action != null)
{
head.State = m_LalrState = action.Value;;
m_tempStack.PushToken(head);
}
else
{
throw new ParserException("Action for LALR state is null");
}
return(result);
}
/// Implements <CompareExpr> ::= <Value> Type Plus Attribute DOT
public Reduction CreateRULE_TYPEPLUSATTRIBUTE_DOT(Reduction reduction)
{
return null;
}
/// Implements <CompareExpr> ::= <Value> Property Identifier
public Reduction CreateRULE_PROPERTY_IDENTIFIER(Reduction reduction)
{
return CreateRULE_OBJECTTYPE_IDENTIFIER(reduction);
}
/// Implements <CompareExpr> ::= <Value> ObjectType
public Reduction CreateRULE_OBJECTTYPE(Reduction reduction)
{
return null;
}
/// Implements <StrLiteralList> ::= <StrLiteral> ',' <StrLiteralList>
public Reduction CreateRULE_STRLITERALLIST_COMMA(Reduction reduction)
{
return CreateInclusionList(reduction);
}
/// Implements <Identifier> ::= Identifier
public Reduction CreateRULE_IDENTIFIER_IDENTIFIER(Reduction reduction)
{
reduction.Tag = ((Token)reduction.GetToken(0)).Data.ToString();
if(NCacheLog.IsInfoEnabled) NCacheLog.Info("RULE_IDENTIFIER_IDENTIFIER -> " + reduction.Tag);
return null;
}
///Implements <ObjectAttribute> ::= Keyword '.' Identifier
public Reduction CreateRULE_OBJECTATTRIBUTE_KEYWORD_DOT_IDENTIFIER(Reduction reduction)
{
return CreateRULE_OBJECTVALUE_KEYWORD_DOT_IDENTIFIER(reduction);
}
/// Implements <CompareExpr> ::= <Value> COUNT Function COUNT LParan RParan
public Reduction CreateRULE_COUNTFUNCTION_COUNTLPARAN_RPARAN(Reduction reduction)
{
return CreateRULE_COUNTFUNCTION_COUNTLPARAN_TIMES_RPARAN(reduction);
}
public Reduction CreateRULE_DELETEPARAMS_DOLLARTEXTDOLLAR(Reduction reduction)
{
reduction.Tag = "System.String";
if (NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_OBJECTTYPE_DOLLARTEXTDOLLAR");
return null;
}
public Reduction CreateRULE_OBJECTVALUE_KEYWORD_DOT_IDENTIFIER(Reduction reduction)
{
if(NCacheLog.IsInfoEnabled) NCacheLog.Info("RULE_OBJECTVALUE_KEYWORD_DOT_IDENTIFIER");
string memName = reduction.GetToken(2).Data.ToString();
reduction.Tag = new MemberFunction(memName);
return null;
}
public Reduction CreateRULE_DATE_DATETIME_LPARAN_STRINGLITERAL_RPARAN(Reduction reduction)
{
if(NCacheLog.IsInfoEnabled) NCacheLog.Info("RULE_DATE_DATETIME_LPARAN_STRINGLITERAL_RPARAN");
string dateTime = reduction.GetToken(2).Data.ToString().Trim('\'');
reduction.Tag = new DateTimeConstantValue(dateTime);
return null;
}
//self create
//=========================
public Reduction CreateRULE_ATRRIB(Reduction reduction)
{
if(NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_ATRRIB");
reduction.Tag = ((Reduction)((Token)reduction.GetToken(0)).Data).Tag;
return null;
}
/// Implements <DateList> ::= <Date> ',' <DateList>
public Reduction CreateRULE_DATELIST_COMMA(Reduction reduction)
{
return CreateInclusionList(reduction);
}
///Implements <Query> ::= SELECT <AggregateFunction>
public Reduction CreateRULE_QUERY_SELECT2(Reduction reduction)
{
return CreateRULE_QUERY_SELECT(reduction);
}
/// Implements <CompareExpr> ::= <Value> Aggregate Function5
public Reduction CreateRULE_AGGREGATEFUNCTION5(Reduction reduction)
{
return null;
}
/// Implements <InList> ::= '(' <ListType> ')'
public Reduction CreateRULE_INLIST_LPARAN_RPARAN(Reduction reduction)
{
if(NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_INLIST_LPARAN_RPARAN");
object obj = ((Reduction)((Token)reduction.GetToken(1)).Data).Tag;
if (obj is ConstantValue || obj is RuntimeValue)
{
IsInListPredicate pred = new IsInListPredicate();
pred.Append(obj);
reduction.Tag = pred;
}
else
{
reduction.Tag = ((Reduction)((Token)reduction.GetToken(1)).Data).Tag;
}
return null;
}
/// Implements <CountFunction> ::= 'COUNT(' <Property> ')'
public Reduction CreateRULE_COUNTFUNCTION_COUNTLPARAN_TIMES_RPARAN(Reduction reduction)
{
string typeName = ((Reduction)reduction.GetToken(1).Data).Tag as string;
Predicate childPredicate = new IsOfTypePredicate(typeName);
AggregateFunctionPredicate countFunctionPredicate = ExpressionBuilder.CreateCountFunctionPredicate() as AggregateFunctionPredicate;
countFunctionPredicate.ChildPredicate = childPredicate;
reduction.Tag = countFunctionPredicate;
return null;
}
//========================
public Reduction CreateInclusionList(Reduction reduction)
{
object tag = ((Reduction)reduction.GetToken(2).Data).Tag;
IsInListPredicate inc = null;
if(tag is IsInListPredicate)
inc = tag as IsInListPredicate;
else
{
inc = new IsInListPredicate();
inc.Append(tag);
}
inc.Append(((Reduction)reduction.GetToken(0).Data).Tag);
reduction.Tag = inc;
return null;
}
private Reduction CreateNewObject(Reduction reduction)
{
Reduction result = null;
switch((RuleConstants)Enum.ToObject(typeof(RuleConstants), reduction.ParentRule.TableIndex))
{
case RuleConstants.RULE_QUERY_SELECT :
////<Query> ::= SELECT <ObjectType>
result = _parserRule.CreateRULE_QUERY_SELECT(reduction);
break;
case RuleConstants.RULE_QUERY_SELECT_WHERE :
////<Query> ::= SELECT <ObjectType> WHERE <Expression>
result = _parserRule.CreateRULE_QUERY_SELECT_WHERE(reduction);
break;
case RuleConstants.RULE_QUERY_SELECT2 :
////<Query> ::= SELECT <AggregateFunction>
result = _parserRule.CreateRULE_QUERY_SELECT2(reduction);
break;
case RuleConstants.RULE_QUERY_SELECT_WHERE2 :
////<Query> ::= SELECT <AggregateFunction> WHERE <Expression>
result = _parserRule.CreateRULE_QUERY_SELECT_WHERE2(reduction);
break;
case RuleConstants.RULE_EXPRESSION :
////<Expression> ::= <OrExpr>
result = _parserRule.CreateRULE_EXPRESSION(reduction);
break;
case RuleConstants.RULE_OREXPR_OR :
////<OrExpr> ::= <OrExpr> OR <AndExpr>
result = _parserRule.CreateRULE_OREXPR_OR(reduction);
break;
case RuleConstants.RULE_OREXPR :
////<OrExpr> ::= <AndExpr>
result = _parserRule.CreateRULE_OREXPR(reduction);
break;
case RuleConstants.RULE_ANDEXPR_AND :
////<AndExpr> ::= <AndExpr> AND <UnaryExpr>
result = _parserRule.CreateRULE_ANDEXPR_AND(reduction);
break;
case RuleConstants.RULE_ANDEXPR :
////<AndExpr> ::= <UnaryExpr>
result = _parserRule.CreateRULE_ANDEXPR(reduction);
break;
case RuleConstants.RULE_UNARYEXPR_NOT :
////<UnaryExpr> ::= NOT <CompareExpr>
result = _parserRule.CreateRULE_UNARYEXPR_NOT(reduction);
break;
case RuleConstants.RULE_UNARYEXPR :
////<UnaryExpr> ::= <CompareExpr>
result = _parserRule.CreateRULE_UNARYEXPR(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_EQ :
////<CompareExpr> ::= <Atrrib> '=' <Value>
result = _parserRule.CreateRULE_COMPAREEXPR_EQ(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_EXCLAMEQ :
////<CompareExpr> ::= <Atrrib> '!=' <Value>
result = _parserRule.CreateRULE_COMPAREEXPR_EXCLAMEQ(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_EQEQ :
////<CompareExpr> ::= <Atrrib> '==' <Value>
result = _parserRule.CreateRULE_COMPAREEXPR_EQEQ(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_LTGT :
////<CompareExpr> ::= <Atrrib> '<>' <Value>
result = _parserRule.CreateRULE_COMPAREEXPR_LTGT(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_LT :
////<CompareExpr> ::= <Atrrib> '<' <Value>
result = _parserRule.CreateRULE_COMPAREEXPR_LT(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_GT :
////<CompareExpr> ::= <Atrrib> '>' <Value>
result = _parserRule.CreateRULE_COMPAREEXPR_GT(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_LTEQ :
////<CompareExpr> ::= <Atrrib> '<=' <Value>
result = _parserRule.CreateRULE_COMPAREEXPR_LTEQ(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_GTEQ :
////<CompareExpr> ::= <Atrrib> '>=' <Value>
result = _parserRule.CreateRULE_COMPAREEXPR_GTEQ(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_LIKE_STRINGLITERAL :
////<CompareExpr> ::= <Atrrib> LIKE StringLiteral
result = _parserRule.CreateRULE_COMPAREEXPR_LIKE_STRINGLITERAL(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_LIKE_QUESTION :
////<CompareExpr> ::= <Atrrib> LIKE '?'
result = _parserRule.CreateRULE_COMPAREEXPR_LIKE_QUESTION(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_NOT_LIKE_STRINGLITERAL :
////<CompareExpr> ::= <Atrrib> NOT LIKE StringLiteral
result = _parserRule.CreateRULE_COMPAREEXPR_NOT_LIKE_STRINGLITERAL(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_NOT_LIKE_QUESTION :
////<CompareExpr> ::= <Atrrib> NOT LIKE '?'
result = _parserRule.CreateRULE_COMPAREEXPR_NOT_LIKE_QUESTION(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_IN :
////<CompareExpr> ::= <Atrrib> IN <InList>
result = _parserRule.CreateRULE_COMPAREEXPR_IN(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_NOT_IN :
////<CompareExpr> ::= <Atrrib> NOT IN <InList>
result = _parserRule.CreateRULE_COMPAREEXPR_NOT_IN(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_IS_NULL :
////<CompareExpr> ::= <Atrrib> IS NULL
result = _parserRule.CreateRULE_COMPAREEXPR_IS_NULL(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_IS_NOT_NULL :
////<CompareExpr> ::= <Atrrib> IS NOT NULL
result = _parserRule.CreateRULE_COMPAREEXPR_IS_NOT_NULL(reduction);
break;
case RuleConstants.RULE_COMPAREEXPR_LPARAN_RPARAN :
////<CompareExpr> ::= '(' <Expression> ')'
result = _parserRule.CreateRULE_COMPAREEXPR_LPARAN_RPARAN(reduction);
break;
case RuleConstants.RULE_ATRRIB :
////<Atrrib> ::= <ObjectValue>
result = _parserRule.CreateRULE_ATRRIB(reduction);
break;
case RuleConstants.RULE_VALUE_MINUS :
////<Value> ::= '-' <NumLiteral>
result = _parserRule.CreateRULE_VALUE_MINUS(reduction);
break;
case RuleConstants.RULE_VALUE :
////<Value> ::= <NumLiteral>
result = _parserRule.CreateRULE_VALUE(reduction);
break;
case RuleConstants.RULE_VALUE2 :
////<Value> ::= <StrLiteral>
result = _parserRule.CreateRULE_VALUE2(reduction);
break;
case RuleConstants.RULE_VALUE_TRUE :
////<Value> ::= true
result = _parserRule.CreateRULE_VALUE_TRUE(reduction);
break;
case RuleConstants.RULE_VALUE_FALSE :
////<Value> ::= false
result = _parserRule.CreateRULE_VALUE_FALSE(reduction);
break;
case RuleConstants.RULE_VALUE3 :
////<Value> ::= <Date>
result = _parserRule.CreateRULE_VALUE3(reduction);
break;
case RuleConstants.RULE_DATE_DATETIME_DOT_NOW :
////<Date> ::= DateTime '.' now
result = _parserRule.CreateRULE_DATE_DATETIME_DOT_NOW(reduction);
break;
case RuleConstants.RULE_DATE_DATETIME_LPARAN_STRINGLITERAL_RPARAN :
////<Date> ::= DateTime '(' StringLiteral ')'
result = _parserRule.CreateRULE_DATE_DATETIME_LPARAN_STRINGLITERAL_RPARAN(reduction);
break;
case RuleConstants.RULE_STRLITERAL_STRINGLITERAL :
////<StrLiteral> ::= StringLiteral
result = _parserRule.CreateRULE_STRLITERAL_STRINGLITERAL(reduction);
break;
case RuleConstants.RULE_STRLITERAL_NULL :
////<StrLiteral> ::= NULL
result = _parserRule.CreateRULE_STRLITERAL_NULL(reduction);
break;
case RuleConstants.RULE_STRLITERAL_QUESTION :
////<StrLiteral> ::= '?'
result = _parserRule.CreateRULE_STRLITERAL_QUESTION(reduction);
break;
case RuleConstants.RULE_NUMLITERAL_INTEGERLITERAL :
////<NumLiteral> ::= IntegerLiteral
result = _parserRule.CreateRULE_NUMLITERAL_INTEGERLITERAL(reduction);
break;
case RuleConstants.RULE_NUMLITERAL_REALLITERAL :
////<NumLiteral> ::= RealLiteral
result = _parserRule.CreateRULE_NUMLITERAL_REALLITERAL(reduction);
break;
case RuleConstants.RULE_OBJECTTYPE_TIMES :
////<ObjectType> ::= '*'
result = _parserRule.CreateRULE_OBJECTTYPE_TIMES(reduction);
break;
case RuleConstants.RULE_OBJECTTYPE_DOLLARTEXTDOLLAR :
////<ObjectType> ::= '$Text$'
result = _parserRule.CreateRULE_OBJECTTYPE_DOLLARTEXTDOLLAR(reduction);
break;
case RuleConstants.RULE_OBJECTTYPE :
////<ObjectType> ::= <Property>
result = _parserRule.CreateRULE_OBJECTTYPE(reduction);
break;
case RuleConstants.RULE_OBJECTATTRIBUTE_IDENTIFIER :
////<ObjectAttribute> ::= Identifier
result = _parserRule.CreateRULE_OBJECTATTRIBUTE_IDENTIFIER(reduction);
break;
case RuleConstants.RULE_DELETEPARAMS_DOLLARTEXTDOLLAR :
////<DeleteParams> ::= '$Text$'
result = _parserRule.CreateRULE_DELETEPARAMS_DOLLARTEXTDOLLAR(reduction);
break;
case RuleConstants.RULE_DELETEPARAMS :
////<DeleteParams> ::= <Property>
result = _parserRule.CreateRULE_DELETEPARAMS(reduction);
break;
case RuleConstants.RULE_PROPERTY_DOT_IDENTIFIER :
////<Property> ::= <Property> '.' Identifier
result = _parserRule.CreateRULE_PROPERTY_DOT_IDENTIFIER(reduction);
break;
case RuleConstants.RULE_PROPERTY_IDENTIFIER :
////<Property> ::= Identifier
result = _parserRule.CreateRULE_PROPERTY_IDENTIFIER(reduction);
break;
case RuleConstants.RULE_TYPEPLUSATTRIBUTE_DOT :
////<TypePlusAttribute> ::= <Property> '.' <ObjectAttribute>
result = _parserRule.CreateRULE_TYPEPLUSATTRIBUTE_DOT(reduction);
break;
case RuleConstants.RULE_AGGREGATEFUNCTION :
////<AggregateFunction> ::= <SumFunction>
result = _parserRule.CreateRULE_AGGREGATEFUNCTION(reduction);
break;
case RuleConstants.RULE_AGGREGATEFUNCTION2 :
////<AggregateFunction> ::= <CountFunction>
result = _parserRule.CreateRULE_AGGREGATEFUNCTION2(reduction);
break;
case RuleConstants.RULE_AGGREGATEFUNCTION3 :
////<AggregateFunction> ::= <MinFunction>
result = _parserRule.CreateRULE_AGGREGATEFUNCTION3(reduction);
break;
case RuleConstants.RULE_AGGREGATEFUNCTION4 :
////<AggregateFunction> ::= <MaxFunction>
result = _parserRule.CreateRULE_AGGREGATEFUNCTION4(reduction);
break;
case RuleConstants.RULE_AGGREGATEFUNCTION5 :
////<AggregateFunction> ::= <AverageFunction>
result = _parserRule.CreateRULE_AGGREGATEFUNCTION5(reduction);
break;
case RuleConstants.RULE_SUMFUNCTION_SUMLPARAN_RPARAN :
////<SumFunction> ::= 'SUM(' <TypePlusAttribute> ')'
result = _parserRule.CreateRULE_SUMFUNCTION_SUMLPARAN_RPARAN(reduction);
break;
case RuleConstants.RULE_COUNTFUNCTION_COUNTLPARAN_RPARAN :
////<CountFunction> ::= 'COUNT(' <Property> ')'
result = _parserRule.CreateRULE_COUNTFUNCTION_COUNTLPARAN_RPARAN(reduction);
break;
case RuleConstants.RULE_MINFUNCTION_MINLPARAN_RPARAN :
////<MinFunction> ::= 'MIN(' <TypePlusAttribute> ')'
result = _parserRule.CreateRULE_MINFUNCTION_MINLPARAN_RPARAN(reduction);
break;
case RuleConstants.RULE_MAXFUNCTION_MAXLPARAN_RPARAN :
////<MaxFunction> ::= 'MAX(' <TypePlusAttribute> ')'
result = _parserRule.CreateRULE_MAXFUNCTION_MAXLPARAN_RPARAN(reduction);
break;
case RuleConstants.RULE_AVERAGEFUNCTION_AVGLPARAN_RPARAN :
////<AverageFunction> ::= 'AVG(' <TypePlusAttribute> ')'
result = _parserRule.CreateRULE_AVERAGEFUNCTION_AVGLPARAN_RPARAN(reduction);
break;
case RuleConstants.RULE_OBJECTATTRIBUTE_KEYWORD_DOT_IDENTIFIER :
////<ObjectAttribute> ::= Keyword '.' Identifier
result = _parserRule.CreateRULE_OBJECTATTRIBUTE_KEYWORD_DOT_IDENTIFIER(reduction);
break;
case RuleConstants.RULE_OBJECTVALUE_KEYWORD_DOT_IDENTIFIER :
////<ObjectValue> ::= Keyword '.' Identifier
result = _parserRule.CreateRULE_OBJECTVALUE_KEYWORD_DOT_IDENTIFIER(reduction);
break;
case RuleConstants.RULE_INLIST_LPARAN_RPARAN :
////<InList> ::= '(' <ListType> ')'
result = _parserRule.CreateRULE_INLIST_LPARAN_RPARAN(reduction);
break;
case RuleConstants.RULE_LISTTYPE :
////<ListType> ::= <NumLiteralList>
result = _parserRule.CreateRULE_LISTTYPE(reduction);
break;
case RuleConstants.RULE_LISTTYPE2 :
////<ListType> ::= <StrLiteralList>
result = _parserRule.CreateRULE_LISTTYPE2(reduction);
break;
case RuleConstants.RULE_LISTTYPE3 :
////<ListType> ::= <DateList>
result = _parserRule.CreateRULE_LISTTYPE3(reduction);
break;
case RuleConstants.RULE_NUMLITERALLIST_COMMA :
////<NumLiteralList> ::= <NumLiteral> ',' <NumLiteralList>
result = _parserRule.CreateRULE_NUMLITERALLIST_COMMA(reduction);
break;
case RuleConstants.RULE_NUMLITERALLIST :
////<NumLiteralList> ::= <NumLiteral>
result = _parserRule.CreateRULE_NUMLITERALLIST(reduction);
break;
case RuleConstants.RULE_STRLITERALLIST_COMMA :
////<StrLiteralList> ::= <StrLiteral> ',' <StrLiteralList>
result = _parserRule.CreateRULE_STRLITERALLIST_COMMA(reduction);
break;
case RuleConstants.RULE_STRLITERALLIST :
////<StrLiteralList> ::= <StrLiteral>
result = _parserRule.CreateRULE_STRLITERALLIST(reduction);
break;
case RuleConstants.RULE_DATELIST_COMMA :
////<DateList> ::= <Date> ',' <DateList>
result = _parserRule.CreateRULE_DATELIST_COMMA(reduction);
break;
case RuleConstants.RULE_DATELIST :
////<DateList> ::= <Date>
result = _parserRule.CreateRULE_DATELIST(reduction);
break;
}
if (result == null)
result = reduction;
return result;
}
/// Implements <Identifier> ::= Keyword
public Reduction CreateRULE_IDENTIFIER_KEYWORD(Reduction reduction)
{
reduction.Tag = ((Token)reduction.GetToken(0)).Data;
if(NCacheLog.IsInfoEnabled) NCacheLog.Info("RULE_IDENTIFIER_KEYWORD -> " + reduction.Tag);
return null;
}
/// Implements <Property> ::= <Identifier>
public Reduction CreateRULE_PROPERTY(Reduction reduction)
{
if(NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_PROPERTY");
reduction.Tag = ((Token)reduction.GetToken(0)).Data;
return null;
}
/// Implements <AverageFunction> ::= 'AVG(' <TypePlusAttribute> ')'
public Reduction CreateRULE_AVERAGEFUNCTION_AVGLPARAN_RPARAN(Reduction reduction)
{
Reduction typePlusAttributeReduction = (Reduction)reduction.GetToken(1).Data;
string typeName = ((Reduction)typePlusAttributeReduction.GetToken(0).Data).Tag as string;
string memberName = ((Reduction)typePlusAttributeReduction.GetToken(2).Data).Tag as string;
Predicate childPredicate = new IsOfTypePredicate(typeName);
AggregateFunctionPredicate avgFunctionPredicate = ExpressionBuilder.CreateAverageFunctionPredicate(memberName) as AggregateFunctionPredicate;
avgFunctionPredicate.ChildPredicate = childPredicate;
reduction.Tag = avgFunctionPredicate;
return null;
}
/// Implements <NumLiteralList> ::= <NumLiteral>
public Reduction CreateRULE_NUMLITERALLIST(Reduction reduction)
{
if(NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_NUMLITERALLIST");
IsInListPredicate pred = new IsInListPredicate();
pred.Append(((Reduction)reduction.GetToken(0).Data).Tag);
reduction.Tag = pred;
return null;
}
/// <summary>Produces a reduction.</summary>
/// <remarks>Removes as many tokens as members in the rule and pushes a
/// non-terminal token.</remarks>
private ParseResult Reduce(Rule p_rule)
{
ParseResult result;
Token head;
if (m_trimReductions && p_rule.ContainsOneNonTerminal)
{
// The current rule only consists of a single nonterminal and can be trimmed from the
// parse tree. Usually we create a new Reduction, assign it to the Data property
// of Head and push it on the stack. However, in this case, the Data property of the
// Head will be assigned the Data property of the reduced token (i.e. the only one
// on the stack). In this case, to save code, the value popped of the stack is changed
// into the head.
head = m_tempStack.PopToken();
head.SetParent(p_rule.RuleNonTerminal);
result = ParseResult.ReduceEliminated;
}
else
{
Reduction reduction = new Reduction();
reduction.ParentRule = p_rule;
m_tempStack.PopTokensInto(reduction, p_rule.SymbolCount);
head = new Token();
head.Data = reduction;
head.SetParent(p_rule.RuleNonTerminal);
m_haveReduction = true;
result = ParseResult.ReduceNormal;
}
int index = m_tempStack.PeekToken().State;
LRAction action = m_LalrTables[index].GetActionForSymbol(p_rule.RuleNonTerminal.TableIndex);
if (action != null)
{
head.State = m_LalrState = action.Value;;
m_tempStack.PushToken(head);
}
else
throw new ParserException("Action for LALR state is null");
return result;
}
public Reduction CreateRULE_DELETEPARAMS(Reduction reduction)
{
return null;
}
/// <summary>
/// Adds the query to the PreparedQueryTable. This method also does the eviction
/// if PreparedQueryTable count is greater than eviction ratio.
/// This method is only called from GetPreparedReduction(string).
/// </summary>
/// <param name="query">The query to add in the table.</param>
/// <param name="currentReduction">The successful query result in the form of Reduction.</param>
private void AddPreparedReduction(string query, Reduction currentReduction)
{
_preparedQueryTable.Add(new QueryIdentifier(query), currentReduction);
if (_preparedQueryTable.Count > _preparedQueryTableSize)
{
ArrayList list = new ArrayList(_preparedQueryTable.Keys);
list.Sort();
int evictCount = (_preparedQueryTable.Count * _preparedQueryEvictionPercentage) / 100;
for (int i = 0; i < evictCount; i++)
_preparedQueryTable.Remove(list[i]);
}
}
/// Implements <CompareExpr> ::= <Value> NOT LIKE Question
public Reduction CreateRULE_COMPAREEXPR_NOT_LIKE_QUESTION(Reduction reduction)
{
return CreateRULE_COMPAREEXPR_NOT_LIKE_STRINGLITERAL(reduction);
}
