/// <summary> /// Asserts the client configs are equal. /// </summary> public static void AssertClientConfigsAreEqual(CacheClientConfiguration cfg, CacheClientConfiguration cfg2) { if (cfg2.QueryEntities != null) { // Remove identical aliases which are added during config roundtrip. foreach (var e in cfg2.QueryEntities) { e.Aliases = e.Aliases.Where(x => x.Alias != x.FullName).ToArray(); } } HashSet <string> ignoredProps = null; if (cfg.ExpiryPolicyFactory != null && cfg2.ExpiryPolicyFactory != null) { ignoredProps = new HashSet <string> { "ExpiryPolicyFactory" }; AssertExtensions.ReflectionEqual(cfg.ExpiryPolicyFactory.CreateInstance(), cfg2.ExpiryPolicyFactory.CreateInstance()); } AssertExtensions.ReflectionEqual(cfg, cfg2, ignoredProperties: ignoredProps); }
public void TestConstructors() { // Default property values. var clientCfg = new CacheClientConfiguration(); var defCfg = new CacheClientConfiguration(new CacheConfiguration(), false); ClientTestBase.AssertClientConfigsAreEqual(defCfg, clientCfg); // Name. clientCfg = new CacheClientConfiguration("foo"); Assert.AreEqual("foo", clientCfg.Name); clientCfg.Name = null; ClientTestBase.AssertClientConfigsAreEqual(defCfg, clientCfg); // Query entities. clientCfg = new CacheClientConfiguration("bar", typeof(QueryPerson)); Assert.AreEqual("bar", clientCfg.Name); var qe = clientCfg.QueryEntities.Single(); Assert.AreEqual(typeof(QueryPerson), qe.ValueType); Assert.AreEqual("Name", qe.Fields.Single().Name); clientCfg = new CacheClientConfiguration("baz", new QueryEntity(typeof(QueryPerson))); qe = clientCfg.QueryEntities.Single(); Assert.AreEqual(typeof(QueryPerson), qe.ValueType); Assert.AreEqual("Name", qe.Fields.Single().Name); }
public void Start(IDictionary <string, string> properties) { CacheClientConfiguration configuration; try { var tenantName = properties["cache.region_prefix"]; bool enableCompression = false; string enableCompressionString; if (properties.TryGetValue("compression_enabled", out enableCompressionString)) { enableCompression = Boolean.Parse(enableCompressionString); } var pca = new DefaultPlatformConfigurationAccessor(); configuration = CacheClientConfiguration.FromPlatformConfiguration(tenantName, Constants.DatabaseCacheSettingNamePrefix, pca); configuration.CompressionIsEnabled = enableCompression; configuration.Validate(); } catch (Exception ex) { throw new Exception(String.Format("The {0} configuration settings are missing or invalid.", Constants.DatabaseCacheFeatureName), ex); } _dataCacheFactory = configuration.CreateCache(); _dataCache = _dataCacheFactory.GetDefaultCache(); }
public static void Main() { using (IIgniteClient ignite = Ignition.StartClient(Utils.GetThinClientConfiguration())) { Console.WriteLine(); Console.WriteLine(">>> Optimistic transaction example started."); // Create Transactional cache. var cacheCfg = new CacheClientConfiguration(CacheName) { AtomicityMode = CacheAtomicityMode.Transactional }; var cache = ignite.GetOrCreateCache <int, int>(cacheCfg); // Put a value. cache[1] = 0; // Increment a value in parallel within a transaction. var transactions = ignite.GetTransactions(); var task1 = Task.Factory.StartNew(() => IncrementCacheValue(cache, transactions, 1)); var task2 = Task.Factory.StartNew(() => IncrementCacheValue(cache, transactions, 2)); Task.WaitAll(task1, task2); Console.WriteLine(); Console.WriteLine(">>> Resulting value in cache: " + cache[1]); Console.WriteLine(); Console.WriteLine(">>> Example finished, press any key to exit ..."); Console.ReadKey(); } }
public static void Main() { var cfg = new IgniteClientConfiguration("127.0.0.1"); using (IIgniteClient igniteClient = Ignition.StartClient(cfg)) { Console.WriteLine(); Console.WriteLine(">>> Cache query client example started."); // Configure query entities to enable SQL. var cacheCfg = new CacheClientConfiguration { Name = CacheName, QueryEntities = new[] { new QueryEntity(typeof(int), typeof(Employee)), } }; ICacheClient <int, Employee> cache = igniteClient.GetOrCreateCache <int, Employee>(cacheCfg); // Populate cache with sample data entries. PopulateCache(cache); // Run examples. SqlExample(cache); LinqExample(cache); LinqFieldsExample(cache); } Console.WriteLine(); Console.WriteLine(">>> Example finished, press any key to exit ..."); Console.ReadKey(); }
public void TestCreateFromConfigurationWithExpiration() { var expiryPolicy = new ExpiryPolicy( TimeSpan.FromMilliseconds(20), TimeSpan.FromMilliseconds(10), TimeSpan.FromMilliseconds(30)); // Default config. var cfg = new CacheClientConfiguration("a") { ExpiryPolicyFactory = new ExpiryPolicyFactory(expiryPolicy) }; var cache = Client.CreateCache <int, int>(cfg); AssertExtensions.ReflectionEqual(cfg, cache.GetConfiguration()); var remoteExpiryPolicy = cache.GetConfiguration().ExpiryPolicyFactory.CreateInstance(); AssertExtensions.ReflectionEqual(expiryPolicy, remoteExpiryPolicy); cache.Put(1, 1); // Wait for expiration period. Thread.Sleep(100); Assert.IsFalse(cache.ContainsKey(1)); }
public AzureOutputCacheStorageProvider(ShellSettings shellSettings, IAzureOutputCacheHolder cacheHolder) { var region = shellSettings.Name; // Azure Cache supports only alphanumeric strings for regions, but Orchard supports some // non-alphanumeric characters in tenant names. Remove all non-alphanumering characters // from the region, and append the hash code of the original string to mitigate the risk // of two distinct original region strings yielding the same transformed region string. _regionAlphaNumeric = new String(Array.FindAll(region.ToCharArray(), Char.IsLetterOrDigit)) + region.GetHashCode().ToString(CultureInfo.InvariantCulture); _cache = cacheHolder.TryGetDataCache(() => { CacheClientConfiguration cacheConfig; try { cacheConfig = CacheClientConfiguration.FromPlatformConfiguration(shellSettings.Name, Constants.OutputCacheSettingNamePrefix); cacheConfig.Validate(); } catch (Exception ex) { throw new Exception(String.Format("The {0} configuration settings are missing or invalid.", Constants.OutputCacheFeatureName), ex); } var cache = cacheConfig.CreateCache(); cache.CreateRegion(_regionAlphaNumeric); return(cache); }); }
public void TestCreateFromPartialConfiguration() { // Default config. var cfg = new CacheClientConfiguration("a") { Backups = 7 }; var client = (IgniteClient)Client; // Create cache directly through a socket with only some config properties provided. client.Socket.DoOutInOp <object>(ClientOp.CacheCreateWithConfiguration, s => { var w = client.Marshaller.StartMarshal(s); w.WriteInt(2 + 2 + 6 + 2 + 4); // config length in bytes. w.WriteShort(2); // 2 properties. w.WriteShort(3); // backups opcode. w.WriteInt(cfg.Backups); w.WriteShort(0); // name opcode. w.WriteString(cfg.Name); }, null); var cache = new CacheClient <int, int>(client, cfg.Name); AssertExtensions.ReflectionEqual(cfg, cache.GetConfiguration()); }
/// <summary> /// Serializes and deserializes the config. /// </summary> private static CacheClientConfiguration SerializeDeserialize(CacheClientConfiguration cfg) { using (var stream = new BinaryHeapStream(128)) { ClientCacheConfigurationSerializer.Write(stream, cfg); stream.Seek(0, SeekOrigin.Begin); return(new CacheClientConfiguration(stream)); } }
/** <inheritDoc /> */ public ICacheClient <TK, TV> CreateCache <TK, TV>(CacheClientConfiguration configuration) { IgniteArgumentCheck.NotNull(configuration, "configuration"); DoOutOp(ClientOp.CacheCreateWithConfiguration, w => ClientCacheConfigurationSerializer.Write(w.Stream, configuration, ServerVersion())); return(GetCache <TK, TV>(configuration.Name)); }
/** <inheritDoc /> */ public ICacheClient <TK, TV> GetOrCreateCache <TK, TV>(CacheClientConfiguration configuration) { IgniteArgumentCheck.NotNull(configuration, "configuration"); DoOutOp(ClientOp.CacheGetOrCreateWithConfiguration, ctx => ClientCacheConfigurationSerializer.Write(ctx.Stream, configuration, ctx.ProtocolVersion)); return(GetCache <TK, TV>(configuration.Name)); }
/// <summary> /// Serializes and deserializes the config. /// </summary> private static CacheClientConfiguration SerializeDeserialize(CacheClientConfiguration cfg) { using (var stream = new BinaryHeapStream(128)) { ClientCacheConfigurationSerializer.Write(stream, cfg, ClientSocket.CurrentProtocolVersion, true); stream.Seek(0, SeekOrigin.Begin); return(new CacheClientConfiguration(stream, ClientSocket.CurrentProtocolVersion)); } }
public void TestConfigConversion() { // Copy ctor. var clientCfg = new CacheClientConfiguration( CacheConfigurationTest.GetCustomCacheConfiguration("z"), true); ClientTestBase.AssertClientConfigsAreEqual(clientCfg, new CacheClientConfiguration(clientCfg)); // Convert to server cfg. var serverCfg = clientCfg.ToCacheConfiguration(); ClientTestBase.AssertClientConfigsAreEqual(clientCfg, new CacheClientConfiguration(serverCfg, false)); }
/// <summary> /// Asserts the client configs are equal. /// </summary> public static void AssertClientConfigsAreEqual(CacheClientConfiguration cfg, CacheClientConfiguration cfg2) { if (cfg2.QueryEntities != null) { // Remove identical aliases which are added during config roundtrip. foreach (var e in cfg2.QueryEntities) { e.Aliases = e.Aliases.Where(x => x.Alias != x.FullName).ToArray(); } } AssertExtensions.ReflectionEqual(cfg, cfg2); }
public static void ThinClientCacheOperations() { var cfg = new IgniteClientConfiguration { Endpoints = new[] { "127.0.0.1:10800" } }; using (var client = Ignition.StartClient(cfg)) { //tag::createCache[] var cacheCfg = new CacheClientConfiguration { Name = "References", CacheMode = CacheMode.Replicated, WriteSynchronizationMode = CacheWriteSynchronizationMode.FullSync }; var cache = client.GetOrCreateCache <int, string>(cacheCfg); //end::createCache[] //tag::basicOperations[] var data = Enumerable.Range(1, 100).ToDictionary(e => e, e => e.ToString()); cache.PutAll(data); var replace = cache.Replace(1, "2", "3"); Console.WriteLine(replace); //false var value = cache.Get(1); Console.WriteLine(value); //1 replace = cache.Replace(1, "1", "3"); Console.WriteLine(replace); //true value = cache.Get(1); Console.WriteLine(value); //3 cache.Put(101, "101"); cache.RemoveAll(data.Keys); var sizeIsOne = cache.GetSize() == 1; Console.WriteLine(sizeIsOne); //true value = cache.Get(101); Console.WriteLine(value); //101 cache.RemoveAll(); var sizeIsZero = cache.GetSize() == 0; Console.WriteLine(sizeIsZero); //true //end::basicOperations[] } }
public CacheClientConfiguration GetOrCreateEmployeeCacheConfig(string cacheName) { var cacheConfig = new CacheClientConfiguration { CacheMode = Apache.Ignite.Core.Cache.Configuration.CacheMode.Partitioned, Name = cacheName, QueryEntities = new[] { new QueryEntity(typeof(string), typeof(Employee)) } }; return(cacheConfig); }
/// <summary> /// Writes the specified config. /// </summary> public static void Write(IBinaryStream stream, CacheClientConfiguration cfg) { Debug.Assert(stream != null); Debug.Assert(cfg != null); // Configuration should be written with a system marshaller. var writer = BinaryUtils.Marshaller.StartMarshal(stream); var pos = writer.Stream.Position; writer.WriteInt(0); // Reserve for length. writer.WriteInt((int)cfg.AtomicityMode); writer.WriteInt(cfg.Backups); writer.WriteInt((int)cfg.CacheMode); writer.WriteBoolean(cfg.CopyOnRead); writer.WriteString(cfg.DataRegionName); writer.WriteBoolean(cfg.EagerTtl); writer.WriteBoolean(cfg.EnableStatistics); writer.WriteString(cfg.GroupName); writer.WriteBoolean(cfg.Invalidate); writer.WriteTimeSpanAsLong(cfg.LockTimeout); writer.WriteInt(cfg.MaxConcurrentAsyncOperations); writer.WriteInt(cfg.MaxQueryIteratorsCount); writer.WriteString(cfg.Name); writer.WriteBoolean(cfg.OnheapCacheEnabled); writer.WriteInt((int)cfg.PartitionLossPolicy); writer.WriteInt(cfg.QueryDetailMetricsSize); writer.WriteInt(cfg.QueryParallelism); writer.WriteBoolean(cfg.ReadFromBackup); writer.WriteInt(cfg.RebalanceBatchSize); writer.WriteLong(cfg.RebalanceBatchesPrefetchCount); writer.WriteTimeSpanAsLong(cfg.RebalanceDelay); writer.WriteInt((int)cfg.RebalanceMode); writer.WriteInt(cfg.RebalanceOrder); writer.WriteTimeSpanAsLong(cfg.RebalanceThrottle); writer.WriteTimeSpanAsLong(cfg.RebalanceTimeout); writer.WriteBoolean(cfg.SqlEscapeAll); writer.WriteInt(cfg.SqlIndexMaxInlineSize); writer.WriteString(cfg.SqlSchema); writer.WriteInt((int)cfg.WriteSynchronizationMode); writer.WriteCollectionRaw(cfg.KeyConfiguration); writer.WriteCollectionRaw(cfg.QueryEntities); // Write length (so that part of the config can be skipped). var len = writer.Stream.Position - pos - 4; writer.Stream.WriteInt(pos, len); }
/// <summary> /// Reads the config. /// </summary> public static void Read(IBinaryStream stream, CacheClientConfiguration cfg, ClientFeatures features) { Debug.Assert(stream != null); // Configuration should be read with system marshaller. var reader = BinaryUtils.Marshaller.StartUnmarshal(stream); var len = reader.ReadInt(); var pos = reader.Stream.Position; cfg.AtomicityMode = (CacheAtomicityMode)reader.ReadInt(); cfg.Backups = reader.ReadInt(); cfg.CacheMode = (CacheMode)reader.ReadInt(); cfg.CopyOnRead = reader.ReadBoolean(); cfg.DataRegionName = reader.ReadString(); cfg.EagerTtl = reader.ReadBoolean(); cfg.EnableStatistics = reader.ReadBoolean(); cfg.GroupName = reader.ReadString(); cfg.LockTimeout = reader.ReadLongAsTimespan(); cfg.MaxConcurrentAsyncOperations = reader.ReadInt(); cfg.MaxQueryIteratorsCount = reader.ReadInt(); cfg.Name = reader.ReadString(); cfg.OnheapCacheEnabled = reader.ReadBoolean(); cfg.PartitionLossPolicy = (PartitionLossPolicy)reader.ReadInt(); cfg.QueryDetailMetricsSize = reader.ReadInt(); cfg.QueryParallelism = reader.ReadInt(); cfg.ReadFromBackup = reader.ReadBoolean(); cfg.RebalanceBatchSize = reader.ReadInt(); cfg.RebalanceBatchesPrefetchCount = reader.ReadLong(); cfg.RebalanceDelay = reader.ReadLongAsTimespan(); cfg.RebalanceMode = (CacheRebalanceMode)reader.ReadInt(); cfg.RebalanceOrder = reader.ReadInt(); cfg.RebalanceThrottle = reader.ReadLongAsTimespan(); cfg.RebalanceTimeout = reader.ReadLongAsTimespan(); cfg.SqlEscapeAll = reader.ReadBoolean(); cfg.SqlIndexMaxInlineSize = reader.ReadInt(); cfg.SqlSchema = reader.ReadString(); cfg.WriteSynchronizationMode = (CacheWriteSynchronizationMode)reader.ReadInt(); cfg.KeyConfiguration = reader.ReadCollectionRaw(r => new CacheKeyConfiguration(r)); cfg.QueryEntities = reader.ReadCollectionRaw(r => ReadQueryEntity(r, features)); if (features.HasCacheConfigurationExpiryPolicyFactory()) { cfg.ExpiryPolicyFactory = ExpiryPolicySerializer.ReadPolicyFactory(reader); } Debug.Assert(len == reader.Stream.Position - pos); }
public void TestAuthentication() { using (var srv = Ignition.Start(SecureServerConfig())) { srv.GetCluster().SetActive(true); using (var cli = Ignition.StartClient(SecureClientConfig())) { CacheClientConfiguration ccfg = new CacheClientConfiguration() { Name = "TestCache", QueryEntities = new[] { new QueryEntity { KeyType = typeof(string), ValueType = typeof(string), }, }, }; ICacheClient <string, string> cache = cli.GetOrCreateCache <string, string>(ccfg); cache.Put("key1", "val1"); cache.Query(new SqlFieldsQuery("CREATE USER \"my_User\" WITH PASSWORD 'my_Password'")).GetAll(); } var cliCfg = SecureClientConfig(); cliCfg.UserName = "******"; cliCfg.Password = "******"; using (var cli = Ignition.StartClient(cliCfg)) { ICacheClient <string, string> cache = cli.GetCache <string, string>("TestCache"); string val = cache.Get("key1"); Assert.True(val == "val1"); } } }
public void TestGetOrCreateFromConfiguration() { // Default configur. var cfg = new CacheClientConfiguration("a"); var cache = Client.GetOrCreateCache <int, int>(cfg); AssertExtensions.ReflectionEqual(cfg, cache.GetConfiguration()); cache[1] = 1; // Create when exists. cache = Client.GetOrCreateCache <int, int>("a"); Assert.AreEqual(1, cache[1]); // Custom config. cfg = GetFullCacheConfiguration("b"); cache = Client.GetOrCreateCache <int, int>(cfg); AssertClientConfigsAreEqual(cfg, cache.GetConfiguration()); }
/// <summary> /// Start new node, create new user with given credentials and try to authenticate. /// </summary> /// <param name="user">Username</param> /// <param name="pass">Password</param> private void CreateNewUserAndAuthenticate(string user, string pass) { using (var srv = Ignition.Start(SecureServerConfig())) { srv.GetCluster().SetActive(true); using (var cli = Ignition.StartClient(GetSecureClientConfig())) { CacheClientConfiguration ccfg = new CacheClientConfiguration { Name = "TestCache", QueryEntities = new[] { new QueryEntity { KeyType = typeof(string), ValueType = typeof(string), }, }, }; ICacheClient <string, string> cache = cli.GetOrCreateCache <string, string>(ccfg); cache.Put("key1", "val1"); cache.Query(new SqlFieldsQuery("CREATE USER \"" + user + "\" WITH PASSWORD '" + pass + "'")).GetAll(); } var cliCfg = GetSecureClientConfig(); cliCfg.UserName = user; cliCfg.Password = pass; using (var cli = Ignition.StartClient(cliCfg)) { ICacheClient <string, string> cache = cli.GetCache <string, string>("TestCache"); string val = cache.Get("key1"); Assert.True(val == "val1"); } } }
public static ICacheClient <TKey, TData> GetOrCreateCache <TKey, TData>(IIgniteClient ignite, string cacheName, Action <CacheClientConfiguration> extendConfigurationAction = null) { var cacheCfg = new CacheClientConfiguration() { Name = cacheName, CacheMode = CacheMode.Partitioned, GroupName = typeof(TData).FullName, QueryEntities = new[] { new QueryEntity { KeyType = typeof(TKey), ValueType = typeof(TData), } } }; extendConfigurationAction?.Invoke(cacheCfg); return(ignite.GetOrCreateCache <TKey, TData>(cacheCfg)); }
public void ReplicatedCacheGet_RepeatedCall_DoesNotRequestAffinityMapping() { // Test cache for which affinity awareness is not applicable. var cfg = new CacheClientConfiguration("replicated_cache") { CacheMode = CacheMode.Replicated }; var cache = Client.CreateCache <int, int>(cfg); // Init the replicated cache and start the new one to enforce partition mapping request. cache.PutAll(Enumerable.Range(1, 3).ToDictionary(x => x, x => x)); Client.CreateCache <int, int>("repeat-call-test-replicated"); ClearLoggers(); cache.Get(1); cache.Get(2); cache.Get(3); var reqs = GetLoggers() .Select(l => new { Logger = l, Requests = GetServerRequestNames(l, RequestNamePrefixCache).ToArray() }) .Where(r => r.Requests.Length > 0) .ToArray(); // All requests should go to a single (default) node, because affinity awareness is not applicable. Assert.AreEqual(1, reqs.Length); // There should be only one partitions request. var expectedRequests = new[] { "Partitions", "Get", "Get", "Get" }; Assert.AreEqual(expectedRequests, reqs[0].Requests); }
public void TestCreateFromConfiguration() { // Default config. var cfg = new CacheClientConfiguration("a"); var cache = Client.CreateCache <int, int>(cfg); AssertExtensions.ReflectionEqual(cfg, cache.GetConfiguration()); // Create when exists. var ex = Assert.Throws <IgniteClientException>(() => Client.CreateCache <int, int>(cfg)); Assert.AreEqual( "Failed to start cache (a cache with the same name is already started): a", ex.Message); Assert.AreEqual(ClientStatusCode.CacheExists, ex.StatusCode); // Custom config. cfg = GetFullCacheConfiguration("b"); cache = Client.CreateCache <int, int>(cfg); AssertClientConfigsAreEqual(cfg, cache.GetConfiguration()); }
/// <summary> /// Copies one cache configuration to another. /// </summary> public static void Copy(CacheClientConfiguration from, CacheConfiguration to) { Debug.Assert(from != null); Debug.Assert(to != null); to.AtomicityMode = from.AtomicityMode; to.Backups = from.Backups; to.CacheMode = from.CacheMode; to.CopyOnRead = from.CopyOnRead; to.DataRegionName = from.DataRegionName; to.EagerTtl = from.EagerTtl; to.ExpiryPolicyFactory = from.ExpiryPolicyFactory; to.EnableStatistics = from.EnableStatistics; to.GroupName = from.GroupName; to.LockTimeout = from.LockTimeout; to.MaxConcurrentAsyncOperations = from.MaxConcurrentAsyncOperations; to.MaxQueryIteratorsCount = from.MaxQueryIteratorsCount; to.Name = from.Name; to.OnheapCacheEnabled = from.OnheapCacheEnabled; to.PartitionLossPolicy = from.PartitionLossPolicy; to.QueryDetailMetricsSize = from.QueryDetailMetricsSize; to.QueryParallelism = from.QueryParallelism; to.ReadFromBackup = from.ReadFromBackup; to.RebalanceBatchSize = from.RebalanceBatchSize; to.RebalanceBatchesPrefetchCount = from.RebalanceBatchesPrefetchCount; to.RebalanceDelay = from.RebalanceDelay; to.RebalanceMode = from.RebalanceMode; to.RebalanceOrder = from.RebalanceOrder; to.RebalanceThrottle = from.RebalanceThrottle; to.RebalanceTimeout = from.RebalanceTimeout; to.SqlEscapeAll = from.SqlEscapeAll; to.SqlIndexMaxInlineSize = from.SqlIndexMaxInlineSize; to.SqlSchema = from.SqlSchema; to.WriteSynchronizationMode = from.WriteSynchronizationMode; to.KeyConfiguration = from.KeyConfiguration; to.QueryEntities = from.QueryEntities; }
public void CachePut_UserDefinedTypeWithAffinityKey_ThrowsIgniteException() { // Note: annotation-based configuration is not supported on Java side. // Use manual configuration instead. var cacheClientConfiguration = new CacheClientConfiguration("c_custom_key_aff") { KeyConfiguration = new List <CacheKeyConfiguration> { new CacheKeyConfiguration(typeof(TestKeyWithAffinity)) { AffinityKeyFieldName = "_i" } } }; var cache = Client.GetOrCreateCache <TestKeyWithAffinity, int>(cacheClientConfiguration); var ex = Assert.Throws <IgniteException>(() => cache.Put(new TestKeyWithAffinity(1, "1"), 1)); var expected = string.Format("Affinity keys are not supported. Object '{0}' has an affinity key.", typeof(TestKeyWithAffinity)); Assert.AreEqual(expected, ex.Message); }
public void TestCacheStartFromThinClientRegistersMetaForQueryEntityTypes() { var cfg = new CacheClientConfiguration { Name = TestUtils.TestName, QueryEntities = new[] { new QueryEntity { KeyType = typeof(Key1), ValueType = typeof(Value1) } } }; using (var client = Ignition.StartClient(new IgniteClientConfiguration("localhost:10800..10801"))) { client.CreateCache <Key1, Value1>(cfg); var type = client.GetBinary().GetBinaryType(typeof(Key1)); Assert.AreEqual("Bar", type.AffinityKeyFieldName); } }
public static void Main() { using (IIgniteClient ignite = Ignition.StartClient(Utils.GetThinClientConfiguration())) { Console.WriteLine(); Console.WriteLine(">>> Cache query DDL example started."); // Create dummy cache to act as an entry point for SQL queries (new SQL API which do not require this // will appear in future versions, JDBC and ODBC drivers do not require it already). var cacheCfg = new CacheClientConfiguration("dummy_cache") { SqlSchema = "PUBLIC", CacheMode = CacheMode.Replicated }; ICacheClient <object, object> cache = ignite.GetOrCreateCache <object, object>(cacheCfg); // Create reference City table based on REPLICATED template. cache.Query(new SqlFieldsQuery( "CREATE TABLE city (id LONG PRIMARY KEY, name VARCHAR) WITH \"template=replicated\"")).GetAll(); // Create table based on PARTITIONED template with one backup. cache.Query(new SqlFieldsQuery( "CREATE TABLE person (id LONG, name VARCHAR, city_id LONG, PRIMARY KEY (id, city_id)) " + "WITH \"backups=1, affinity_key=city_id\"")).GetAll(); // Create an index. cache.Query(new SqlFieldsQuery("CREATE INDEX on Person (city_id)")).GetAll(); Console.WriteLine("\n>>> Created database objects."); const string addCity = "INSERT INTO city (id, name) VALUES (?, ?)"; cache.Query(new SqlFieldsQuery(addCity, 1L, "Forest Hill")); cache.Query(new SqlFieldsQuery(addCity, 2L, "Denver")); cache.Query(new SqlFieldsQuery(addCity, 3L, "St. Petersburg")); const string addPerson = "INSERT INTO person (id, name, city_id) values (?, ?, ?)"; cache.Query(new SqlFieldsQuery(addPerson, 1L, "John Doe", 3L)); cache.Query(new SqlFieldsQuery(addPerson, 2L, "Jane Roe", 2L)); cache.Query(new SqlFieldsQuery(addPerson, 3L, "Mary Major", 1L)); cache.Query(new SqlFieldsQuery(addPerson, 4L, "Richard Miles", 2L)); Console.WriteLine("\n>>> Populated data."); IFieldsQueryCursor res = cache.Query(new SqlFieldsQuery( "SELECT p.name, c.name FROM Person p INNER JOIN City c on c.id = p.city_id")); Console.WriteLine("\n>>> Query results:"); foreach (var row in res) { Console.WriteLine("{0}, {1}", row[0], row[1]); } cache.Query(new SqlFieldsQuery("drop table Person")).GetAll(); cache.Query(new SqlFieldsQuery("drop table City")).GetAll(); Console.WriteLine("\n>>> Dropped database objects."); } Console.WriteLine(); Console.WriteLine(">>> Example finished, press any key to exit ..."); Console.ReadKey(); }
/// <summary> /// Copies one cache configuration to another. /// </summary> public static void Copy(CacheConfiguration from, CacheClientConfiguration to, bool ignoreUnsupportedProperties) { Debug.Assert(from != null); Debug.Assert(to != null); to.AtomicityMode = from.AtomicityMode; to.Backups = from.Backups; to.CacheMode = from.CacheMode; to.CopyOnRead = from.CopyOnRead; to.DataRegionName = from.DataRegionName; to.EagerTtl = from.EagerTtl; to.ExpiryPolicyFactory = from.ExpiryPolicyFactory; to.EnableStatistics = from.EnableStatistics; to.GroupName = from.GroupName; to.LockTimeout = from.LockTimeout; to.MaxConcurrentAsyncOperations = from.MaxConcurrentAsyncOperations; to.MaxQueryIteratorsCount = from.MaxQueryIteratorsCount; to.Name = from.Name; to.OnheapCacheEnabled = from.OnheapCacheEnabled; to.PartitionLossPolicy = from.PartitionLossPolicy; to.QueryDetailMetricsSize = from.QueryDetailMetricsSize; to.QueryParallelism = from.QueryParallelism; to.ReadFromBackup = from.ReadFromBackup; to.RebalanceBatchSize = from.RebalanceBatchSize; to.RebalanceBatchesPrefetchCount = from.RebalanceBatchesPrefetchCount; to.RebalanceDelay = from.RebalanceDelay; to.RebalanceMode = from.RebalanceMode; to.RebalanceOrder = from.RebalanceOrder; to.RebalanceThrottle = from.RebalanceThrottle; to.RebalanceTimeout = from.RebalanceTimeout; to.SqlEscapeAll = from.SqlEscapeAll; to.SqlIndexMaxInlineSize = from.SqlIndexMaxInlineSize; to.SqlSchema = from.SqlSchema; to.WriteSynchronizationMode = from.WriteSynchronizationMode; to.KeyConfiguration = from.KeyConfiguration; to.QueryEntities = from.QueryEntities; if (!ignoreUnsupportedProperties) { // Unsupported complex properties. ThrowUnsupportedIfNotDefault(from.AffinityFunction, "AffinityFunction"); ThrowUnsupportedIfNotDefault(from.EvictionPolicy, "EvictionPolicy"); ThrowUnsupportedIfNotDefault(from.PluginConfigurations, "PluginConfigurations"); ThrowUnsupportedIfNotDefault(from.CacheStoreFactory, "CacheStoreFactory"); ThrowUnsupportedIfNotDefault(from.NearConfiguration, "NearConfiguration"); // Unsupported store-related properties. ThrowUnsupportedIfNotDefault(from.KeepBinaryInStore, "KeepBinaryInStore"); ThrowUnsupportedIfNotDefault(from.LoadPreviousValue, "LoadPreviousValue"); ThrowUnsupportedIfNotDefault(from.ReadThrough, "ReadThrough"); ThrowUnsupportedIfNotDefault(from.WriteThrough, "WriteThrough"); ThrowUnsupportedIfNotDefault(from.StoreConcurrentLoadAllThreshold, "StoreConcurrentLoadAllThreshold", CacheConfiguration.DefaultStoreConcurrentLoadAllThreshold); ThrowUnsupportedIfNotDefault(from.WriteBehindBatchSize, "WriteBehindBatchSize", CacheConfiguration.DefaultWriteBehindBatchSize); ThrowUnsupportedIfNotDefault(from.WriteBehindCoalescing, "WriteBehindCoalescing", CacheConfiguration.DefaultWriteBehindCoalescing); ThrowUnsupportedIfNotDefault(from.WriteBehindEnabled, "WriteBehindEnabled"); ThrowUnsupportedIfNotDefault(from.WriteBehindFlushFrequency, "WriteBehindFlushFrequency", CacheConfiguration.DefaultWriteBehindFlushFrequency); ThrowUnsupportedIfNotDefault(from.WriteBehindFlushSize, "WriteBehindFlushSize", CacheConfiguration.DefaultWriteBehindFlushSize); ThrowUnsupportedIfNotDefault(from.WriteBehindFlushThreadCount, "WriteBehindFlushThreadCount", CacheConfiguration.DefaultWriteBehindFlushThreadCount); } }
/// <summary> /// Writes the specified config. /// </summary> public static void Write(IBinaryStream stream, CacheClientConfiguration cfg, ClientFeatures features, bool skipCodes = false) { Debug.Assert(stream != null); Debug.Assert(cfg != null); // Configuration should be written with a system marshaller. var writer = BinaryUtils.Marshaller.StartMarshal(stream); var pos = writer.Stream.Position; writer.WriteInt(0); // Reserve for length. if (!skipCodes) { writer.WriteShort(PropertyCount); // Property count. } var code = skipCodes ? (Action <Op>)(o => { }) : o => writer.WriteShort((short)o); code(Op.AtomicityMode); writer.WriteInt((int)cfg.AtomicityMode); code(Op.Backups); writer.WriteInt(cfg.Backups); code(Op.CacheMode); writer.WriteInt((int)cfg.CacheMode); code(Op.CopyOnRead); writer.WriteBoolean(cfg.CopyOnRead); code(Op.DataRegionName); writer.WriteString(cfg.DataRegionName); code(Op.EagerTtl); writer.WriteBoolean(cfg.EagerTtl); code(Op.StatisticsEnabled); writer.WriteBoolean(cfg.EnableStatistics); code(Op.GroupName); writer.WriteString(cfg.GroupName); code(Op.DefaultLockTimeout); writer.WriteTimeSpanAsLong(cfg.LockTimeout); code(Op.MaxConcurrentAsyncOperations); writer.WriteInt(cfg.MaxConcurrentAsyncOperations); code(Op.MaxQueryIteratorsCount); writer.WriteInt(cfg.MaxQueryIteratorsCount); code(Op.Name); writer.WriteString(cfg.Name); code(Op.OnheapCacheEnabled); writer.WriteBoolean(cfg.OnheapCacheEnabled); code(Op.PartitionLossPolicy); writer.WriteInt((int)cfg.PartitionLossPolicy); code(Op.QueryDetailMetricsSize); writer.WriteInt(cfg.QueryDetailMetricsSize); code(Op.QueryParallelism); writer.WriteInt(cfg.QueryParallelism); code(Op.ReadFromBackup); writer.WriteBoolean(cfg.ReadFromBackup); code(Op.RebalanceBatchSize); writer.WriteInt(cfg.RebalanceBatchSize); code(Op.RebalanceBatchesPrefetchCount); writer.WriteLong(cfg.RebalanceBatchesPrefetchCount); code(Op.RebalanceDelay); writer.WriteTimeSpanAsLong(cfg.RebalanceDelay); code(Op.RebalanceMode); writer.WriteInt((int)cfg.RebalanceMode); code(Op.RebalanceOrder); writer.WriteInt(cfg.RebalanceOrder); code(Op.RebalanceThrottle); writer.WriteTimeSpanAsLong(cfg.RebalanceThrottle); code(Op.RebalanceTimeout); writer.WriteTimeSpanAsLong(cfg.RebalanceTimeout); code(Op.SqlEscapeAll); writer.WriteBoolean(cfg.SqlEscapeAll); code(Op.SqlIndexMaxInlineSize); writer.WriteInt(cfg.SqlIndexMaxInlineSize); code(Op.SqlSchema); writer.WriteString(cfg.SqlSchema); code(Op.WriteSynchronizationMode); writer.WriteInt((int)cfg.WriteSynchronizationMode); code(Op.KeyConfiguration); writer.WriteCollectionRaw(cfg.KeyConfiguration); code(Op.QueryEntities); writer.WriteCollectionRaw(cfg.QueryEntities, (w, qe) => WriteQueryEntity(w, qe, features)); code(Op.ExpiryPolicy); ExpiryPolicySerializer.WritePolicyFactory(writer, cfg.ExpiryPolicyFactory); // Write length (so that part of the config can be skipped). var len = writer.Stream.Position - pos - 4; writer.Stream.WriteInt(pos, len); }