/// <summary>
/// Running and return temp cached result table for now.
/// To do: Just return result table name, invoke search later when user calls RunSearch()
/// </summary>
public string AddQueryItem(IQueryItem item)
{
if (_logger == null)
{
_logger = new SearchLogger();
}
_logger.AddQueryItemCalled();
_queryNodes.Add(item.NodeId, item);
LeafItem qi = item as LeafItem;
if (qi == null)
{
return(string.Empty);
}
MapTableFieldName(qi);
if (_results.Count < 1)
{
QueryResult result = new QueryResult();
result.SourceTable = qi.TableName;
_resultMap.Add(result.ResultTable, result);
_results.Add(result);
}
return(_results[0].ResultTable);
}
private static void SqlConvert(IQueryItem iqueryItem, StringBuilder sb, List <SqlParameter> _parameter)
{
var mssqlQueryBuilder = new MssqlQueryBuilder(typeMapper);
sb.Append(mssqlQueryBuilder.ProcessBEXP(iqueryItem as BEXP));
_parameter.AddRange(mssqlQueryBuilder._parameters.Select(queryParameter => new SqlParameter(queryParameter.Name, queryParameter.Value)));
}
/// <summary>
/// Add criteria query item handler
/// </summary>
/// <param name="originalQuery">Original query</param>
/// <param name="queryItem">Parameter query item</param>
/// <param name="parameterQueryOption">Parameter query option</param>
static IQueryItem AddCriteriaQueryItemHandler(DefaultQuery originalQuery, IQueryItem queryItem, QueryParameterOptions parameterQueryOption)
{
if (originalQuery == null || queryItem == null)
{
return(null);
}
Criteria criteria = queryItem as Criteria;
var queryValue = criteria.Value as IQuery;
originalQuery.SetHasConverter(originalQuery.HasConverter || criteria.Converter != null);
if (queryValue != null)
{
if (queryValue.GetEntityType() == null)
{
throw new EZNEWException("the IQuery object used for the subquery must set the property EntityType");
}
queryValue = HandleParameterQueryBeforeUse(queryValue, parameterQueryOption);
criteria.SetValue(queryValue);
originalQuery.subqueryCollection.Add(queryValue);
originalQuery.SetHasSubQuery(true);
originalQuery.SetHasJoin(originalQuery.HasJoin || queryValue.HasJoin);
originalQuery.SetHasRecurveCriteria(originalQuery.HasRecurveCriteria || queryValue.HasRecurveCriteria);
originalQuery.SetHasConverter(originalQuery.HasConverter || queryValue.HasConverter);
}
else
{
bool equalCriterial = false;
bool verifyValueNull = false;
CriteriaOperator verifyValueNullOperator = CriteriaOperator.IsNull;
switch (criteria.Operator)
{
case CriteriaOperator.Equal:
equalCriterial = true;
verifyValueNull = true;
break;
case CriteriaOperator.NotEqual:
verifyValueNull = true;
verifyValueNullOperator = CriteriaOperator.NotNull;
break;
case CriteriaOperator.In:
equalCriterial = true;
break;
}
if (criteria.GetCriteriaRealValue() == null && verifyValueNull)
{
equalCriterial = false;
criteria.Operator = verifyValueNullOperator;
}
if (equalCriterial)
{
originalQuery.equalCriteriaCollection.Add(criteria);
}
}
originalQuery.atomicConditionCount++;
originalQuery.allConditionFieldNameCollection.Add(criteria.Name);
return(criteria);
}
public AWSProductListDynamoDBController(IAWSProductListDynamoDbExamples dynamoDbExamples, IInsertItem insertItem, IQueryItem queryItem, IDeleteItem deleteItem, IUpdateItem updateItem)
{
_dynamoDbExamples = dynamoDbExamples;
_insertItem = insertItem;
_queryItem = queryItem;
_deleteItem = deleteItem;
_updateItem = updateItem;
}
/// <summary>
/// Clone a IQueryItem
/// </summary>
/// <param name="originalQueryItem">Originnal query item</param>
/// <returns></returns>
public static IQueryItem Clone(IQueryItem originalQueryItem)
{
if (originalQueryItem is Criteria criteria)
{
return(criteria.Clone());
}
if (originalQueryItem is IQuery query)
{
return(query.Clone());
}
return(null);
}
private string TraverseTree(IQueryItem item)
{
if (item is IConnectorItem)
{
IConnectorItem conn = item as IConnectorItem;
StringBuilder buffer = new StringBuilder();
string leftRequest = TraverseTree(_queryNodes[conn.LeftChild]);
string rightRequest = TraverseTree(_queryNodes[conn.RightChild]);
buffer.AppendFormat("({0} {1} {2})", leftRequest, conn.FilterType.ToString(), rightRequest);
return(buffer.ToString());
}
else
{
ILeafItem leaf = item as ILeafItem;
return(BuildSearchString(leaf));
}
}
/// <summary>
/// Add queryInfo query item handler
/// </summary>
/// <param name="originalQuery">Original query</param>
/// <param name="queryItem">Parameter query item</param>
/// <param name="parameterQueryOption">Parameter query option</param>
static IQueryItem AddQueryInfoQueryItemHandler(DefaultQuery originalQuery, IQueryItem queryItem, QueryParameterOption parameterQueryOption)
{
if (originalQuery == null || queryItem == null)
{
return(null);
}
DefaultQuery valueQuery = queryItem as DefaultQuery;
valueQuery = HandleParameterQueryBeforeUse(valueQuery, parameterQueryOption);
valueQuery.SetEntityType(originalQuery.entityType);
originalQuery.SetHasSubQuery(originalQuery.HasSubquery || valueQuery.HasSubquery);
originalQuery.SetHasJoin(originalQuery.HasJoin || valueQuery.HasJoin);
originalQuery.SetHasRecurveCriteria(originalQuery.HasRecurveCriteria || valueQuery.HasRecurveCriteria);
originalQuery.equalCriteriaCollection.AddRange(valueQuery.equalCriteriaCollection);
originalQuery.atomicConditionCount += valueQuery.AtomicConditionCount;
originalQuery.allConditionFieldNameCollection.AddRange(valueQuery.AllConditionFieldNames);
originalQuery.alreadySetGlobalCondition |= valueQuery.alreadySetGlobalCondition;
return(valueQuery);
}
/// <summary>
/// Generate expressionn
/// </summary>
/// <param name="parameter">Parameter expression</param>
/// <param name="queryItem">Query item</param>
/// <returns>Return query expression</returns>
Expression GenerateExpression(Expression parameter, IQueryItem queryItem)
{
if (queryItem is Criteria)
{
return(GenerateSingleExpression(parameter, queryItem as Criteria));
}
IQuery query = queryItem as IQuery;
if (query?.Criterias.IsNullOrEmpty() ?? true)
{
return(null);
}
var criteriasCount = query.Criterias.Count();
var firstCriteria = query.Criterias.First();
if (criteriasCount == 1 && firstCriteria.Item2 is Criteria)
{
return(GenerateSingleExpression(parameter, firstCriteria.Item2 as Criteria));
}
Expression conditionExpression = null;
foreach (var criteriaItem in query.Criterias)
{
var childExpression = GenerateExpression(parameter, criteriaItem.Item2);
if (conditionExpression == null)
{
conditionExpression = childExpression;
continue;
}
if (criteriaItem.Item1 == QueryOperator.AND)
{
conditionExpression = Expression.AndAlso(conditionExpression, childExpression);
}
else
{
conditionExpression = Expression.OrElse(conditionExpression, childExpression);
}
}
return(conditionExpression);
}
private string ProcessQueryItem(IQueryItem item)
{
if (item == null)
{
return("");
}
else if (item is BEXP)
{
return(ProcessBEXP(item as BEXP));
}
else if (item is TEXP)
{
return(ProcessTEXP(item as TEXP));
}
else if (item is FEXP)
{
return(ProcessFEXP(item as FEXP));
}
else if (item is NEXP)
{
return(ProcessNEXP(item as NEXP));
}
else if (item is COL)
{
return(ProcessCOL(item as COL));
}
else if (item is VAL)
{
return(ProcessVAL(item as VAL));
}
else if (item is ARR)
{
return(ProcessARR(item as ARR));
}
else if (item is IQueryOrderItem)
{
return(ProcessOrderItem(item as IQueryOrderItem));
}
return("");
}
/// <summary>
/// Add a IQueryItem
/// </summary>
/// <param name="queryOperator">Connect operator</param>
/// <param name="queryItem">query item</param>
/// <param name="queryOption">query parameter option</param>
public IQuery AddQueryItem(QueryOperator queryOperator, IQueryItem queryItem, QueryParameterOptions queryOption = null)
{
#region invoke handler
var queryItemTypeId = queryItem?.GetType().GUID ?? Guid.Empty;
Func <DefaultQuery, IQueryItem, QueryParameterOptions, IQueryItem> handler = null;
QueryManager.AddQueryItemHandlers?.TryGetValue(queryItemTypeId, out handler);
if (handler != null)
{
queryItem = handler(this, queryItem, queryOption);
}
#endregion
if (queryItem != null)
{
//clear data
queryExpressionCaches?.Clear();
criteriaCollection.Add(new Tuple <QueryOperator, IQueryItem>(queryOperator, queryItem));
}
return(this);
}
partial void ResetDirty_PreCondition(IQueryItem instance);
partial void ResetDirty_PostValidate(IQueryItem instance);
partial void Parent_SetCondition(ref IQueryItem instance, ref IQueryFolder setValue);
partial void OwnerDescriptor_SetCondition(ref IQueryItem instance, ref IIdentityDescriptor setValue);
partial void IsPersonal_SetCondition(ref IQueryItem instance, ref Boolean setValue);
/// <summary>
/// Adds the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <exception cref="DynCon.OSI.Core.Helpers.ToBeImplementedException"></exception>
void IQueryFolder.Add(IQueryItem item)
{
throw new ToBeImplementedException();
}
public UpdateItem(IQueryItem queryItem, IAmazonDynamoDB dynamoDbClient)
{
_queryItem = queryItem;
_dynamoDbClient = dynamoDbClient;
}
partial void Delete_PostValidate(IQueryItem instance);
partial void CanManagePermissions_SetCondition(ref IQueryItem instance, ref Boolean setValue);
private static IQueryItem WriteExpression(Expression e)
{
BinaryOperator binaryOperator;
if (binaryOperators.TryGetValue(e.NodeType, out binaryOperator))
{
IQueryItem queryItem1 = WriteExpression((e as BinaryExpression).Left);
IQueryItem queryItem2 = WriteExpression((e as BinaryExpression).Right);
if ((object)(queryItem1 as VAL) != null && (queryItem1 as VAL).Value == DBNull.Value)
{
if (binaryOperator == BinaryOperator.Equal)
{
return (IQueryItem) new BEXP()
{
Operand1 = queryItem2, Operator = BinaryOperator.IsNull
}
}
;
if (binaryOperator == BinaryOperator.NotEqual)
{
return (IQueryItem) new BEXP()
{
Operand1 = queryItem2, Operator = BinaryOperator.IsNotNull
}
}
;
}
if ((object)(queryItem2 as VAL) != null && (queryItem2 as VAL).Value == DBNull.Value)
{
if (binaryOperator == BinaryOperator.Equal)
{
return (IQueryItem) new BEXP()
{
Operand1 = queryItem1, Operator = BinaryOperator.IsNull
}
}
;
if (binaryOperator == BinaryOperator.NotEqual)
{
return (IQueryItem) new BEXP()
{
Operand1 = queryItem1, Operator = BinaryOperator.IsNotNull
}
}
;
}
return((IQueryItem) new BEXP()
{
Operand1 = queryItem1, Operand2 = queryItem2, Operator = binaryOperator
});
}
if (e.NodeType == ExpressionType.New)
{
object obj = Expression.Lambda(e).Compile().DynamicInvoke();
return((IQueryItem) new VAL()
{
Value = obj
});
}
if (e.NodeType == ExpressionType.Not)
{
IQueryItem queryItem = NewHelpers.WriteExpression((e as UnaryExpression).Operand);
return((IQueryItem) new BEXP()
{
Operand1 = queryItem, Operator = BinaryOperator.Not
});
}
TransformOperator transformOperator;
if (NewHelpers.transformOperators.TryGetValue(e.NodeType, out transformOperator))
{
IQueryItem queryItem1 = NewHelpers.WriteExpression((e as BinaryExpression).Left);
IQueryItem queryItem2 = NewHelpers.WriteExpression((e as BinaryExpression).Right);
return((IQueryItem) new TEXP()
{
Operand1 = queryItem1, Operand2 = queryItem2, Operator = transformOperator
});
}
if (e.NodeType == ExpressionType.Negate)
{
IQueryItem queryItem = NewHelpers.WriteExpression((e as BinaryExpression).Left);
return((IQueryItem) new TEXP()
{
Operand1 = queryItem, Operator = TransformOperator.Negate
});
}
if (e is MemberExpression)
{
MemberExpression exp = e as MemberExpression;
KeyValuePair <NewHelpers.FunctionProperty, QueryFunctions>[] array = NewHelpers.functionProperties.Where <KeyValuePair <NewHelpers.FunctionProperty, QueryFunctions> >((Func <KeyValuePair <NewHelpers.FunctionProperty, QueryFunctions>, bool>)(a =>
{
if (a.Key.FunctionName == exp.Member.Name.ToLower())
{
return(a.Key.ObjectType.IsAssignableFrom(exp.Expression.Type));
}
return(false);
})).ToArray <KeyValuePair <NewHelpers.FunctionProperty, QueryFunctions> >();
if ((uint)array.Length > 0U)
{
IQueryItem queryItem = NewHelpers.WriteExpression(exp.Expression);
return((IQueryItem) new FEXP()
{
Function = array[0].Value, Parameters = new IQueryValue[1] {
(IQueryValue)queryItem
}
});
}
if (exp.Expression is ParameterExpression || exp.Expression is MemberExpression && (exp.Expression as MemberExpression).Expression is ParameterExpression)
{
return((IQueryItem) new COL(exp.Member.Name));
}
object obj = Expression.Lambda((Expression)exp).Compile().DynamicInvoke();
if (obj == null)
{
return (IQueryItem) new VAL()
{
Value = (object)DBNull.Value
}
}
;
if (!obj.GetType().IsArray)
{
return (IQueryItem) new VAL()
{
Value = obj
}
}
;
return((IQueryItem) new ARR()
{
Values = (IQueryValue[])((Array)obj).Cast <object>().Select <object, VAL>((Func <object, VAL>)(a => new VAL()
{
Value = a
})).ToArray <VAL>()
});
}
if (e is UnaryExpression)
{
return(NewHelpers.WriteExpression((e as UnaryExpression).Operand));
}
if (e is ConstantExpression)
{
return (IQueryItem) new VAL()
{
Value = Expression.Lambda(e).Compile().DynamicInvoke()
}
}
;
if (!(e is MethodCallExpression))
{
return((IQueryItem)null);
}
MethodCallExpression methodCallExpression = (MethodCallExpression)e;
QueryFunctions queryFunctions;
if (NewHelpers.aggregteFunctions.TryGetValue(methodCallExpression.Method.Name.ToLower(CultureInfo.InvariantCulture), out queryFunctions) && methodCallExpression.Object is ParameterExpression)
{
List <IQueryItem> source = new List <IQueryItem>();
foreach (Expression expression in methodCallExpression.Arguments)
{
source.Add(NewHelpers.WriteExpression((expression as LambdaExpression).Body));
}
if (methodCallExpression.Method.Name.ToLower() == "count")
{
source.Add((IQueryItem)COL.ALL);
}
FEXP fexp = new FEXP();
fexp.Function = queryFunctions;
IQueryValue[] array = source.Where <IQueryItem>((Func <IQueryItem, bool>)(a => a is IQueryValue)).Cast <IQueryValue>().ToArray <IQueryValue>();
fexp.Parameters = array;
return((IQueryItem)fexp);
}
if (methodCallExpression.Method.Name.ToLower(CultureInfo.InvariantCulture) == "asc")
{
List <IQueryItem> queryItemList = new List <IQueryItem>();
foreach (Expression expression in methodCallExpression.Arguments)
{
queryItemList.Add(NewHelpers.WriteExpression((expression as LambdaExpression).Body));
}
return((IQueryItem) new ASC()
{
Value = (IQueryValue)queryItemList[0]
});
}
if (methodCallExpression.Method.Name.ToLower(CultureInfo.InvariantCulture) == "desc")
{
List <IQueryItem> queryItemList = new List <IQueryItem>();
foreach (Expression expression in methodCallExpression.Arguments)
{
queryItemList.Add(NewHelpers.WriteExpression((expression as LambdaExpression).Body));
}
return((IQueryItem) new DESC()
{
Value = (IQueryValue)queryItemList[0]
});
}
if (NewHelpers.staticFunctions.TryGetValue(methodCallExpression.Method.Name.ToLower(CultureInfo.InvariantCulture), out queryFunctions))
{
List <IQueryItem> source = new List <IQueryItem>();
foreach (Expression e1 in methodCallExpression.Arguments)
{
source.Add(NewHelpers.WriteExpression(e1));
}
FEXP fexp = new FEXP();
fexp.Function = queryFunctions;
IQueryValue[] array = source.Where <IQueryItem>((Func <IQueryItem, bool>)(a => a is IQueryValue)).Cast <IQueryValue>().ToArray <IQueryValue>();
fexp.Parameters = array;
return((IQueryItem)fexp);
}
if (NewHelpers.instanceFunctions.TryGetValue(methodCallExpression.Method.Name.ToLower(CultureInfo.InvariantCulture), out queryFunctions))
{
List <IQueryItem> source = new List <IQueryItem>();
source.Add(NewHelpers.WriteExpression(methodCallExpression.Object));
foreach (Expression e1 in methodCallExpression.Arguments)
{
source.Add(NewHelpers.WriteExpression(e1));
}
FEXP fexp = new FEXP();
fexp.Function = queryFunctions;
IQueryValue[] array = source.Where <IQueryItem>((Func <IQueryItem, bool>)(a => a is IQueryValue)).Cast <IQueryValue>().ToArray <IQueryValue>();
fexp.Parameters = array;
return((IQueryItem)fexp);
}
if (methodCallExpression.Method.Name.ToLower(CultureInfo.InvariantCulture) == "in")
{
IQueryItem queryItem1 = NewHelpers.WriteExpression(methodCallExpression.Arguments[0]);
IQueryItem queryItem2 = NewHelpers.WriteExpression(methodCallExpression.Arguments[1]);
return((IQueryItem) new BEXP()
{
Operand1 = queryItem1, Operand2 = queryItem2, Operator = BinaryOperator.In
});
}
if (((IEnumerable <string>) new string[3] {
"contains", "startswith", "endswith"
}).Contains <string>(methodCallExpression.Method.Name.ToLower(CultureInfo.InvariantCulture)))
{
string lower = methodCallExpression.Method.Name.ToLower(CultureInfo.InvariantCulture);
List <IQueryItem> queryItemList = new List <IQueryItem>();
queryItemList.Add(NewHelpers.WriteExpression(methodCallExpression.Object));
foreach (Expression e1 in methodCallExpression.Arguments)
{
queryItemList.Add(NewHelpers.WriteExpression(e1));
}
VAL val = (VAL)"%";
IQueryItem queryItem1 = queryItemList[1];
List <IQueryValue> queryValueList = new List <IQueryValue>();
if (lower == "contains" || lower == "endswith")
{
queryValueList.Add((IQueryValue)val);
}
queryValueList.Add((IQueryValue)queryItem1);
if (lower == "contains" || lower == "startswith")
{
queryValueList.Add((IQueryValue)val);
}
FEXP fexp = new FEXP();
fexp.Function = QueryFunctions.Concat;
IQueryValue[] array = queryValueList.ToArray();
fexp.Parameters = array;
IQueryItem queryItem2 = (IQueryItem)fexp;
BEXP bexp = new BEXP();
bexp.Operator = BinaryOperator.Like;
IQueryItem queryItem3 = queryItemList[0];
bexp.Operand1 = queryItem3;
IQueryItem queryItem4 = queryItem2;
bexp.Operand2 = queryItem4;
return((IQueryItem)bexp);
}
object obj1 = Expression.Lambda((Expression)methodCallExpression).Compile().DynamicInvoke();
if (obj1 == null)
{
return (IQueryItem) new VAL()
{
Value = (object)DBNull.Value
}
}
;
if (!obj1.GetType().IsArray)
{
return (IQueryItem) new VAL()
{
Value = obj1
}
}
;
return((IQueryItem) new ARR()
{
Values = (IQueryValue[])((Array)obj1).Cast <object>().Select <object, VAL>((Func <object, VAL>)(a => new VAL()
{
Value = a
})).ToArray <VAL>()
});
}
partial void QueryItem_SetCondition(ref IQueryFolderContentsChangedEventArgs instance, ref IQueryItem setValue);
/// <summary>
/// Determines whether [contains] [the specified item].
/// </summary>
/// <param name="item">The item.</param>
/// <returns>Boolean.</returns>
/// <exception cref="DynCon.OSI.Core.Helpers.ToBeImplementedException"></exception>
Boolean IQueryFolder.Contains(IQueryItem item)
{
throw new ToBeImplementedException();
}
partial void ResetInternal_PostValidate(IQueryItem instance);
partial void Delete_PreCondition(IQueryItem instance);
partial void ResetInternal_PreCondition(IQueryItem instance);
partial void IsDirty_SetCondition(ref IQueryItem instance, ref Boolean setValue);
partial void AccessControlList_SetCondition(ref IQueryItem instance, ref IAccessControlList setValue);
public void AddItem(IQueryItem item)
{
Items.Add(item);
}
