public ManagementObjectCollection GetObjectCollection(string queryString, bool allowQueryCaching)
{
ManagementObjectCollection result = null;
if (allowQueryCaching)
{
QueryCache.TryGetValue(queryString, out result);
}
if (result == null)
{
result = GetManagementObjectCollection(queryString);
if (allowQueryCaching)
{
if (QueryCache.ContainsKey(queryString))
{
QueryCache[queryString] = result;
}
else
{
QueryCache.Add(queryString, result);
}
}
}
return(result);
}
private static string BuildUpdateQuery(IDbConnection connection, Type type)
{
var cacheKey = new QueryCacheKey(QueryCacheType.Update, connection, type);
if (!QueryCache.TryGetValue(cacheKey, out var sql))
{
var tableName = Resolvers.Table(type, connection);
var keyProperties = Resolvers.KeyProperties(type);
var builder = GetSqlBuilder(connection);
// Use all properties which are settable.
var typeProperties = Resolvers.Properties(type)
.Except(keyProperties)
.Where(p => p.GetSetMethod() != null)
.ToArray();
var columnNames = typeProperties.Select(p => $"{Resolvers.Column(p, connection)} = {builder.PrefixParameter(p.Name)}").ToArray();
var keyPropertyWhereClauses = keyProperties.Select(p => $"{Resolvers.Column(p, connection)} = {builder.PrefixParameter(p.Name)}");
sql = $"update {tableName} set {string.Join(", ", columnNames)} where {string.Join(" and ", keyPropertyWhereClauses)}";
QueryCache.TryAdd(cacheKey, sql);
}
return(sql);
}
internal static string BuildUpdateQuery(ISqlBuilder sqlBuilder, Type type)
{
var cacheKey = new QueryCacheKey(QueryCacheType.Update, sqlBuilder, type);
if (!QueryCache.TryGetValue(cacheKey, out var sql))
{
var tableName = Resolvers.Table(type, sqlBuilder);
// Use all non-key and non-generated properties for updates
var keyProperties = Resolvers.KeyProperties(type);
var typeProperties = Resolvers.Properties(type)
.Where(x => !x.IsGenerated)
.Select(x => x.Property)
.Except(keyProperties.Where(p => p.IsGenerated).Select(p => p.Property));
var columnNames = typeProperties.Select(p => $"{Resolvers.Column(p, sqlBuilder)} = {sqlBuilder.PrefixParameter(p.Name)}").ToArray();
var whereClauses = keyProperties.Select(p => $"{Resolvers.Column(p.Property, sqlBuilder)} = {sqlBuilder.PrefixParameter(p.Property.Name)}");
sql = $"update {tableName} set {string.Join(", ", columnNames)} where {string.Join(" and ", whereClauses)}";
if (sql.IndexOf("(True") != -1)
{
sql = sql.Replace("(True", "(1=1");
}
QueryCache.TryAdd(cacheKey, sql);
}
return(sql);
}
public async Task RegisterCqrs_WithConfigurationBuilder()
{
var queryCache = new QueryCache(new SystemClock());
var container = new Container();
container.RegisterCqrs(cqrs =>
{
cqrs
.AllowMultipleCommandDispatch()
.DisallowVoidCommandDispatch()
.EnableCaching(caching =>
{
caching
.SetDefaultLifetime(TimeSpan.FromMinutes(2))
.SetDefaultPriority(Priority.High)
.SetAdapter(
read: (query) => queryCache.TryRead(query),
write: (query, result, lifetime, priority) => queryCache.Write(query, result, lifetime));
caching
.Cache <TestQuery>(5.Minutes())
.Cache <RandomGuidQuery>(15.Seconds(), Priority.Low)
.Cache <CountingTestQuery>(Priority.Normal);
});
});
container.RegisterQueryHandler <RandomGuidQueryHandler>();
var dispatcher = container.GetInstance <IDispatcher>();
var guid1 = await dispatcher.QueryAsync(new RandomGuidQuery());
var guid2 = await dispatcher.QueryAsync(new RandomGuidQuery());
Assert.Equal(guid1, guid2);
}
public void QueryCacheTest()
{
DaoRepository daoRepo;
CachingRepository cachingRepo;
GetRepos(nameof(QueryCacheTest), out daoRepo, out cachingRepo);
string name = 8.RandomLetters();
TestMonkey data = new TestMonkey {
Name = name
};
daoRepo.Save(data);
QueryCache cache = new QueryCache();
bool reloaded = false;
cache.Reloaded += (o, c) => reloaded = true;
IEnumerable <object> results = cache.Results(typeof(TestMonkey), daoRepo, Filter.Where("Name") == name);
Expect.IsTrue(reloaded);
reloaded = false;
results = cache.Results(typeof(TestMonkey), daoRepo, Filter.Where("Name") == name);
Expect.IsFalse(reloaded);
Expect.AreEqual(1, results.Count());
}
public async Task RegisterHandlers()
{
var queryCache = new QueryCache(new SystemClock());
var configuration = new Configuration(
allowMultipleCommandDispatch: true,
allowVoidCommandDispatch: false,
cachingConfiguration: new CachingConfiguration(
defaultLifetime: TimeSpan.FromMinutes(1),
defaultPriority: Priority.Normal,
read: query => queryCache.TryRead(query),
write: (query, result, lifetime, priority) => queryCache.Write(query, result, lifetime),
queryCachingConfigurations: new Dictionary <Type, IQueryCachingConfiguration>()
{
{ typeof(RandomGuidQuery), new QueryCachingConfiguration(TimeSpan.FromMinutes(1)) }
}));
var container = new Container();
container.RegisterCqrs(configuration);
container.RegisterHandlers(GetType().GetTypeInfo().Assembly);
container.Verify();
var dispatcher = container.GetInstance <IDispatcher>();
var guid1 = await dispatcher.QueryAsync(new RandomGuidQuery());
var guid2 = await dispatcher.QueryAsync(new RandomGuidQuery());
Assert.Equal(guid1, guid2);
}
private static string BuildInsertQuery(IDbConnection connection, Type type)
{
var sqlBuilder = GetSqlBuilder(connection);
var cacheKey = new QueryCacheKey(QueryCacheType.Insert, sqlBuilder, type);
if (!QueryCache.TryGetValue(cacheKey, out var sql))
{
var tableName = Resolvers.Table(type, connection);
// Use all non-key and non-generated properties for inserts
var keyProperties = Resolvers.KeyProperties(type);
var typeProperties = Resolvers.Properties(type)
.Where(x => !x.IsGenerated)
.Select(x => x.Property)
.Except(keyProperties.Where(p => p.IsGenerated).Select(p => p.Property));
var columnNames = typeProperties.Select(p => Resolvers.Column(p, sqlBuilder)).ToArray();
var paramNames = typeProperties.Select(p => "@" + p.Name).ToArray();
sql = sqlBuilder.BuildInsert(type, tableName, columnNames, paramNames);
QueryCache.TryAdd(cacheKey, sql);
}
return(sql);
}
protected void LimpiarCache(Object sender, EventArgs e)
{
QueryCache.removeQuery(Request.QueryString["params"]);
tbWord.Text = "";
BindDatas();
}
private QueryCacheEntry GetFromCache(QueryQueueEntry key)
{
lock (QueryCacheLock)
{
return(QueryCache.Get(key));
}
}
private void ExecuteQuery(string query)
{
QueryCache <IDqlObject> _reducedQueryCache = new QueryCache <IDqlObject>();
IDqlObject parsedObject = _reducedQueryCache.GetParsedQuery(query);
if (parsedObject is SelectObject)
{
if (_databaseContext)
{
Execute(query, QueryType.Reader);
}
else
{
throw new Exception("For Execution of Data Query you must be in context of database.");
}
}
else if (parsedObject is InsertObject || parsedObject is DeleteObject ||
parsedObject is UpdateObject)
{
if (_databaseContext)
{
Execute(query, QueryType.NonQuery);
}
else
{
throw new Exception("For Execution of Data Query you must be in context of database.");
}
}
else
{
Execute(query, QueryType.NonDataQuery);
}
}
public void TestDeleteOldQueries()
{
var user = 1;
var queries = new List <string>()
{
"text:a", "text:b", "text:c", "text:d"
};
var results = new List <string>()
{
"1", "2"
};
var queryCache = new QueryCache()
{
LIMIT = 3, VALID_TIME_SECONDS = 5
};
foreach (var query in queries)
{
queryCache.Add(user, query, results);
Thread.Sleep(500);
}
Assert.IsNull(queryCache.SearchInCache(user, "text:a"));
var res = queryCache.SearchInCache(user, "text:b");
Assert.IsNotNull(res);
Assert.AreEqual(results, res);
}
private static string BuildInsertQuery(IDbConnection connection, Type type)
{
var sqlBuilder = GetSqlBuilder(connection);
var cacheKey = new QueryCacheKey(QueryCacheType.Insert, sqlBuilder, type);
if (!QueryCache.TryGetValue(cacheKey, out var sql))
{
var tableName = Resolvers.Table(type, connection);
var keyProperties = Resolvers.KeyProperties(type);
var typeProperties = new List <PropertyInfo>();
foreach (var typeProperty in Resolvers.Properties(type))
{
if (keyProperties.Any(p => p.IsGenerated && p.Property == typeProperty))
{
// Skip key properties marked as database generated
continue;
}
if (typeProperty.GetSetMethod() != null)
{
typeProperties.Add(typeProperty);
}
}
var columnNames = typeProperties.Select(p => Resolvers.Column(p, sqlBuilder)).ToArray();
var paramNames = typeProperties.Select(p => "@" + p.Name).ToArray();
sql = sqlBuilder.BuildInsert(type, tableName, columnNames, paramNames);
QueryCache.TryAdd(cacheKey, sql);
}
return(sql);
}
public DisplayNameHandler(ILogger <DisplayNameHandler <TFullDisplayNameType> > _Logger, ISqlDataAccess _db, ILogger <QueryCache <string, dynamic> > cacheLogger, IFriendHandler friendHandler)
{
logger = _Logger;
db = _db;
this.friendHandler = friendHandler;
db.ConnectionStringName = ConnectionStringName;
Cache = new(cacheLogger);
}
public QueryCache Instance()
{
if (_instance == null)
{
_instance = new QueryCache();
}
return _instance
}
public CustomVerificationStatusRepository(
ICosmos db,
ILogger <CustomVerificationStatusRepository> logger)
{
_db = db;
_logger = logger;
GetAsyncCache = new QueryCache <CustomVerificationStatusModel[]>(Constants.CacheTimeout);
}
public CosmosTemporaryExposureKeyExportRepository(
ICosmos db,
ISequenceRepository sequence,
ILogger <CosmosTemporaryExposureKeyExportRepository> logger)
{
_db = db;
_logger = logger;
GetKeysAsyncCache = new QueryCache <TemporaryExposureKeyExportModel[]>(Constants.CacheTimeout);
}
//Buscar Click
protected void Search(Object Sender, EventArgs E)
{
if (tbWord.Text != "")
{
string sql = "";
if (Request.QueryString["params"].Contains("**"))
{
string opcion = Request.QueryString["params"].Replace("**", "");
sql = DB.SQLConsultaGlobal.Buscar(opcion);
}
else
{
sql = Request.QueryString["params"].Replace("%20", " ");
}
string column = ddlCols.SelectedItem.Text;
string content = tbWord.Text;
dgTable.CurrentPageIndex = 0;
ds = QueryCache.getResult(sql);
DataTable table = ds.Tables[0];
IEnumerable <DataRow> enumRows;
try
{
enumRows = table
.Select(String.Format("{0} LIKE '{1}'", column, content), column)
.AsEnumerable();
}
catch (Exception err)
{
enumRows = table
.Select(String.Format("{0} = {1}", column, content), column)
.AsEnumerable();
}
//IEnumerable<DataRow> enumRows = table
// .Select(String.Format("{0} LIKE '{1}'", column, content), column)
// .AsEnumerable();
if (enumRows.Count <DataRow>() == 0)
{
table = table.Clone();
table.Clear();
}
else
{
table = enumRows
.CopyToDataTable <DataRow>();
}
dgTable.DataSource = table;
dgTable.DataBind();
}
}
//private Dictionary<string, string> _extendDatabaseConnection = null;
public DBInfo(string dbName, string connectionString,
string dbType
)
{
_dbType = dbType;
_connectionString = connectionString;
_dbName = dbName;
_cache = new QueryCache(this);
InitAdapters();
}
public IEnumerable <T> Read <T>()
{
ISchema schema = this.Store.GetSchema(typeof(IList <T>));
EnumerateFactory <T> reader = QueryCache.GetEnumerateFactory <T>(schema, this.syncReader);
while (this.syncReader.Read())
{
yield return(reader(this.syncReader));
}
}
public FriendHandler(ISqlDataAccess db, ILogger <FriendHandler <TFriendModelType> > _logger, ILogger <QueryCache <TFriendModelType, dynamic> > cacheLogger, IFriendListHandler _friendListHandler, IAvatarHandler _avatarHandler)
{
this.db = db;
logger = _logger;
friendListHandler = _friendListHandler;
avatarHandler = _avatarHandler;
this.db.ConnectionStringName = DatabaseConnectionName;
Cache = new(cacheLogger);
Cache.DefaultExpirationTime = 2_000;
}
public bool?CachedResolve(DecisionQuery query)
{
bool result;
QueryCache item = new QueryCache(query);
if (!cache.TryGetValue(item, out result))
{
return(null);
}
return(result);
}
public IEnumerable <FinchOrder> GetPastDateChips(
IDbTransaction transaction = null
)
{
var query = QueryCache.GetQuery("FinchCheck.sql");
return(Query <FinchOrder>(
query,
transaction: transaction
));
}
//private Dictionary<string, string> _extendDatabaseConnection = null;
public DBInfo(string dbName, string connectionString,
string dbType, LazyType allowLazy
)
{
_dbType = dbType;
_connectionString = connectionString;
_dbName = dbName;
_cache = new QueryCache(this);
_allowLazy = allowLazy;
InitAdapters();
}
internal static string BuildGetAllQuery(IDbConnection connection, Type type)
{
var sqlBuilder = GetSqlBuilder(connection);
var cacheKey = new QueryCacheKey(QueryCacheType.GetAll, sqlBuilder, type);
if (!QueryCache.TryGetValue(cacheKey, out var sql))
{
sql = "select * from " + Resolvers.Table(type, sqlBuilder);
QueryCache.TryAdd(cacheKey, sql);
}
return sql;
}
private void button1_Click(object sender, EventArgs e)
{
//INetFwPolicy2 firewallPolicy = (INetFwPolicy2)Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FwPolicy2"));
//INetFwRule2 firewallRule = null;
//firewallRule = firewallPolicy.Rules.Item("Bonjour 服务") as INetFwRule2;
QueryCache cache = CacheUnit.CreateCache(BuffaloCacheTypes.Redis, "server=39.108.125.58:6379;throw=1;");
string key = "App.BkIP";
cache.SetValue <long>(key, 100);
object cnt = cache.GetValue(key);
}
private static string BuildGetAllQuery(IDbConnection connection, Type type)
{
var cacheKey = new QueryCacheKey(QueryCacheType.GetAll, connection, type);
if (!QueryCache.TryGetValue(cacheKey, out var sql))
{
sql = "select * from " + Resolvers.Table(type, connection);
QueryCache.TryAdd(cacheKey, sql);
}
return(sql);
}
//Paginar
protected void dgHelp_Page(Object sender, DataGridPageChangedEventArgs e)
{
string sql = "";
if (Request.QueryString["params"].Contains("**"))
{
string opcion = Request.QueryString["params"].Replace("**", "");
sql = DB.SQLConsultaGlobal.Buscar(opcion);
}
else
{
sql = Request.QueryString["params"].Replace("%20", " ");
}
string column = ddlCols.SelectedItem.Text;
string content = tbWord.Text;
dgTable.CurrentPageIndex = e.NewPageIndex;
ds = QueryCache.getResult(sql);
DataTable table = ds.Tables[0];
if (tbWord.Text != "")
{
IEnumerable <DataRow> enumRows = table
.Select(String.Format("{0} LIKE '{1}'", column, content), column)
.AsEnumerable();
if (enumRows.Count <DataRow>() == 0)
{
table = table.Clone();
table.Clear();
}
else
{
//if (Request.QueryString["Padre"] != null)
// enumRows = enumRows.Take(100);
table = enumRows
.CopyToDataTable <DataRow>();
}
dgTable.DataSource = table;
}
else
{
dgTable.DataSource = table
.AsEnumerable()
.CopyToDataTable <DataRow>();
}
dgTable.DataBind();
}
internal static string BuildDeleteAllQuery(ISqlBuilder sqlBuilder, Type type)
{
var cacheKey = new QueryCacheKey(QueryCacheType.DeleteAll, sqlBuilder, type);
if (!QueryCache.TryGetValue(cacheKey, out var sql))
{
var tableName = Resolvers.Table(type, sqlBuilder);
sql = $"delete from {tableName}";
QueryCache.TryAdd(cacheKey, sql);
}
return(sql);
}
internal static string BuildCountAllSql(ISqlBuilder sqlBuilder, Type type)
{
var cacheKey = new QueryCacheKey(QueryCacheType.Count, sqlBuilder, type);
if (!QueryCache.TryGetValue(cacheKey, out var sql))
{
var tableName = Resolvers.Table(type, sqlBuilder);
sql = $"select count(*) from {tableName}";
QueryCache.TryAdd(cacheKey, sql);
}
return(sql);
}
public void QueryCache_Get_Query_ID_Returns_Name_When_Not_Found()
{
// Arrange
var expected = "My Queries";
QueryCache.Update(new List <string>());
// Act
var actual = QueryCache.GetId("My Queries");
// Assert
Assert.AreEqual(expected, actual);
}
public void TestQueryCache()
{
int iterations = 1000;
var cache = new QueryCache(10);
var notCached = RunTimedTest(iterations, i =>
{
var results = db.OrderDetails.Where(d => d.OrderID > i).Take(n).ToList();
System.Diagnostics.Debug.Assert(results.Count == n);
});
this.GetProvider().Cache = cache;
var autoCached = RunTimedTest(iterations, i =>
{
var results = db.OrderDetails.Where(d => d.OrderID > i).Take(n).ToList();
System.Diagnostics.Debug.Assert(results.Count == n);
});
this.GetProvider().Cache = null;
var check = RunTimedTest(iterations, i =>
{
var query = db.OrderDetails.Where(d => d.OrderID > i).Take(n);
var isCached = cache.Contains(query);
});
var cached = RunTimedTest(iterations, i =>
{
var query = db.OrderDetails.Where(d => d.OrderID > i).Take(n);
var results = cache.Execute(query).ToList();
System.Diagnostics.Debug.Assert(results.Count == n);
});
System.Diagnostics.Debug.Assert(cache.Count == 1);
var cq = QueryCompiler.Compile((Northwind nw, int i) => nw.OrderDetails.Where(d => d.OrderID > i).Take(n));
var compiled = RunTimedTest(iterations, i =>
{
var results = cq(db, i).ToList();
System.Diagnostics.Debug.Assert(results.Count == n);
});
Console.WriteLine("compiled : {0} sec", compiled);
Console.WriteLine("check cache: {0}", check);
Console.WriteLine("cached : {0} {1:#.##}x vs compiled", cached, cached / compiled);
Console.WriteLine("auto cached: {0} {1:#.##}x vs compiled", autoCached, autoCached / compiled);
Console.WriteLine("not cached : {0} {1:#.##}x vs compiled", notCached, notCached / compiled);
}
public void TestCache()
{
var qcache = new QueryCache(10);
AssertValue(0, qcache.Count);
var c1 = qcache.Execute(from c in db.Customers where c.CustomerID == "ALFKI" select c).First();
AssertValue("ALFKI", c1.CustomerID);
AssertValue(1, qcache.Count);
var c2 = qcache.Execute(from c in db.Customers where c.CustomerID == "ANTON" select c).First();
AssertValue("ANTON", c2.CustomerID);
AssertValue(1, qcache.Count);
string id = "ANTON";
var c3 = qcache.Execute(from c in db.Customers where c.CustomerID == id select c).First();
AssertValue(id, c3.CustomerID);
AssertValue(1, qcache.Count);
var o1 = qcache.Execute(from o in db.Orders where o.CustomerID == c1.CustomerID select o).ToList();
AssertValue(6, o1.Count);
AssertValue(2, qcache.Count);
var o2 = qcache.Execute(from o in db.Orders where o.CustomerID == c2.CustomerID select o).ToList();
AssertValue(7, o2.Count);
AssertValue(2, qcache.Count);
var o3 = qcache.Execute(from o in db.Orders where o.CustomerID == "ANTON" select o).ToList();
AssertValue(7, o3.Count);
AssertValue(2, qcache.Count);
}
