static Func <IDataReader, T> GetObjectReader2 <T>(DataConnection dataConnection, IDataReader dataReader, string sql)
{
var key = new QueryKey(typeof(T), dataConnection.ID, sql);
var func = CreateObjectReader <T>(dataConnection, dataReader, (type, idx, dataReaderExpr) =>
new ConvertFromDataReaderExpression(type, idx, dataReaderExpr, dataConnection).Reduce());
_objectReaders[key] = func;
return(func);
}
private static void AssertIsValidKey(QueryKey key, string expectedName = null)
{
Assert.NotNull(key);
Assert.NotNull(key.Key);
Assert.NotEmpty(key.Key);
if (expectedName != null)
{
Assert.Equal(expectedName, key.Name);
}
}
public static bool TryGetQueryValue(NameValueCollection queryCollection, QueryKey queryKey, out int value)
{
var key = queryCollection.AllKeys.FirstOrDefault(x => x.Equals(queryKey.ToString(), StringComparison.OrdinalIgnoreCase));
if (key != null)
{
return(int.TryParse(queryCollection[key], out value));
}
value = default(int);
return(false);
}
static Func <IDataReader, T> GetObjectReader <T>(DataConnection dataConnection, IDataReader dataReader, string sql)
{
var key = new QueryKey(typeof(T), dataConnection.ID, sql);
if (!_objectReaders.TryGetValue(key, out var func))
{
_objectReaders[key] = func = CreateObjectReader <T>(dataConnection, dataReader, (type, idx, dataReaderExpr) =>
new ConvertFromDataReaderExpression(type, idx, dataReaderExpr, dataConnection).Reduce(dataReader));
}
return((Func <IDataReader, T>)func);
}
private MemberExpression GetPropertyAccess(ParameterExpression arg)
{
string[] parts = QueryKey.Split('.');
MemberExpression property = Expression.Property(arg, parts[0]);
for (int i = 1; i < parts.Length; i++)
{
property = Expression.Property(property, parts[i]);
}
return(property);
}
public new IList Get(
QueryKey key,
QueryParameters queryParameters,
ICacheAssembler[] returnTypes,
ISet <string> spaces,
ISessionImplementor session)
{
return(base.Get(
key,
queryParameters,
returnTypes,
spaces,
session));
}
public new IList Get(
QueryKey key,
ICacheAssembler[] returnTypes,
bool isNaturalKeyLookup,
ISet <string> spaces,
ISessionImplementor session)
{
return(base.Get(
key,
returnTypes,
isNaturalKeyLookup,
spaces,
session));
}
public new Task <IList> GetAsync(
QueryKey key,
QueryParameters queryParameters,
ICacheAssembler[] returnTypes,
ISet <string> spaces,
ISessionImplementor session,
CancellationToken cancellationToken)
{
return(base.GetAsync(
key,
queryParameters,
returnTypes,
spaces,
session,
cancellationToken));
}
public DataTable GetDataTable(IDbDataAdapter adapter, string sql, IDbDataParameter[] paramters)
{
QueryKey key = new QueryKey(sql, new QueryParameters(paramters));
DataTable result = (DataTable)cache.Get(key);
if (result != null)
{
return(result);
}
DataTable dt = GetDataSet(adapter, sql, paramters).Tables[0];
cache.Put(key, dt, DateTime.Now.AddMinutes(1).Ticks);
return(dt);
}
public new Task <IList> GetAsync(
QueryKey key,
ICacheAssembler[] returnTypes,
bool isNaturalKeyLookup,
ISet <string> spaces,
ISessionImplementor session,
CancellationToken cancellationToken)
{
return(base.GetAsync(
key,
returnTypes,
isNaturalKeyLookup,
spaces,
session,
cancellationToken));
}
private async Task GetCachedResultsAsync(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var statisticsEnabled = Session.Factory.Statistics.IsStatisticsEnabled;
var queriesByCaches = GetQueriesByCaches(ci => ci.CanGetFromCache);
foreach (var queriesByCache in queriesByCaches)
{
var queryInfos = queriesByCache.ToArray();
var cache = queriesByCache.Key;
var keys = new QueryKey[queryInfos.Length];
var parameters = new QueryParameters[queryInfos.Length];
var returnTypes = new ICacheAssembler[queryInfos.Length][];
var spaces = new ISet <string> [queryInfos.Length];
for (var i = 0; i < queryInfos.Length; i++)
{
var queryInfo = queryInfos[i];
keys[i] = queryInfo.CacheKey;
parameters[i] = queryInfo.Parameters;
returnTypes[i] = queryInfo.Parameters.HasAutoDiscoverScalarTypes
? null
: queryInfo.CacheKey.ResultTransformer.GetCachedResultTypes(queryInfo.GetCacheTypes());
spaces[i] = queryInfo.QuerySpaces;
}
var results = await(cache.GetManyAsync(keys, parameters, returnTypes, spaces, Session, cancellationToken)).ConfigureAwait(false);
for (var i = 0; i < queryInfos.Length; i++)
{
var queryInfo = queryInfos[i];
queryInfo.SetCachedResult(results[i]);
if (statisticsEnabled)
{
var queryIdentifier = queryInfo.QueryIdentifier;
if (results[i] == null)
{
Session.Factory.StatisticsImplementor.QueryCacheMiss(queryIdentifier, cache.RegionName);
}
else
{
Session.Factory.StatisticsImplementor.QueryCacheHit(queryIdentifier, cache.RegionName);
}
}
}
}
}
private Expression <Func <T, bool> > CreatePredicateWithNullCheck <T>(Expression searchExpression, ParameterExpression arg, MemberExpression targetProperty)
{
string[] parts = QueryKey.Split('.');
Expression nullCheckExpression = null;
if (parts.Length > 1)
{
MemberExpression property = Expression.Property(arg, parts[0]);
nullCheckExpression = Expression.NotEqual(property, Expression.Constant(null));
for (int i = 1; i < parts.Length - 1; i++)
{
property = Expression.Property(property, parts[i]);
Expression innerNullCheckExpression = Expression.NotEqual(property, Expression.Constant(null));
nullCheckExpression = Expression.AndAlso(nullCheckExpression, innerNullCheckExpression);
}
}
if (!targetProperty.Type.IsValueType || (targetProperty.Type.IsGenericType && targetProperty.Type.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
var innerNullCheckExpression = Expression.NotEqual(targetProperty, Expression.Constant(null));
if (nullCheckExpression == null)
{
nullCheckExpression = innerNullCheckExpression;
}
else
{
nullCheckExpression = Expression.AndAlso(nullCheckExpression, innerNullCheckExpression);
}
}
if (nullCheckExpression == null || ValueFromQuery == null)
{
return(Expression.Lambda <Func <T, bool> >(searchExpression, arg));
}
else
{
var combinedExpression = Expression.AndAlso(nullCheckExpression, searchExpression);
var predicate = Expression.Lambda <Func <T, bool> >(combinedExpression, arg);
return(predicate);
}
}
public new async Task <bool> PutAsync(
QueryKey key,
QueryParameters queryParameters,
ICacheAssembler[] returnTypes,
IList result,
ISessionImplementor session,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (queryParameters.NaturalKeyLookup &&
result.Count == 0)
{
return(false);
}
var ts = session.Factory.Settings.CacheProvider.NextTimestamp();
if (Log.IsDebugEnabled())
{
Log.Debug(
"caching query results in region: '{0}'; {1}",
RegionName,
key);
}
var value = await GetCacheableResultAsync(
returnTypes,
session,
result,
ts,
cancellationToken)
.ConfigureAwait(false);
var queryDependencies =
NCacheProvider.GetQueryDependencyConfigs(_ncacheClient.RegionPrefix);
await _ncacheClient.PutAsync(
key,
value,
session,
queryDependencies,
cancellationToken)
.ConfigureAwait(false);
return(true);
}
private object InvokeFunction(string methodName, Query query, object[] args)
{
var key = new QueryKey(query.DeclaredFunctions);
using (_database.Scripts.GetScriptRunner(key, readOnly: true, patchRun: out var run))
using (var result = run.Run(_context as DocumentsOperationContext, methodName, args))
{
_includeDocumentsCommand?.AddRange(run.Includes);
if (result.IsNull)
{
return(null);
}
return(run.Translate(result, _context, QueryResultModifier.Instance));
}
}
public virtual DataSet GetDataSet(string sql, IDbDataParameter[] paramters = null)
{
QueryKey key = new QueryKey(sql, new QueryParameters(paramters));
DataSet result = (DataSet)cache.Get(key);
if (result != null)
{
return(result);
}
IDbDataAdapter adapter = CreateAdapter();
DataSet ds = GetDataSet(adapter, sql, paramters);
cache.Put(key, ds, DateTime.Now.AddMinutes(1).Ticks);
return(ds);
}
public void CanListQueryKeys()
{
Run(() =>
{
SearchManagementClient searchMgmt = GetSearchManagementClient();
var queryKeys =
searchMgmt.QueryKeys.ListBySearchService(Data.ResourceGroupName, Data.SearchServiceName);
Assert.NotNull(queryKeys);
QueryKey onlyKey = queryKeys.Single();
AssertIsValidKey(onlyKey);
AssertIsDefaultKey(onlyKey);
});
}
private void GetCachedResults()
{
var statisticsEnabled = Session.Factory.Statistics.IsStatisticsEnabled;
var queriesByCaches = GetQueriesByCaches(ci => ci.CanGetFromCache);
foreach (var queriesByCache in queriesByCaches)
{
var queryInfos = queriesByCache.ToArray();
var cache = queriesByCache.Key;
var keys = new QueryKey[queryInfos.Length];
var parameters = new QueryParameters[queryInfos.Length];
var returnTypes = new ICacheAssembler[queryInfos.Length][];
var spaces = new ISet <string> [queryInfos.Length];
for (var i = 0; i < queryInfos.Length; i++)
{
var queryInfo = queryInfos[i];
keys[i] = queryInfo.CacheKey;
parameters[i] = queryInfo.Parameters;
returnTypes[i] = queryInfo.Parameters.HasAutoDiscoverScalarTypes
? null
: queryInfo.CacheKey.ResultTransformer.GetCachedResultTypes(queryInfo.ResultTypes);
spaces[i] = queryInfo.QuerySpaces;
}
var results = cache.GetMany(keys, parameters, returnTypes, spaces, Session);
for (var i = 0; i < queryInfos.Length; i++)
{
queryInfos[i].SetCachedResult(results[i]);
if (statisticsEnabled)
{
var queryIdentifier = queryInfos[i].QueryIdentifier;
if (results[i] == null)
{
Session.Factory.StatisticsImplementor.QueryCacheMiss(queryIdentifier, cache.RegionName);
}
else
{
Session.Factory.StatisticsImplementor.QueryCacheHit(queryIdentifier, cache.RegionName);
}
}
}
}
}
public IEnumerable <T> FindAll <T>(IDbDataAdapter adapter, string sql, IDbDataParameter[] paramters)
{
QueryKey key = new QueryKey(sql, new QueryParameters(paramters));
IEnumerable <T> result = (IEnumerable <T>)cache.Get(key);
if (result != null)
{
return(result);
}
IModelBinder binder = ModelBinderFactory.Current.GetModelBinder();
IEnumerable <T> list = binder.BindModel <T>(GetDataTable(adapter, sql, paramters));
cache.Put(key, list, DateTime.Now.AddMinutes(1).Ticks);
return(list);
}
private bool Equals(QueryKey other)
{
if (_functions?.Count != other._functions?.Count)
{
return(false);
}
foreach (var function in _functions ?? Enumerable.Empty <KeyValuePair <StringSegment, (string FunctionText, Esprima.Ast.Program Program)> >())
{
if (other._functions != null && (other._functions.TryGetValue(function.Key, out var otherVal) == false ||
function.Value.FunctionText != otherVal.FunctionText))
{
return(false);
}
}
return(true);
}
private bool Equals(QueryKey other)
{
if (_functions.Count != other._functions.Count)
{
return(false);
}
foreach (var function in _functions)
{
if (other._functions.TryGetValue(function.Key, out var otherVal) == false ||
function.Value != otherVal)
{
return(false);
}
}
return(true);
}
private bool Equals(QueryKey other)
{
if (_functions?.Count != other._functions?.Count)
{
return(false);
}
foreach (var function in _functions ?? Enumerable.Empty <KeyValuePair <string, DeclaredFunction> >())
{
if (other._functions != null &&
(other._functions.TryGetValue(function.Key, out var otherVal) == false ||
function.Value.FunctionText != otherVal.FunctionText))
{
return(false);
}
}
return(true);
}
private async Task <IList> ListUsingQueryCacheAsync(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
IQueryCache queryCache = session.Factory.GetQueryCache(cacheRegion);
ISet <FilterKey> filterKeys = FilterKey.CreateFilterKeys(session.EnabledFilters);
ISet <string> querySpaces = new HashSet <string>();
List <IType[]> resultTypesList = new List <IType[]>(Translators.Count);
for (int i = 0; i < Translators.Count; i++)
{
ITranslator queryTranslator = Translators[i];
querySpaces.UnionWith(queryTranslator.QuerySpaces);
resultTypesList.Add(queryTranslator.ReturnTypes);
}
int[] firstRows = new int[Parameters.Count];
int[] maxRows = new int[Parameters.Count];
for (int i = 0; i < Parameters.Count; i++)
{
RowSelection rowSelection = Parameters[i].RowSelection;
firstRows[i] = rowSelection.FirstRow;
maxRows[i] = rowSelection.MaxRows;
}
MultipleQueriesCacheAssembler assembler = new MultipleQueriesCacheAssembler(resultTypesList);
QueryKey key = new QueryKey(session.Factory, SqlString, combinedParameters, filterKeys, null)
.SetFirstRows(firstRows)
.SetMaxRows(maxRows);
IList result = await(assembler.GetResultFromQueryCacheAsync(session, combinedParameters, querySpaces, queryCache, key, cancellationToken)).ConfigureAwait(false);
if (result == null)
{
log.Debug("Cache miss for multi query");
var list = await(DoListAsync(cancellationToken)).ConfigureAwait(false);
await(queryCache.PutAsync(key, new ICacheAssembler[] { assembler }, new object[] { list }, false, session, cancellationToken)).ConfigureAwait(false);
result = list;
}
return(GetResultList(result));
}
private IList ListUsingQueryCache()
{
IQueryCache queryCache = session.Factory.GetQueryCache(cacheRegion);
ISet <FilterKey> filterKeys = FilterKey.CreateFilterKeys(session.EnabledFilters, session.EntityMode);
ISet <string> querySpaces = new HashedSet <string>();
List <IType[]> resultTypesList = new List <IType[]>(Translators.Count);
for (int i = 0; i < Translators.Count; i++)
{
ITranslator queryTranslator = Translators[i];
querySpaces.AddAll(queryTranslator.QuerySpaces);
resultTypesList.Add(queryTranslator.ReturnTypes);
}
int[] firstRows = new int[Parameters.Count];
int[] maxRows = new int[Parameters.Count];
for (int i = 0; i < Parameters.Count; i++)
{
RowSelection rowSelection = Parameters[i].RowSelection;
firstRows[i] = rowSelection.FirstRow;
maxRows[i] = rowSelection.MaxRows;
}
MultipleQueriesCacheAssembler assembler = new MultipleQueriesCacheAssembler(resultTypesList);
QueryKey key = new QueryKey(session.Factory, SqlString, combinedParameters, filterKeys)
.SetFirstRows(firstRows)
.SetMaxRows(maxRows);
IList result = assembler.GetResultFromQueryCache(session, combinedParameters, querySpaces, queryCache, key);
if (result == null)
{
log.Debug("Cache miss for multi query");
var list = DoList();
queryCache.Put(key, new ICacheAssembler[] { assembler }, new object[] { list }, false, session);
result = list;
}
return(GetResultList(result));
}
private IList ListUsingQueryCache()
{
IQueryCache queryCache = session.Factory.GetQueryCache(cacheRegion);
ISet <FilterKey> filterKeys = FilterKey.CreateFilterKeys(session.EnabledFilters, session.EntityMode);
ISet <string> querySpaces = new HashSet <string>();
List <IType[]> resultTypesList = new List <IType[]>();
int[] maxRows = new int[loaders.Count];
int[] firstRows = new int[loaders.Count];
for (int i = 0; i < loaders.Count; i++)
{
querySpaces.UnionWith(loaders[i].QuerySpaces);
resultTypesList.Add(loaders[i].ResultTypes);
firstRows[i] = parameters[i].RowSelection.FirstRow;
maxRows[i] = parameters[i].RowSelection.MaxRows;
}
MultipleQueriesCacheAssembler assembler = new MultipleQueriesCacheAssembler(resultTypesList);
QueryParameters combinedParameters = CreateCombinedQueryParameters();
QueryKey key = new QueryKey(session.Factory, SqlString, combinedParameters, filterKeys, null)
.SetFirstRows(firstRows)
.SetMaxRows(maxRows);
IList result =
assembler.GetResultFromQueryCache(session,
combinedParameters,
querySpaces,
queryCache,
key);
if (result == null)
{
log.Debug("Cache miss for multi criteria query");
IList list = DoList();
queryCache.Put(key, new ICacheAssembler[] { assembler }, new object[] { list }, combinedParameters.NaturalKeyLookup, session);
result = list;
}
return(GetResultList(result));
}
/// <summary>
/// Builds query agrregate function.
/// </summary>
protected override void Build()
{
// Build expression.
string function = QueryFunction.ToString().ToUpper();
string expression = Expression.ToString();
string key = string.Empty;
if (QueryKey != QueryKey.All)
{
key = QueryKey.ToString().ToUpper();
}
// If normal template.
if (Expression != null && OverColumns == null)
{
if (QueryKey == QueryKey.All)
{
Text = string.Format(m_normalTemplate, function, expression);
}
else if (QueryKey != QueryKey.All)
{
Text = string.Format(m_normalTemplateKey, function, key, expression);
}
}
// If over template.
else if (OverColumns != null && PartitionColumns == null)
{
}
// If partition template.
else if (PartitionColumns != null)
{
}
// Column name.
//string columnName = ColumnName.TrimComma();
// Generate aggregate string.
//Text = string.Format(m_normalTemplate, queryFunction, queryKey, columnName);
}
public void ToStringWithMoreFilters()
{
string filterName = "DescriptionLike";
var f = new FilterImpl(sessions.GetFilterDefinition(filterName));
f.SetParameter("pLike", "so%");
var fk = new FilterKey(filterName, f.Parameters, f.FilterDefinition.ParameterTypes, EntityMode.Poco);
filterName = "DescriptionEqualAndValueGT";
var fv = new FilterImpl(sessions.GetFilterDefinition(filterName));
fv.SetParameter("pDesc", "something").SetParameter("pValue", 10);
var fvk = new FilterKey(filterName, f.Parameters, f.FilterDefinition.ParameterTypes, EntityMode.Poco);
ISet <FilterKey> fks = new HashedSet <FilterKey> {
fk, fvk
};
var qk = new QueryKey(sessions, SqlAll, new QueryParameters(), (ISet)fks);
Assert.That(qk.ToString(), Is.StringContaining(string.Format("filters: ['{0}', '{1}']", fk, fvk)));
}
public void ToStringWithMoreFilters()
{
string filterName = "DescriptionLike";
var f = new FilterImpl(Sfi.GetFilterDefinition(filterName));
f.SetParameter("pLike", "so%");
var fk = new FilterKey(filterName, f.Parameters, f.FilterDefinition.ParameterTypes);
filterName = "DescriptionEqualAndValueGT";
var fv = new FilterImpl(Sfi.GetFilterDefinition(filterName));
fv.SetParameter("pDesc", "something").SetParameter("pValue", 10);
var fvk = new FilterKey(filterName, f.Parameters, f.FilterDefinition.ParameterTypes);
ISet <FilterKey> fks = new HashSet <FilterKey> {
fk, fvk
};
var qk = new QueryKey(Sfi, SqlAll, new QueryParameters(), fks, null);
Assert.That(qk.ToString(), Does.Contain(string.Format("filters: ['{0}', '{1}']", fk, fvk)));
}
private async Task PutCacheableResultsAsync(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var statisticsEnabled = Session.Factory.Statistics.IsStatisticsEnabled;
var queriesByCaches = GetQueriesByCaches(ci => ci.ResultToCache != null);
foreach (var queriesByCache in queriesByCaches)
{
var queryInfos = queriesByCache.ToArray();
var cache = queriesByCache.Key;
var keys = new QueryKey[queryInfos.Length];
var parameters = new QueryParameters[queryInfos.Length];
var returnTypes = new ICacheAssembler[queryInfos.Length][];
var results = new IList[queryInfos.Length];
for (var i = 0; i < queryInfos.Length; i++)
{
var queryInfo = queryInfos[i];
keys[i] = queryInfo.CacheKey;
parameters[i] = queryInfo.Parameters;
returnTypes[i] = queryInfo.CacheKey.ResultTransformer.GetCachedResultTypes(queryInfo.GetCacheTypes());
results[i] = queryInfo.ResultToCache;
}
var putted = await(cache.PutManyAsync(keys, parameters, returnTypes, results, Session, cancellationToken)).ConfigureAwait(false);
if (!statisticsEnabled)
{
continue;
}
for (var i = 0; i < queryInfos.Length; i++)
{
if (putted[i])
{
Session.Factory.StatisticsImplementor.QueryCachePut(
queryInfos[i].QueryIdentifier, cache.RegionName);
}
}
}
}
private void PutCacheableResults()
{
var statisticsEnabled = Session.Factory.Statistics.IsStatisticsEnabled;
var queriesByCaches = GetQueriesByCaches(ci => ci.ResultToCache != null);
foreach (var queriesByCache in queriesByCaches)
{
var queryInfos = queriesByCache.ToArray();
var cache = queriesByCache.Key;
var keys = new QueryKey[queryInfos.Length];
var parameters = new QueryParameters[queryInfos.Length];
var returnTypes = new ICacheAssembler[queryInfos.Length][];
var results = new IList[queryInfos.Length];
for (var i = 0; i < queryInfos.Length; i++)
{
var queryInfo = queryInfos[i];
keys[i] = queryInfo.CacheKey;
parameters[i] = queryInfo.Parameters;
returnTypes[i] = queryInfo.CacheKey.ResultTransformer.GetCachedResultTypes(queryInfo.GetCacheTypes());
results[i] = queryInfo.ResultToCache;
}
var putted = cache.PutMany(keys, parameters, returnTypes, results, Session);
if (!statisticsEnabled)
{
continue;
}
for (var i = 0; i < queryInfos.Length; i++)
{
if (putted[i])
{
Session.Factory.StatisticsImplementor.QueryCachePut(
queryInfos[i].QueryIdentifier, cache.RegionName);
}
}
}
}
public new bool Put(
QueryKey key,
QueryParameters queryParameters,
ICacheAssembler[] returnTypes,
IList result,
ISessionImplementor session)
{
if (queryParameters.NaturalKeyLookup &&
result.Count == 0)
{
return(false);
}
var ts = session.Factory.Settings.CacheProvider.NextTimestamp();
if (Log.IsDebugEnabled())
{
Log.Debug(
"caching query results in region: '{0}'; {1}",
RegionName,
key);
}
var queryDependencies =
NCacheProvider.GetQueryDependencyConfigs(_ncacheClient.RegionPrefix);
_ncacheClient.Put(
key,
GetCacheableResult(
returnTypes,
session,
result,
ts),
session,
queryDependencies);
return(true);
}
