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); }