public static bool IsTargetObject( object @object, QueryExpression expression )
{
List<StatElement> suffixExpression = expression.SuffixExpression;
Stack<StatElement> resultStack = new Stack<StatElement> ();
StatElement result;
foreach ( StatElement element in suffixExpression ) {
switch ( element.Type ) {
case StatElementType.Constant: resultStack.Push ( element );
break;
case StatElementType.Operator: ProcessOperator ( ( Operator ) element.Value, resultStack, @object );
break;
case StatElementType.Variable: ProcessVariable ( @object, element, resultStack );
break;
default: throw new Exception ( "Invalid Statement" );
}
}
if ( resultStack.Count == 1 ) {
result = resultStack.Pop ();
if ( result.Type == StatElementType.Result || ( result.Type == StatElementType.Constant && result.Value is bool ) ) {
return ( bool ) result.Value;
} else {
throw new Exception ( "Invalid Statement" );
}
} else {
throw new Exception ( "Invalid Statement" );
}
}
private IList<object> GetObjectsFromGlobalCache(Type objType, QueryExpression expression, IList<Guid> ignoreIds)
{
List<object> result = new List<object>();
IEnumerable<GlobalCacheResult> globalCacheResults;
foreach (CacheEntity cacheEntity in _deleteList)
{
ignoreIds.Add(cacheEntity.ObjectId);
}
globalCacheResults = GlobalCache.Search(objType, expression, _persistenceContext, ignoreIds);
foreach (GlobalCacheResult globalCacheResult in globalCacheResults)
{
CacheEntity cacheEntity = new CacheEntity();
cacheEntity.ObjectId = globalCacheResult.ObjectId;
cacheEntity.Value = globalCacheResult.Value;
cacheEntity.Version = globalCacheResult.Version;
cacheEntity.ForeignKeys = globalCacheResult.ForeignKeys;
_objList.Add(cacheEntity.Value, cacheEntity);
if (!_objTable.ContainsKey(objType))
{
_objTable.Add(objType, new List<CacheEntity>());
}
_objTable[objType].Add(cacheEntity);
result.Add(cacheEntity.Value);
}
return result;
}
public IEnumerable<object> Search(Type objType, QueryExpression expression)
{
List<Guid> ignoreIds = new List<Guid>();
List<object> result = new List<object>();
IList<object> globalCacheObjects;
if (_objTable.ContainsKey(objType))
{
foreach (CacheEntity cacheEntity in _objTable[objType])
{
RefreshCacheEntity(cacheEntity);
if (ObjectCalculator.IsTargetObject(cacheEntity.Value, expression))
{
EntityMapping mapping = _persistenceContext.GetEntityMappingByClassName(objType.FullName);
result.Add((object)cacheEntity.Value);
ignoreIds.Add(cacheEntity.ObjectId);
}
}
}
globalCacheObjects = GetObjectsFromGlobalCache(objType, expression, ignoreIds);
foreach (object o in globalCacheObjects)
{
GetReferenceClasses(o);
result.Add(o);
}
return result;
}
public string GetSelectSQL( Type type, QueryExpression queryExpression )
{
List<StatElement> expression;
StringBuilder sql = new StringBuilder ( "select * from " );
EntityMapping mapping = _persistenceContext.GetEntityMappingByClassName ( type.FullName );
string tableName = mapping.TableName;
sql.Append ( tableName );
if ( queryExpression != null ) {
expression = queryExpression.NifixExpression;
} else {
expression = null;
}
if ( expression != null && expression.Count > 0 ) {
sql.Append ( " where (" );
foreach ( StatElement element in expression ) {
switch ( element.Type ) {
case StatElementType.Constant: sql.Append ( element.Value );
break;
case StatElementType.Operator: sql.Append ( GetSQLOperator ( ( Operator ) element.Value ) );
break;
case StatElementType.Variable: sql.Append ( element.Value );
break;
default: throw new Exception ( "Invalid Statement" );
}
}
}
sql.Append ( ")" );
return sql.ToString ();
}
