public void SetupFixture()
{
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("2.2"), Comparison.LessThan))
{
Assert.Ignore("Requires Cassandra version >= 2.2");
return;
}
Diagnostics.CassandraTraceSwitch.Level = TraceLevel.Info;
_testCluster = TestClusterManager.CreateNew(1, new TestClusterOptions
{
CassandraYaml = new[]
{
"batch_size_warn_threshold_in_kb:5",
"batch_size_fail_threshold_in_kb:50"
},
//Using a mirroring handler, the server will reply providing the same payload that was sent
JvmArgs = new[] { "-Dcassandra.custom_query_handler_class=org.apache.cassandra.cql3.CustomPayloadMirroringQueryHandler" }
});
_testCluster.InitClient();
Session = _testCluster.Session;
Session.Execute(string.Format(TestUtils.CreateKeyspaceSimpleFormat, Keyspace, 1));
Session.Execute(string.Format(TestUtils.CreateTableSimpleFormat, Table));
}
public void Fetch_WithConsistencyLevel_Invalids_OnlySupportedForWrites()
{
Table <Author> table = new Table <Author>(_session, new MappingConfiguration());
table.Create();
int totalInserts = 10;
var mapper = new Mapper(_session, new MappingConfiguration().Define(new FluentUserMapping()));
List <Author> expectedAuthors = Author.GetRandomList(totalInserts);
foreach (Author expectedAuthor in expectedAuthors)
{
mapper.Insert(expectedAuthor);
}
Cql cql = new Cql("SELECT * from " + table.Name).WithOptions(c => c.SetConsistencyLevel(ConsistencyLevel.Any));
var err = Assert.Throws <InvalidQueryException>(() => mapper.Fetch <Author>(cql).ToList());
Assert.AreEqual("ANY ConsistencyLevel is only supported for writes", err.Message);
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("3.0"), Comparison.LessThan))
{
cql = new Cql("SELECT * from " + table.Name).WithOptions(c => c.SetConsistencyLevel(ConsistencyLevel.EachQuorum));
err = Assert.Throws <InvalidQueryException>(() => mapper.Fetch <Author>(cql).ToList());
Assert.AreEqual("EACH_QUORUM ConsistencyLevel is only supported for writes", err.Message);
}
}
public void ColumnClusteringOrderReversedTest(bool metadataSync)
{
if (TestClusterManager.CheckCassandraVersion(false, new Version(4, 0), Comparison.GreaterThanOrEqualsTo))
{
Assert.Ignore("Compact table test designed for C* 3.0");
return;
}
var keyspaceName = TestUtils.GetUniqueKeyspaceName();
var tableName = TestUtils.GetUniqueTableName().ToLower();
var cluster = GetNewTemporaryCluster(builder => builder.WithMetadataSyncOptions(new MetadataSyncOptions().SetMetadataSyncEnabled(metadataSync)));
var session = cluster.Connect();
session.CreateKeyspace(keyspaceName);
session.ChangeKeyspace(keyspaceName);
var cql = "CREATE TABLE " + tableName + " (" +
@"id int,
description text,
price double,
PRIMARY KEY(id, description, price)
) WITH COMPACT STORAGE
AND CLUSTERING ORDER BY (description ASC, price DESC)";
session.Execute(cql);
var tableMeta = cluster.Metadata.GetKeyspace(keyspaceName).GetTableMetadata(tableName);
Assert.AreEqual(new[] { "description", "price" }, tableMeta.ClusteringKeys.Select(c => c.Item1.Name));
Assert.AreEqual(new[] { SortOrder.Ascending, SortOrder.Descending }, tableMeta.ClusteringKeys.Select(c => c.Item2));
}
public SchemaMetadataTests() :
base(1, true, new TestClusterOptions
{
CassandraYaml =
TestClusterManager.CheckCassandraVersion(true, new Version(4, 0), Comparison.GreaterThanOrEqualsTo)
? new[] { "enable_materialized_views: true" } : new string[0]
})
{
}
public void Parallel_Insert_And_Select_Sync_With_Nodes_Failing()
{
var testCluster = TestClusterManager.GetNonShareableTestCluster(3, 1, true, false);
using (var cluster = ClusterBuilder()
.WithRetryPolicy(AlwaysRetryRetryPolicy.Instance)
.AddContactPoint(testCluster.InitialContactPoint)
.Build())
{
var session = cluster.Connect();
var uniqueKsName = "keyspace_" + Randomm.RandomAlphaNum(10);
session.Execute(@"CREATE KEYSPACE " + uniqueKsName +
" WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 3};");
session.ChangeKeyspace(uniqueKsName);
var tableName = "table_" + Guid.NewGuid().ToString("N").ToLower();
session.Execute(string.Format(TestUtils.CREATE_TABLE_TIME_SERIES, tableName));
var insertQuery = string.Format("INSERT INTO {0} (id, event_time, text_sample) VALUES (?, ?, ?)", tableName);
var insertQueryPrepared = session.Prepare(insertQuery);
var selectQuery = string.Format("SELECT * FROM {0} LIMIT 10000", tableName);
const int rowsPerId = 100;
object insertQueryStatement = new SimpleStatement(insertQuery);
if (TestClusterManager.CheckCassandraVersion(false, new Version(2, 0), Comparison.LessThan))
{
//Use prepared statements all the way as it is not possible to bind on a simple statement with C* 1.2
insertQueryStatement = session.Prepare(insertQuery);
}
var actionInsert = GetInsertAction(session, insertQueryStatement, ConsistencyLevel.Quorum, rowsPerId);
var actionInsertPrepared = GetInsertAction(session, insertQueryPrepared, ConsistencyLevel.Quorum, rowsPerId);
var actionSelect = GetSelectAction(session, selectQuery, ConsistencyLevel.Quorum, 10);
//Execute insert sync to have some records
actionInsert();
//Execute select sync to assert that everything is going OK
actionSelect();
var actions = new List <Action>();
for (var i = 0; i < 10; i++)
{
//Add 10 actions to execute
actions.AddRange(new[] { actionInsert, actionSelect, actionInsertPrepared });
actions.AddRange(new[] { actionSelect, actionInsert, actionInsertPrepared, actionInsert });
actions.AddRange(new[] { actionInsertPrepared, actionInsertPrepared, actionSelect });
}
actions.Insert(8, () =>
{
Thread.Sleep(300);
testCluster.StopForce(2);
});
TestHelper.ParallelInvoke(actions.ToArray());
}
}
public void Insert_WithMapperInsert_TwoPartitionKeys_OnlyOne()
{
// Setup
var mappingConfig = new MappingConfiguration().Define(new Map <ClassWithTwoPartitionKeys>()
.TableName(typeof(ClassWithTwoPartitionKeys).Name).CaseSensitive()
.PartitionKey(new string[] { "PartitionKey1", "PartitionKey2" }).CaseSensitive()
);
var table = new Table <ClassWithTwoPartitionKeys>(_session, mappingConfig);
table.Create();
// Insert the data
ClassWithTwoPartitionKeys defaultInstance = new ClassWithTwoPartitionKeys();
ClassWithTwoPartitionKeys instance = new ClassWithTwoPartitionKeys();
var mapper = new Mapper(_session, mappingConfig);
mapper.Insert(instance);
List <ClassWithTwoPartitionKeys> instancesRetrieved = new List <ClassWithTwoPartitionKeys>();
DateTime futureDateTime = DateTime.Now.AddSeconds(5);
while (instancesRetrieved.Count < 1 && DateTime.Now < futureDateTime)
{
instancesRetrieved = mapper.Fetch <ClassWithTwoPartitionKeys>("SELECT * from \"" + table.Name + "\"").ToList();
}
Assert.AreEqual(1, instancesRetrieved.Count);
Assert.AreEqual(defaultInstance.PartitionKey1, instancesRetrieved[0].PartitionKey1);
Assert.AreEqual(defaultInstance.PartitionKey2, instancesRetrieved[0].PartitionKey2);
instancesRetrieved.Clear();
futureDateTime = DateTime.Now.AddSeconds(5);
string cqlSelect = "SELECT * from \"" + table.Name + "\" where \"PartitionKey1\" = '" + instance.PartitionKey1 + "' and \"PartitionKey2\" = '" + instance.PartitionKey2 + "'";
while (instancesRetrieved.Count < 1 && DateTime.Now < futureDateTime)
{
instancesRetrieved = mapper.Fetch <ClassWithTwoPartitionKeys>(cqlSelect).ToList();
}
Assert.AreEqual(1, instancesRetrieved.Count);
Assert.AreEqual(defaultInstance.PartitionKey1, instancesRetrieved[0].PartitionKey1);
Assert.AreEqual(defaultInstance.PartitionKey2, instancesRetrieved[0].PartitionKey2);
var err = Assert.Throws <InvalidQueryException>(() => mapper.Fetch <ClassWithTwoPartitionKeys>("SELECT * from \"" + table.Name + "\" where \"PartitionKey1\" = '" + instance.PartitionKey1 + "'"));
string expectedErrMsg = "Partition key part(s:)? PartitionKey2 must be restricted (since preceding part is|as other parts are)";
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("3.10"), Comparison.GreaterThanOrEqualsTo))
{
expectedErrMsg = "Cannot execute this query as it might involve data filtering and thus may have unpredictable performance. If you want to execute this query despite the performance unpredictability, use ALLOW FILTERING";
}
StringAssert.IsMatch(expectedErrMsg, err.Message);
Assert.Throws <InvalidQueryException>(() => mapper.Fetch <ClassWithTwoPartitionKeys>("SELECT * from \"" + table.Name + "\" where \"PartitionKey2\" = '" + instance.PartitionKey2 + "'"));
}
public void Should_Use_Maximum_Protocol_Version_Provided()
{
var version = ProtocolVersion.V2;
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("3.0"), Comparison.GreaterThanOrEqualsTo))
{
//protocol 2 is not supported in Cassandra 3.0+
version = ProtocolVersion.V3;
}
var cc = NewInstance(version);
cc.InitAsync().Wait(InitTimeout);
Assert.AreEqual(version, cc.ProtocolVersion);
cc.Dispose();
}
public override void OneTimeSetUp()
{
base.OneTimeSetUp();
var insertQuery = $"INSERT INTO {AllTypesTableName} (id, timeuuid_sample) VALUES (?, ?)";
var selectQuery = $"SELECT id, timeuuid_sample, dateOf(timeuuid_sample) FROM {AllTypesTableName} WHERE id = ?";
if (TestClusterManager.CheckCassandraVersion(false, new Version(2, 2), Comparison.GreaterThanOrEqualsTo))
{
selectQuery =
$"SELECT id, timeuuid_sample, toTimestamp(timeuuid_sample) as timeuuid_date_value FROM {AllTypesTableName} WHERE id = ?";
}
_insertPrepared = Session.Prepare(insertQuery);
_selectPrepared = Session.Prepare(selectQuery);
}
public override void OneTimeSetUp()
{
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("2.1.0"), Comparison.LessThan))
{
Assert.Ignore("Requires Cassandra version >= 2.1");
}
base.OneTimeSetUp();
Session.Execute(UdtMappingsTests.CqlType1);
Session.Execute(UdtMappingsTests.CqlType2);
Session.Execute(UdtMappingsTests.CqlTable1);
Session.Execute(UdtMappingsTests.CqlTable2);
}
public void Register_For_Events()
{
var eventHandle = new AutoResetEvent(false);
CassandraEventArgs eventArgs = null;
using (var connection = CreateConnection())
{
connection.Open().Wait();
Query(connection, String.Format("DROP KEYSPACE IF EXISTS test_events_kp", 1)).Wait();
var eventTypes = CassandraEventType.TopologyChange | CassandraEventType.StatusChange | CassandraEventType.SchemaChange;
var task = connection.Send(new RegisterForEventRequest(eventTypes));
TaskHelper.WaitToComplete(task, 1000);
Assert.IsInstanceOf <ReadyResponse>(task.Result);
connection.CassandraEventResponse += (o, e) =>
{
eventArgs = e;
eventHandle.Set();
};
//create a keyspace and check if gets received as an event
Query(connection, String.Format(TestUtils.CreateKeyspaceSimpleFormat, "test_events_kp", 1)).Wait(1000);
eventHandle.WaitOne(2000);
Assert.IsNotNull(eventArgs);
Assert.IsInstanceOf <SchemaChangeEventArgs>(eventArgs);
Assert.AreEqual(SchemaChangeEventArgs.Reason.Created, (eventArgs as SchemaChangeEventArgs).What);
Assert.AreEqual("test_events_kp", (eventArgs as SchemaChangeEventArgs).Keyspace);
Assert.That((eventArgs as SchemaChangeEventArgs).Table, Is.Null.Or.Empty);
//create a table and check if gets received as an event
Query(connection, String.Format(TestUtils.CreateTableAllTypes, "test_events_kp.test_table", 1)).Wait(1000);
eventHandle.WaitOne(2000);
Assert.IsNotNull(eventArgs);
Assert.IsInstanceOf <SchemaChangeEventArgs>(eventArgs);
Assert.AreEqual(SchemaChangeEventArgs.Reason.Created, (eventArgs as SchemaChangeEventArgs).What);
Assert.AreEqual("test_events_kp", (eventArgs as SchemaChangeEventArgs).Keyspace);
Assert.AreEqual("test_table", (eventArgs as SchemaChangeEventArgs).Table);
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("2.1"), Comparison.GreaterThanOrEqualsTo))
{
Query(connection, "CREATE TYPE test_events_kp.test_type (street text, city text, zip int);").Wait(1000);
eventHandle.WaitOne(2000);
Assert.IsNotNull(eventArgs);
Assert.IsInstanceOf <SchemaChangeEventArgs>(eventArgs);
Assert.AreEqual(SchemaChangeEventArgs.Reason.Created, (eventArgs as SchemaChangeEventArgs).What);
Assert.AreEqual("test_events_kp", (eventArgs as SchemaChangeEventArgs).Keyspace);
Assert.AreEqual("test_type", (eventArgs as SchemaChangeEventArgs).Type);
}
}
}
public void SetupFixture()
{
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("2.2.0"), Comparison.LessThan))
{
Assert.Ignore("Requires Cassandra version >= 2.2");
return;
}
Diagnostics.CassandraTraceSwitch.Level = TraceLevel.Info;
//Using a mirroring handler, the server will reply providing the same payload that was sent
var jvmArgs = new [] { "-Dcassandra.custom_query_handler_class=org.apache.cassandra.cql3.CustomPayloadMirroringQueryHandler" };
var testCluster = TestClusterManager.GetTestCluster(1, 0, false, DefaultMaxClusterCreateRetries, true, true, 0, jvmArgs);
Session = testCluster.Session;
Session.Execute(string.Format(TestUtils.CreateKeyspaceSimpleFormat, Keyspace, 1));
Session.Execute(string.Format(TestUtils.CreateTableSimpleFormat, Table));
}
public void TestFixtureSetup()
{
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("2.2"), Comparison.LessThan))
{
return;
}
_testCluster = TestClusterManager.GetTestCluster(1, 0, false, DefaultMaxClusterCreateRetries, false, false);
_testCluster.UpdateConfig("enable_user_defined_functions: true");
_testCluster.Start(1);
using (var cluster = ClusterBuilder().AddContactPoint(_testCluster.InitialContactPoint).Build())
{
var session = cluster.Connect();
var queries = new List <string>
{
"CREATE KEYSPACE ks_udf WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 1}",
"CREATE FUNCTION ks_udf.return_one() RETURNS NULL ON NULL INPUT RETURNS int LANGUAGE java AS 'return 1;'",
"CREATE FUNCTION ks_udf.plus(s int, v int) RETURNS NULL ON NULL INPUT RETURNS int LANGUAGE java AS 'return s+v;'",
"CREATE FUNCTION ks_udf.plus(s bigint, v bigint) RETURNS NULL ON NULL INPUT RETURNS bigint LANGUAGE java AS 'return s+v;'",
"CREATE AGGREGATE ks_udf.sum(int) SFUNC plus STYPE int INITCOND 1",
"CREATE AGGREGATE ks_udf.sum(bigint) SFUNC plus STYPE bigint INITCOND 2"
};
if (TestClusterManager.CheckDseVersion(new Version(6, 0), Comparison.GreaterThanOrEqualsTo))
{
queries.Add("CREATE FUNCTION ks_udf.deterministic(dividend int, divisor int) " +
"CALLED ON NULL INPUT RETURNS int DETERMINISTIC LANGUAGE java AS " +
"'return dividend / divisor;'");
queries.Add("CREATE FUNCTION ks_udf.monotonic(dividend int, divisor int) " +
"CALLED ON NULL INPUT RETURNS int MONOTONIC LANGUAGE java AS " +
"'return dividend / divisor;'");
queries.Add("CREATE FUNCTION ks_udf.md(dividend int, divisor int) " +
"CALLED ON NULL INPUT RETURNS int DETERMINISTIC MONOTONIC LANGUAGE java AS " +
"'return dividend / divisor;'");
queries.Add("CREATE FUNCTION ks_udf.monotonic_on(dividend int, divisor int) " +
"CALLED ON NULL INPUT RETURNS int MONOTONIC ON dividend LANGUAGE java AS " +
"'return dividend / divisor;'");
queries.Add("CREATE AGGREGATE ks_udf.deta(int) SFUNC plus STYPE int INITCOND 0 DETERMINISTIC;");
}
foreach (var q in queries)
{
session.Execute(q);
}
}
}
public async Task Cluster_Should_Honor_MaxProtocolVersion_Set(bool asyncConnect)
{
_testCluster = SimulacronCluster.CreateNew(2);
// Default MaxProtocolVersion
using (var clusterDefault = Cluster.Builder()
.AddContactPoint(_testCluster.InitialContactPoint)
.Build())
{
Assert.AreEqual(Cluster.MaxProtocolVersion, clusterDefault.Configuration.ProtocolOptions.MaxProtocolVersion);
// MaxProtocolVersion set
var clusterMax = Cluster.Builder()
.AddContactPoint(_testCluster.InitialContactPoint)
.WithMaxProtocolVersion(3)
.Build();
Assert.AreEqual(3, clusterMax.Configuration.ProtocolOptions.MaxProtocolVersion);
await Connect(clusterMax, asyncConnect, session =>
{
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("2.1"), Comparison.LessThan))
{
Assert.AreEqual(2, session.BinaryProtocolVersion);
}
else
{
Assert.AreEqual(3, session.BinaryProtocolVersion);
}
}).ConfigureAwait(false);
// Arbitary MaxProtocolVersion set, will negotiate down upon connect
var clusterNegotiate = Cluster.Builder()
.AddContactPoint(_testCluster.InitialContactPoint)
.WithMaxProtocolVersion(10)
.Build();
Assert.AreEqual(10, clusterNegotiate.Configuration.ProtocolOptions.MaxProtocolVersion);
await Connect(clusterNegotiate, asyncConnect, session =>
{
Assert.LessOrEqual(4, clusterNegotiate.Configuration.ProtocolOptions.MaxProtocolVersion);
}).ConfigureAwait(false);
// ProtocolVersion 0 does not exist
Assert.Throws <ArgumentException>(
() => Cluster.Builder().AddContactPoint("127.0.0.1").WithMaxProtocolVersion((byte)0));
}
}
public void SimpleStatement_With_No_Compact_Disabled_Should_Not_Reveal_Non_Schema_Columns()
{
if (TestClusterManager.CheckCassandraVersion(false, new Version(4, 0), Comparison.GreaterThanOrEqualsTo))
{
Assert.Ignore("COMPACT STORAGE is only supported by C* versions prior to 4.0");
return;
}
var builder = Cluster.Builder().AddContactPoint(TestCluster.InitialContactPoint);
using (var cluster = builder.Build())
{
var session = cluster.Connect(KeyspaceName);
var rs = session.Execute($"SELECT * FROM {TableCompactStorage} LIMIT 1");
Assert.AreEqual(3, rs.Columns.Length);
Assert.Null(rs.Columns.FirstOrDefault(c => c.Name == "column1"));
Assert.Null(rs.Columns.FirstOrDefault(c => c.Name == "value"));
}
}
public void Insert_MislabledClusteringKey()
{
string tableName = typeof(PocoWithAdditionalField).Name.ToLower();
string createTableCql = "Create table " + tableName + "(somestring text PRIMARY KEY)";
_session.Execute(createTableCql);
var cqlClient = new Mapper(_session, new MappingConfiguration());
PocoWithAdditionalField pocoWithCustomAttributes = new PocoWithAdditionalField();
// Validate expected exception
var ex = Assert.Throws <InvalidQueryException>(() => cqlClient.Insert(pocoWithCustomAttributes));
var expectedMessage = "Unknown identifier someotherstring";
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("3.10"), Comparison.GreaterThanOrEqualsTo))
{
expectedMessage = "Undefined column name someotherstring";
}
StringAssert.Contains(expectedMessage, ex.Message);
}
public void TableMetadataCassandra22Types()
{
if (TestClusterManager.CheckCassandraVersion(false, new Version(2, 2), Comparison.LessThan))
{
Assert.Ignore("Date, Time, SmallInt and TinyInt are supported in 2.2 and above");
}
var keyspaceName = TestUtils.GetUniqueKeyspaceName();
const string tableName = "tbl_cass22_types";
ITestCluster testCluster = TestClusterManager.GetNonShareableTestCluster(DefaultNodeCount);
var cluster = testCluster.Cluster;
var session = testCluster.Session;
session.CreateKeyspaceIfNotExists(keyspaceName);
session.ChangeKeyspace(keyspaceName);
session.Execute(string.Format("CREATE TABLE {0} (" +
"id uuid primary key, " +
"map1 map<smallint, date>," +
"s smallint," +
"b tinyint," +
"d date," +
"t time)", tableName));
var table = cluster.Metadata
.GetKeyspace(keyspaceName)
.GetTableMetadata(tableName);
Assert.AreEqual(6, table.TableColumns.Length);
CollectionAssert.AreEqual(table.PartitionKeys, new[] { table.TableColumns.First(c => c.Name == "id") });
var map1 = table.TableColumns.First(c => c.Name == "map1");
Assert.AreEqual(ColumnTypeCode.Map, map1.TypeCode);
Assert.IsInstanceOf <MapColumnInfo>(map1.TypeInfo);
var map1Info = (MapColumnInfo)map1.TypeInfo;
Assert.AreEqual(ColumnTypeCode.SmallInt, map1Info.KeyTypeCode);
Assert.AreEqual(ColumnTypeCode.Date, map1Info.ValueTypeCode);
Assert.AreEqual(ColumnTypeCode.SmallInt, table.TableColumns.First(c => c.Name == "s").TypeCode);
Assert.AreEqual(ColumnTypeCode.TinyInt, table.TableColumns.First(c => c.Name == "b").TypeCode);
Assert.AreEqual(ColumnTypeCode.Date, table.TableColumns.First(c => c.Name == "d").TypeCode);
Assert.AreEqual(ColumnTypeCode.Time, table.TableColumns.First(c => c.Name == "t").TypeCode);
}
public void Insert_TableNameLowerCase_PartitionKeyCamelCase()
{
// Setup
var mappingConfig = new MappingConfiguration().Define(new Map <lowercaseclassnamepkcamelcase>().PartitionKey(c => c.SomePartitionKey));
Table <lowercaseclassnamepkcamelcase> table = new Table <lowercaseclassnamepkcamelcase>(_session, mappingConfig);
Assert.AreEqual(table.Name, table.Name.ToLower());
table.Create();
var mapper = new Mapper(_session, new MappingConfiguration());
lowercaseclassnamepkcamelcase privateClassInstance = new lowercaseclassnamepkcamelcase();
// Validate state of table
mapper.Insert(privateClassInstance);
List <lowercaseclassnamepkcamelcase> instancesQueried = mapper.Fetch <lowercaseclassnamepkcamelcase>("SELECT * from " + table.Name).ToList();
Assert.AreEqual(1, instancesQueried.Count);
lowercaseclassnamepkcamelcase defaultPocoInstance = new lowercaseclassnamepkcamelcase();
Assert.AreEqual(defaultPocoInstance.SomePartitionKey, instancesQueried[0].SomePartitionKey);
// Attempt to select from Camel Case partition key
string cqlCamelCasePartitionKey = "SELECT * from " + typeof(lowercaseclassnamepkcamelcase).Name + " where \"SomePartitionKey\" = 'doesntmatter'";
var ex = Assert.Throws <InvalidQueryException>(() => _session.Execute(cqlCamelCasePartitionKey));
var expectedErrMsg = "Undefined name SomePartitionKey in where clause";
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("3.10"), Comparison.GreaterThanOrEqualsTo))
{
expectedErrMsg = "Undefined column name \"SomePartitionKey\"";
}
StringAssert.Contains(expectedErrMsg, ex.Message);
// Validate that select on lower case key does not fail
string cqlLowerCasePartitionKey = "SELECT * from " + typeof(lowercaseclassnamepkcamelcase).Name + " where \"somepartitionkey\" = '" + defaultPocoInstance.SomePartitionKey + "'";
List <Row> rows = _session.Execute(cqlLowerCasePartitionKey).GetRows().ToList();
Assert.AreEqual(1, rows.Count);
Assert.AreEqual(defaultPocoInstance.SomePartitionKey, rows[0].GetValue <string>("somepartitionkey"));
}
public void Register_For_Events()
{
var receivedEvents = new CopyOnWriteList <CassandraEventArgs>();
using (var connection = CreateConnection())
{
connection.Open().Wait();
Query(connection, string.Format("DROP KEYSPACE IF EXISTS test_events_kp", 1)).Wait();
var eventTypes = CassandraEventType.TopologyChange | CassandraEventType.StatusChange | CassandraEventType.SchemaChange;
var task = connection.Send(new RegisterForEventRequest(eventTypes));
TaskHelper.WaitToComplete(task, 1000);
Assert.IsInstanceOf <ReadyResponse>(task.Result);
connection.CassandraEventResponse += (o, e) =>
{
receivedEvents.Add(e);
};
//create a keyspace and check if gets received as an event
Query(connection, string.Format(TestUtils.CreateKeyspaceSimpleFormat, "test_events_kp", 1)).Wait(1000);
TestHelper.RetryAssert(
() =>
{
Assert.Greater(receivedEvents.Count, 0);
var evs = receivedEvents.Select(e => e as SchemaChangeEventArgs).Where(e => e != null);
var createdEvent = evs.SingleOrDefault(
e => e.What == SchemaChangeEventArgs.Reason.Created && e.Keyspace == "test_events_kp" &&
string.IsNullOrEmpty(e.Table));
Assert.IsNotNull(createdEvent, JsonConvert.SerializeObject(receivedEvents.ToArray()));
},
100,
50);
//create a table and check if gets received as an event
Query(connection, string.Format(TestUtils.CreateTableAllTypes, "test_events_kp.test_table", 1)).Wait(1000);
TestHelper.RetryAssert(
() =>
{
Assert.Greater(receivedEvents.Count, 0);
var evs = receivedEvents.Select(e => e as SchemaChangeEventArgs).Where(e => e != null);
var createdEvent = evs.SingleOrDefault(
e => e.What == SchemaChangeEventArgs.Reason.Created && e.Keyspace == "test_events_kp" &&
e.Table == "test_table");
Assert.IsNotNull(createdEvent, JsonConvert.SerializeObject(receivedEvents.ToArray()));
},
100,
50);
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("2.1"), Comparison.GreaterThanOrEqualsTo))
{
Query(connection, "CREATE TYPE test_events_kp.test_type (street text, city text, zip int);").Wait(1000);
TestHelper.RetryAssert(
() =>
{
Assert.Greater(receivedEvents.Count, 0);
var evs = receivedEvents.Select(e => e as SchemaChangeEventArgs).Where(e => e != null);
var createdEvent = evs.SingleOrDefault(
e => e.What == SchemaChangeEventArgs.Reason.Created && e.Keyspace == "test_events_kp" &&
e.Type == "test_type");
Assert.IsNotNull(createdEvent, JsonConvert.SerializeObject(receivedEvents.ToArray()));
},
100,
50);
}
}
}
public void TableMetadataNestedCollectionsTest()
{
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("2.1.3"), Comparison.LessThan))
{
Assert.Ignore("Nested frozen collections are supported in 2.1.3 and above");
return;
}
var keyspaceName = TestUtils.GetUniqueKeyspaceName();
const string tableName = "tbl_nested_cols_meta";
ITestCluster testCluster = TestClusterManager.GetNonShareableTestCluster(DefaultNodeCount);
var cluster = testCluster.Cluster;
var session = testCluster.Session;
session.CreateKeyspaceIfNotExists(keyspaceName);
session.ChangeKeyspace(keyspaceName);
session.Execute(string.Format("CREATE TABLE {0} (" +
"id uuid primary key, " +
"map1 map<varchar, frozen<list<timeuuid>>>," +
"map2 map<int, frozen<map<uuid, bigint>>>," +
"list1 list<frozen<map<uuid, int>>>)", tableName));
var table = cluster.Metadata
.GetKeyspace(keyspaceName)
.GetTableMetadata(tableName);
Assert.AreEqual(4, table.TableColumns.Length);
var map1 = table.TableColumns.First(c => c.Name == "map1");
Assert.AreEqual(ColumnTypeCode.Map, map1.TypeCode);
Assert.IsInstanceOf <MapColumnInfo>(map1.TypeInfo);
var map1Info = (MapColumnInfo)map1.TypeInfo;
Assert.True(map1Info.KeyTypeCode == ColumnTypeCode.Varchar || map1Info.KeyTypeCode == ColumnTypeCode.Text,
"Expected {0} but was {1}", ColumnTypeCode.Varchar, map1Info.KeyTypeCode);
Assert.AreEqual(ColumnTypeCode.List, map1Info.ValueTypeCode);
Assert.IsInstanceOf <ListColumnInfo>(map1Info.ValueTypeInfo);
var map1ListInfo = (ListColumnInfo)map1Info.ValueTypeInfo;
Assert.AreEqual(ColumnTypeCode.Timeuuid, map1ListInfo.ValueTypeCode);
var map2 = table.TableColumns.First(c => c.Name == "map2");
Assert.AreEqual(ColumnTypeCode.Map, map2.TypeCode);
Assert.IsInstanceOf <MapColumnInfo>(map2.TypeInfo);
var map2Info = (MapColumnInfo)map2.TypeInfo;
Assert.AreEqual(ColumnTypeCode.Int, map2Info.KeyTypeCode);
Assert.AreEqual(ColumnTypeCode.Map, map2Info.ValueTypeCode);
Assert.IsInstanceOf <MapColumnInfo>(map2Info.ValueTypeInfo);
var map2MapInfo = (MapColumnInfo)map2Info.ValueTypeInfo;
Assert.AreEqual(ColumnTypeCode.Uuid, map2MapInfo.KeyTypeCode);
Assert.AreEqual(ColumnTypeCode.Bigint, map2MapInfo.ValueTypeCode);
var list1 = table.TableColumns.First(c => c.Name == "list1");
Assert.AreEqual(ColumnTypeCode.List, list1.TypeCode);
Assert.IsInstanceOf <ListColumnInfo>(list1.TypeInfo);
var list1Info = (ListColumnInfo)list1.TypeInfo;
Assert.AreEqual(ColumnTypeCode.Map, list1Info.ValueTypeCode);
Assert.IsInstanceOf <MapColumnInfo>(list1Info.ValueTypeInfo);
var list1MapInfo = (MapColumnInfo)list1Info.ValueTypeInfo;
Assert.AreEqual(ColumnTypeCode.Uuid, list1MapInfo.KeyTypeCode);
Assert.AreEqual(ColumnTypeCode.Int, list1MapInfo.ValueTypeCode);
}
