/// <summary>
/// Insert retrived data into destination table
/// </summary>
/// <param name="server">ip or name of the destination database</param>
/// <param name="keyspace">name of the keyspace to use for the insert</param>
/// <param name="columnFamily">name of the column family for the insert</param>
/// <param name="sourceData">data retrieved from the source</param>
private static void InsertIntoDest(string server, string keyspace, string columnFamily, List <dynamic> sourceData, TransferResultsInfo info)
{
try
{
CqlConnection destConn = new CqlConnection("Contact Points=" + server, server);
CqlCommand destCmd = new CqlCommand();
destConn.Open();
destConn.ChangeDatabase(keyspace);
destCmd.Connection = destConn;
destCmd.CommandText = "SELECT COUNT(*) FROM " + columnFamily;
info.OriginalDestCount = Convert.ToInt32(destCmd.ExecuteScalar());
destCmd.InsertDynamicList(sourceData, columnFamily);
destCmd.CommandText = "SELECT COUNT(*) FROM " + columnFamily;
info.AfterDestCount = Convert.ToInt32(destCmd.ExecuteScalar());
//cleanup
destCmd.Connection.Close();
destCmd.Connection.Dispose();
destCmd.Dispose();
}
catch (Exception ex)
{
info.Message = "Error writting to destination: \r\n" + ex.Message;
}
}
public void Init()
{
const string createKsCql =
@"CREATE KEYSPACE Test WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 1} and durable_writes = 'false';";
const string createTableCql = @"create table Test.BasicFlow (id int primary key, value text);";
const string truncateTableCql = @"truncate Test.BasicFlow;";
using (var connection = new CqlConnection(ConnectionString))
{
connection.Open();
try
{
var createKs = new CqlCommand(connection, createKsCql);
createKs.ExecuteNonQuery();
}
catch (AlreadyExistsException)
{
//ignore
}
try
{
var createTable = new CqlCommand(connection, createTableCql);
createTable.ExecuteNonQuery();
}
catch (AlreadyExistsException)
{
var truncTable = new CqlCommand(connection, truncateTableCql);
truncTable.ExecuteNonQuery();
}
}
}
/// <summary>
/// Run the provided query against the source database to get the data to be moved.
/// </summary>
/// <param name="server">ip or name of the source database</param>
/// <param name="keyspace">name of the keyspace to use for the source query</param>
/// <param name="query">query to get source data</param>
/// <param name="gotSourceData">Data retrieved</param>
/// <param name="sourceData">indicator of if an error was thrown</param>
private static void GetSourceData(string server, string keyspace, string query, TransferResultsInfo info, out bool gotSourceData, out List <dynamic> sourceData)
{
sourceData = new List <dynamic>();
gotSourceData = true;
try
{
CqlConnection srcConn = new CqlConnection("Contact Points=" + server, server);
CqlCommand srcCmd = new CqlCommand();
srcConn.Open();
srcConn.ChangeDatabase(keyspace);
srcCmd.Connection = srcConn;
srcCmd.CommandType = CommandType.Text;
srcCmd.CommandText = query;
sourceData = srcCmd.ExecuteDynamics();
info.SourceCount = sourceData.Count;
//cleanup
srcCmd.Connection.Close();
srcCmd.Connection.Dispose();
srcCmd.Dispose();
}
catch (Exception ex)
{
info.Message = "Error getting source data: \r\n" + ex.Message;
gotSourceData = false;
}
}
public static void ClassInit(TestContext context)
{
using(var connection = new CqlConnection(ConnectionString))
{
connection.Open();
try
{
var createKs = new CqlCommand(connection, CreateKsCql);
createKs.ExecuteNonQuery();
}
catch(AlreadyExistsException)
{
//ignore
}
try
{
var createTable = new CqlCommand(connection, CreateTableCql);
createTable.ExecuteNonQuery();
}
catch(AlreadyExistsException)
{
//ignore
}
}
}
public static void Init(TestContext context)
{
const string createKsCql =
@"CREATE KEYSPACE Test WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 1} and durable_writes = 'false';";
const string createTableCql = @"create table Test.BasicFlow (id int primary key, value text, ignored text);";
using(var connection = new CqlConnection(ConnectionString))
{
connection.SetConnectionTimeout(0);
connection.Open();
try
{
var createKs = new CqlCommand(connection, createKsCql);
createKs.ExecuteNonQuery();
}
catch(AlreadyExistsException)
{
//ignore
}
try
{
var createTable = new CqlCommand(connection, createTableCql);
createTable.ExecuteNonQuery();
}
catch(AlreadyExistsException)
{
}
}
}
public static void ClassInit(TestContext context)
{
using (var connection = new CqlConnection(ConnectionString))
{
connection.Open();
try
{
var createKs = new CqlCommand(connection, CreateKsCql);
createKs.ExecuteNonQuery();
}
catch (AlreadyExistsException)
{
//ignore
}
try
{
var createTable = new CqlCommand(connection, CreateTableCql);
createTable.ExecuteNonQuery();
}
catch (AlreadyExistsException)
{
//ignore
}
}
}
public void ConnectToUnknownDb()
{
try
{
//Act
using(
var connection =
new CqlConnection(
"Servers=localhost;Database=DoesNotExist;username=cassandra;password=cassandra;loggerfactory=debug;loglevel=verbose")
)
{
connection.Open();
//invoke random command, as it will try to change database on the connection
var command = new CqlCommand(connection, "select * from randomTable;");
var reader = command.ExecuteReader();
reader.Dispose();
}
}
catch(Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(InvalidException));
return;
}
Assert.Fail("Exception should have been thrown;");
}
public async Task BasicFlow()
{
//Assume
const string insertCql = @"insert into Test.BasicFlow (id,value) values (?,?);";
const string retrieveCql = @"select * from Test.BasicFlow;";
const int insertCount = 1000;
//Act
using (var connection = new CqlConnection(ConnectionString))
{
await connection.OpenAsync();
var executions = new Task <ICqlQueryResult> [insertCount];
var options = new ParallelOptions()
{
MaxDegreeOfParallelism = 1
};
Parallel.For(0, insertCount, options, (i) =>
{
var cmd = new CqlCommand(connection, insertCql, CqlConsistency.One);
cmd.Prepare();
var b = new BasicFlowData {
Id = i, Data = "Hallo " + i
};
cmd.PartitionKey.Set(b);
cmd.Parameters.Set(b);
executions[i] = cmd.ExecuteNonQueryAsync();
});
await Task.WhenAll(executions);
var presence = new bool[insertCount];
var selectCmd = new CqlCommand(connection, retrieveCql, CqlConsistency.One)
{
EnableTracing = true
};
CqlDataReader <BasicFlowData> reader = await selectCmd.ExecuteReaderAsync <BasicFlowData>();
while (await reader.ReadAsync())
{
BasicFlowData row = reader.Current;
Assert.AreEqual(row.Data, "Hallo " + row.Id);
presence[row.Id] = true;
}
Assert.IsTrue(presence.All(p => p));
var tracer = new QueryTraceCommand(connection, reader.TracingId.Value);
TracingSession session = await tracer.GetTraceSessionAsync();
Assert.IsNotNull(session);
}
}
public void DefaultDatabaseSet()
{
//Act
using(var connection = new CqlConnection("Servers=localhost;Database=test2"))
{
Assert.AreEqual("test2", connection.Database);
}
}
public void TestCqlCommand()
{
var target = new CqlCommand();
// test CreateDbParameter()
var parameter = target.CreateParameter();
Assert.IsNotNull(parameter);
// test Parameters
var parameterCollection = target.Parameters;
Assert.IsNotNull(parameterCollection);
Assert.AreEqual(parameterCollection, target.Parameters);
// test Connection
var connection = new CqlConnection("contact points=127.0.0.1;port=9042");
Assert.IsNull(target.Connection);
target.Connection = connection;
Assert.AreEqual(connection, target.Connection);
// test IsPrepared
Assert.IsTrue(target.IsPrepared);
// test CommandText
var cqlQuery = "test query";
Assert.IsNull(target.CommandText);
target.CommandText = cqlQuery;
Assert.AreEqual(cqlQuery, target.CommandText);
// test CommandTimeout, it should always return -1
var timeout = 1;
Assert.AreEqual(-1, target.CommandTimeout);
target.CommandTimeout = timeout;
Assert.AreEqual(-1, target.CommandTimeout);
// test CommandType, it should always return CommandType.Text
var commandType = CommandType.TableDirect;
Assert.AreEqual(CommandType.Text, target.CommandType);
target.CommandType = commandType;
Assert.AreEqual(CommandType.Text, target.CommandType);
// test DesignTimeVisible, it should always return true
Assert.IsTrue(target.DesignTimeVisible);
target.DesignTimeVisible = false;
Assert.IsTrue(target.DesignTimeVisible);
// test UpdateRowSource, it should always return UpdateRowSource.FirstReturnedRecord
var updateRowSource = UpdateRowSource.Both;
Assert.AreEqual(UpdateRowSource.FirstReturnedRecord, target.UpdatedRowSource);
target.UpdatedRowSource = updateRowSource;
Assert.AreEqual(UpdateRowSource.FirstReturnedRecord, target.UpdatedRowSource);
}
public void Init()
{
using (var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var truncTable = new CqlCommand(connection, TruncateTableCql);
truncTable.ExecuteNonQuery();
}
}
public override void SetUp()
{
base.SetUp();
var cb = new CassandraConnectionStringBuilder
{
ContactPoints = new[] { TestCluster.InitialContactPoint.Address.ToString() },
Port = 9042
};
_connection = new CqlConnection(cb.ToString());
}
protected override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
var cb = new CassandraConnectionStringBuilder
{
ContactPoints = new[] { TestCluster.InitialContactPoint },
Port = 9042
};
_connection = new CqlConnection(cb.ToString());
}
private static DbConnection CreateConnection(Program options)
{
DbConnection cnn = null;
string cnnStr = options.ConnectionString;
if (options.Placeholders != null)
{
foreach (var entry in MapPlaceholders(options.Placeholders, options.PlaceholderPrefix, options.PlaceholderSuffix))
{
cnnStr = cnnStr.Replace(entry.Key, entry.Value);
}
}
switch (options.Database)
{
case DBMS.MySQL:
cnn = new MySqlConnection(cnnStr);
break;
case DBMS.MariaDB:
cnn = new MySqlConnection(cnnStr);
break;
case DBMS.PostgreSQL:
cnn = new NpgsqlConnection(cnnStr);
break;
case DBMS.SQLite:
cnn = new SQLiteConnection(cnnStr);
break;
case DBMS.SQLServer:
cnn = new SqlConnection(cnnStr)
{
AccessToken = options.SqlServerAccessToken
};
break;
case DBMS.Cassandra:
cnn = new CqlConnection(cnnStr);
break;
case DBMS.CockroachDB:
cnn = new NpgsqlConnection(cnnStr);
break;
default:
break;
}
return(cnn);
}
public void SetFixture()
{
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
CCMBridge.ReusableCCMCluster.Setup(2);
CCMBridge.ReusableCCMCluster.Build(Cluster.Builder());
session = CCMBridge.ReusableCCMCluster.Connect("tester");
CassandraConnectionStringBuilder cb = new CassandraConnectionStringBuilder();
cb.ContactPoints = new string[] { Options.Default.IP_PREFIX + "1" };
cb.Port = 9042;
connection = new CqlConnection(cb.ToString());
}
/// <summary>
/// Updates the cart async.
/// </summary>
/// <param name="c"> The c. </param>
/// <returns> </returns>
public async Task UpdateCartAsync(Cart c)
{
using (var connection = new CqlConnection("cartDB"))
{
await connection.OpenAsync();
var command = new CqlCommand(connection, "update Shop.Carts set groupid=?, items=? where id=?;");
await command.PrepareAsync();
command.Parameters.Set(c);
await command.ExecuteNonQueryAsync();
}
}
/// <summary>
/// Adds the items async.
/// </summary>
/// <param name="guid"> The GUID. </param>
/// <param name="items"> The items. </param>
/// <returns> </returns>
public async Task AddItemsAsync(Guid guid, Dictionary <string, int> items)
{
using (var connection = new CqlConnection("cartDB"))
{
await connection.OpenAsync();
var command = new CqlCommand(connection, "update Shop.Carts set items = items + ? where id = ?;");
await command.PrepareAsync();
command.Parameters["id"] = guid;
command.Parameters["items"] = items;
await command.ExecuteNonQueryAsync();
}
}
public static void Init(TestContext context)
{
const string createConnection = "Server=localhost;username=cassandra;password=cassandra";
const string createKsCql =
@"CREATE KEYSPACE LinqTest WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 1} and durable_writes = 'false';";
const string createTableCql =
@"create table linqtest.myvalue (id int primary key, value text, ignored text);";
using (var connection = new CqlConnection(createConnection))
{
connection.SetConnectionTimeout(0);
connection.Open();
try
{
var createKs = new CqlCommand(connection, createKsCql);
createKs.ExecuteNonQuery();
var createTable = new CqlCommand(connection, createTableCql);
createTable.ExecuteNonQuery();
using (var transaction = connection.BeginTransaction())
{
transaction.BatchType = CqlBatchType.Unlogged;
var insert = new CqlCommand(connection, "insert into linqtest.myvalue (id,value) values(?,?)");
insert.Transaction = transaction;
insert.Prepare();
for (int i = 0; i < 10000; i++)
{
insert.Parameters[0].Value = i;
insert.Parameters[1].Value = "Hallo " + i;
insert.ExecuteNonQuery();
}
transaction.Commit();
}
}
catch (AlreadyExistsException)
{
//ignore
}
}
CqlConnection.Shutdown(createConnection);
}
public static void Init(TestContext context)
{
const string createKsCql =
@"CREATE KEYSPACE TestUDT WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 1} and durable_writes = 'false';";
const string createAddressType =
@"create type TestUDT.TAddress (street text, number int);";
const string createUserType =
@"CREATE type TestUDT.TUser (name text, password blob, address frozen<TAddress>, phones list<text>);";
const string createTableCql =
@"create table TestUDT.Members (id int primary key, user frozen<TUser>, comment frozen<tuple<text,text>>);";
const string createTable2Cql =
@"create table TestUDT.Groups (id int primary key, members set<frozen<tuple<int, frozen<TUser>>>>);";
using(var connection = new CqlConnection(ConnectionString))
{
connection.SetConnectionTimeout(0);
connection.Open();
Cassandra210OrUp = string.CompareOrdinal(connection.ServerVersion, "2.1.0") >= 0;
if(!Cassandra210OrUp)
return;
try
{
var createKs = new CqlCommand(connection, createKsCql);
createKs.ExecuteNonQuery();
var createAddress = new CqlCommand(connection, createAddressType);
createAddress.ExecuteNonQuery();
var createUser = new CqlCommand(connection, createUserType);
createUser.ExecuteNonQuery();
var createTable = new CqlCommand(connection, createTableCql);
createTable.ExecuteNonQuery();
var createTable2 = new CqlCommand(connection, createTable2Cql);
createTable2.ExecuteNonQuery();
}
catch(AlreadyExistsException)
{
}
}
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
var host = "127.0.0.1";
if (TestUtils.UseRemoteCcm)
{
host = Options.Default.IP_PREFIX + "1";
}
var cb = new CassandraConnectionStringBuilder();
cb.ContactPoints = new[] { host };
cb.Port = 9042;
_connection = new CqlConnection(cb.ToString());
}
/// <summary>
/// Queries the cart async.
/// </summary>
/// <param name="guid"> The GUID. </param>
/// <returns> </returns>
public async Task <Dictionary <string, int> > GetItemsAsync(Guid guid)
{
using (var connection = new CqlConnection("cartDB"))
{
await connection.OpenAsync();
var command = new CqlCommand(connection, "select Items from Shop.Carts where id=?;");
await command.PrepareAsync();
command.UseBuffering = true;
command.Parameters["id"] = guid;
using (var reader = await command.ExecuteReaderAsync())
{
return(await reader.ReadAsync() ? (Dictionary <string, int>)reader["items"] : null);
}
}
}
static void SetupDatabase()
{
const string createKsCql =
@"CREATE KEYSPACE linqperftest WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 1} and durable_writes = 'false';";
const string createTableCql =
@"create table linqperftest.myvalue (id int primary key, value text, ignored text);";
using (var connection = new CqlConnection(ConnectionString))
{
connection.Open();
try
{
var createKs = new CqlCommand(connection, createKsCql);
createKs.ExecuteNonQuery();
var createTable = new CqlCommand(connection, createTableCql);
createTable.ExecuteNonQuery();
using (var transaction = connection.BeginTransaction())
{
transaction.BatchType = CqlBatchType.Unlogged;
var insert = new CqlCommand(connection, "insert into linqperftest.myvalue (id,value) values(?,?)");
insert.Transaction = transaction;
insert.Prepare();
for (int i = 0; i < 10000; i++)
{
insert.Parameters[0].Value = i;
insert.Parameters[1].Value = "Hallo " + i;
insert.ExecuteNonQuery();
}
transaction.Commit();
}
}
catch (AlreadyExistsException)
{
}
}
}
/// <summary>
/// Prepares the db async.
/// </summary>
/// <returns> </returns>
public async Task PrepareDbAsync()
{
using (var connection = new CqlConnection("cartDB"))
{
await connection.OpenAsync();
try
{
var shopExistCommand = new CqlCommand(connection,
"select * from system.schema_keyspaces where keyspace_name='shop';");
using (var reader = shopExistCommand.ExecuteReader())
{
if (reader.HasRows)
{
var dropKs = new CqlCommand(connection, @"DROP KEYSPACE Shop;");
await dropKs.ExecuteNonQueryAsync();
}
}
}
catch (AlreadyExistsException)
{
//ignore
}
try
{
//create the keyspace if it does not exist
var createKs = new CqlCommand(connection,
@"CREATE KEYSPACE Shop WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 1} and durable_writes = 'false';");
await createKs.ExecuteNonQueryAsync();
//create the table
var createTable = new CqlCommand(connection,
@"create table Shop.Carts (id uuid primary key, groupId text, items map<text, int>);");
await createTable.ExecuteNonQueryAsync();
//create corresponding index
var createIndex = new CqlCommand(connection, @"create index on Shop.Carts(GroupId)");
await createIndex.ExecuteNonQueryAsync();
}
catch (AlreadyExistsException)
{
}
}
}
public static void Cleanup()
{
const string dropCql = @"drop keyspace Test;";
using (var connection = new CqlConnection(ConnectionString))
{
connection.Open();
try
{
var drop = new CqlCommand(connection, dropCql);
drop.ExecuteNonQuery();
}
catch (InvalidException)
{
//ignore
}
}
}
/// <summary>
/// Creates the cart async.
/// </summary>
/// <returns> </returns>
public async Task <Cart> AddCartAsync(string groupId)
{
var c = new Cart {
Id = Guid.NewGuid(), GroupId = groupId
};
using (var connection = new CqlConnection("cartDB"))
{
await connection.OpenAsync();
var command = new CqlCommand(connection, "insert into Shop.Carts (id, groupId) values (?,?);");
await command.PrepareAsync();
command.Parameters.Set(c);
await command.ExecuteNonQueryAsync();
return(c);
}
}
public void NullableDeserializeTest()
{
const string insertCql = @"insert into Test.Types(aInt) values (4);";
const string selectCql = "select * from Test.Types limit 1;";
using (var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.ExecuteNonQuery();
var selectCmd = new CqlCommand(connection, selectCql);
NullableTypes result = null;
using (var reader = selectCmd.ExecuteReader <NullableTypes>())
{
if (reader.Read())
{
result = reader.Current;
}
}
Assert.IsNotNull(result);
Assert.IsNull(result.aASCIIString);
Assert.IsNull(result.aVarcharString);
Assert.IsNull(result.aVarint);
Assert.IsNull(result.aTextString);
Assert.IsNull(result.aBool);
Assert.IsNull(result.aDouble);
Assert.IsNull(result.aFloat);
Assert.IsNull(result.aInet);
Assert.IsNull(result.aLong);
Assert.IsNull(result.aTimeUUID);
Assert.IsNull(result.aUUID);
Assert.IsNull(result.aBlob);
Assert.IsNull(result.aList);
Assert.IsNull(result.aSet);
Assert.IsNull(result.aMap);
}
}
public void DefaultDeserializeTest()
{
const string insertCql = @"insert into Test.Types(aInt) values (1);";
const string selectCql = "select * from Test.Types limit 1;";
using (var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.ExecuteNonQuery();
var selectCmd = new CqlCommand(connection, selectCql);
Types result = null;
using (var reader = selectCmd.ExecuteReader <Types>())
{
if (reader.Read())
{
result = reader.Current;
}
}
Assert.IsNotNull(result);
Assert.AreEqual(result.aASCIIString, default(string));
Assert.AreEqual(result.aVarcharString, default(string));
Assert.AreEqual(result.aVarint, default(BigInteger));
Assert.AreEqual(result.aTextString, default(string));
Assert.AreEqual(result.aBool, default(bool));
Assert.AreEqual(result.aDouble, default(double));
Assert.AreEqual(result.aFloat, default(float));
Assert.AreEqual(result.aInet, default(IPAddress));
Assert.AreEqual(result.aLong, default(long));
Assert.AreEqual(result.aTimeUUID, default(Guid));
Assert.AreEqual(result.aUUID, default(Guid));
Assert.AreEqual(result.aBlob, default(byte[]));
Assert.AreEqual(result.aList, default(List <string>));
Assert.AreEqual(result.aSet, default(HashSet <int>));
Assert.AreEqual(result.aMap, default(Dictionary <long, string>));
}
}
public void CommandExecuteReaderUsesSyncExecute()
{
var connection = new CqlConnection();
var sessionMock = new Mock <ISession>();
var rowset = new RowSet();
sessionMock
.Setup(s => s.Execute(It.IsAny <string>(), It.IsAny <ConsistencyLevel>()))
.Returns(rowset)
.Verifiable();
connection.ManagedConnection = sessionMock.Object;
var cmd = (CqlCommand)connection.CreateCommand();
cmd.CommandText = "INSERT INTO dummy_cf (a,b) VALUES (1,2)";
var reader = cmd.ExecuteReader();
reader.Dispose();
sessionMock.Verify();
}
public static void Cleanup()
{
const string dropCql = @"drop keyspace Test;";
using(var connection = new CqlConnection(ConnectionString))
{
connection.Open();
try
{
var drop = new CqlCommand(connection, dropCql);
drop.ExecuteNonQuery();
}
catch(InvalidException)
{
//ignore
}
}
CqlConnection.ShutdownAll();
}
private static IDbConnection CreateConnection(DBMS database, string cnnStr)
{
IDbConnection cnn = null;
switch (database)
{
case DBMS.MySQL:
cnn = new MySqlConnection(cnnStr);
break;
case DBMS.MariaDB:
cnn = new MySqlConnection(cnnStr);
break;
case DBMS.PostgreSQL:
cnn = new NpgsqlConnection(cnnStr);
break;
case DBMS.SQLite:
cnn = new SQLiteConnection(cnnStr);
break;
case DBMS.SQLServer:
cnn = new SqlConnection(cnnStr);
break;
case DBMS.Cassandra:
cnn = new CqlConnection(cnnStr);
break;
case DBMS.CockroachDB:
cnn = new NpgsqlConnection(cnnStr);
break;
default:
break;
}
return(cnn);
}
/// <summary>
/// Finds the carts by group id async.
/// </summary>
/// <param name="groupId"> The group id. </param>
/// <returns> </returns>
public async Task <List <Cart> > FindCartsByGroupIdAsync(string groupId)
{
using (var connection = new CqlConnection("cartDB"))
{
await connection.OpenAsync();
var command = new CqlCommand(connection, "select * from Shop.Carts where GroupId=?;");
await command.PrepareAsync();
command.UseBuffering = true;
command.Parameters["groupid"] = groupId;
using (var reader = await command.ExecuteReaderAsync <Cart>())
{
var carts = new List <Cart>();
while (await reader.ReadAsync())
{
carts.Add(reader.Current);
}
return(carts);
}
}
}
public void AuthenticateError()
{
try
{
using(
var connection =
new CqlConnection(
"Servers=localhost;username=doesNotExist;password=too;loggerfactory=debug;loglevel=verbose")
)
{
connection.Open();
}
}
catch(AuthenticationException uex)
{
Debug.WriteLine("Expected Unauthenticated exception: {0}", uex);
}
catch(Exception ex)
{
Assert.Fail("Wrong exception thrown: {0}", ex.GetType().Name);
}
}
public async Task Issue15()
{
using(ShimsContext.Create())
{
//Assume
//make DateTime.Now return a value in a different timezone
ShimDateTime.NowGet = () =>
{
var timezone = TimeZoneInfo.CreateCustomTimeZone("Issue15Zone",
TimeSpan.FromHours(-5),
"Issue 15 zone",
"Issue 15 zone");
return TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, timezone);
};
//Act
using(var connection = new CqlConnection(ConnectionString))
{
await connection.OpenAsync();
}
}
}
public void DefaultSerializeTest()
{
const string insertCql = @"insert into Test.Types(
aInt,
aLong ,
aVarint ,
aTextString ,
aVarcharString ,
aASCIIString ,
aBlob ,
aBool ,
aDouble ,
aFloat ,
aTimestamp ,
aTimeUUID ,
aUUID ,
aInet ,
aList,
aSet,
aMap)
values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
const string selectCql = "select * from Test.Types limit 1;";
using (var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var values = new Types
{
aInt = 2,
aASCIIString = default(string),
aBlob = default(byte[]),
aBool = default(bool),
aDouble = default(double),
aFloat = default(float),
aInet = default(IPAddress),
aLong = default(long),
aTextString = default(string),
aVarcharString = default(string),
aTimeUUID = default(Guid),
aUUID = default(Guid),
aTimestamp = default(DateTime),
aVarint = default(BigInteger),
aList = default(List <string>),
aSet = default(HashSet <int>),
aMap = default(Dictionary <long, string>)
};
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.Prepare();
insertCmd.Parameters.Set(values);
insertCmd.ExecuteNonQuery();
var selectCmd = new CqlCommand(connection, selectCql);
Types result = null;
using (var reader = selectCmd.ExecuteReader <Types>())
{
if (reader.Read())
{
result = reader.Current;
}
}
Assert.IsNotNull(result);
Assert.AreEqual(result.aASCIIString, default(string));
Assert.AreEqual(result.aVarcharString, default(string));
Assert.AreEqual(result.aVarint, default(BigInteger));
Assert.AreEqual(result.aTextString, default(string));
Assert.AreEqual(result.aBool, default(bool));
Assert.AreEqual(result.aDouble, default(double));
Assert.AreEqual(result.aFloat, default(float));
Assert.AreEqual(result.aInet, default(IPAddress));
Assert.AreEqual(result.aLong, default(long));
Assert.AreEqual(result.aTimeUUID, default(Guid));
Assert.AreEqual(result.aUUID, default(Guid));
Assert.AreEqual(result.aBlob, default(byte[]));
Assert.AreEqual(result.aList, default(List <string>));
Assert.AreEqual(result.aSet, default(HashSet <int>));
Assert.AreEqual(result.aMap, default(Dictionary <long, string>));
}
}
public void Run_all_Cassandra_integration_tests_work()
{
// Open a connection to Cassandra
var cnn = new CqlConnection($"Contact Points=127.0.0.1;Port={_cassandraFixture.Cassandra.HostPort};Cluster Name={_cassandraFixture.Cassandra.ClusterName}");
cnn.Open();
Assert.True(cnn.State == ConnectionState.Open, "Cannot open a connection to Cassandra.");
// Initiate a connection to the database
var wcnn = new WrappedConnection(cnn);
// Validate DBMS.Cassandra
Assert.Equal(DBMS.Cassandra, wcnn.GetDatabaseServerType());
// Init the DatabaseHelper
var db = DatabaseHelperFactory.GetDatabaseHelper(DBMS.Cassandra, wcnn);
// Create schema
string metadataKeyspaceName = "my_metadata_keyspace";
Schema metadataSchema = new CassandraKeyspace(metadataKeyspaceName, CassandraKeyspace.CreateSimpleStrategy(1), wcnn);
Assert.False(metadataSchema.IsExists(), $"The schema [{metadataKeyspaceName}] should not already exist.");
Assert.True(metadataSchema.Create(), $"Creation of the schema [{metadataKeyspaceName}] failed.");
Assert.True(metadataSchema.IsExists(), $"The schema [{metadataKeyspaceName}] should be created.");
Assert.True(metadataSchema.IsEmpty(), $"The schema [{metadataKeyspaceName}] should be empty.");
var s = db.GetSchema("my_metadata_keyspace");
// Get MetadataTable
string metadataTableName = "change_log";
var metadata = db.GetMetadataTable(metadataKeyspaceName, metadataTableName);
// Create MetadataTable
Assert.False(metadata.IsExists(), "MetadataTable sould not already exist.");
Assert.True(metadata.CreateIfNotExists(), "MetadataTable creation failed.");
Assert.True(metadata.IsExists(), "MetadataTable sould exist.");
Assert.False(metadata.CreateIfNotExists(), "MetadataTable already exists. Creation should return false.");
Assert.True(metadata.GetAllMigrationMetadata().Count() == 0, "No migration metadata should be found.");
// Lock MetadataTable
metadata.Lock();
// Save NewSchema metadata
metadata.Save(MetadataType.NewSchema, "0", "New schema created.", metadataKeyspaceName);
Assert.True(metadata.CanDropSchema(metadataKeyspaceName), $"[{metadataKeyspaceName}] should be droppable.");
Assert.False(metadata.CanEraseSchema(metadataKeyspaceName), $"[{metadataKeyspaceName}] should not be erasable.");
// Add metadata migration
var migrationScript = new FileMigrationScript(TestContext.EmptyMigrationScriptPath, "1_3_2", "Migration_description");
metadata.SaveMigration(migrationScript, true);
var migrationMetadata = metadata.GetAllMigrationMetadata().FirstOrDefault();
Assert.True(migrationMetadata != null, "One migration metadata should be found.");
Assert.True(migrationMetadata.Version == migrationScript.Version, "Metadata version is not the same.");
Assert.True(migrationMetadata.Checksum == migrationScript.CalculateChecksum(), "Metadata checksum is not the same.");
Assert.True(migrationMetadata.Description == migrationScript.Description, "Metadata descritpion is not the same.");
Assert.True(migrationMetadata.Name == migrationScript.Name, "Metadata name is not the same.");
Assert.True(migrationMetadata.Success == true, "Metadata success is not true.");
Assert.True(migrationMetadata.Id != 0, "Metadata id is not set.");
Assert.True(migrationMetadata.InstalledOn.Date == DateTime.UtcNow.Date, $"Installed date is {migrationMetadata.InstalledOn.Date} whereas UtcNow is {DateTime.UtcNow.Date}.");
// Update checksum
metadata.UpdateChecksum(migrationMetadata.Id, "Hi !");
Assert.Equal("Hi !", metadata.GetAllMigrationMetadata().First().Checksum);
// Assert metadata schema is not empty
Assert.False(metadataSchema.IsEmpty(), $"[{metadataKeyspaceName}] should not be empty.");
// Erase schema
metadataSchema.Erase();
Assert.True(metadataSchema.IsEmpty(), $"The schema [{metadataKeyspaceName}] should be empty.");
Assert.True(metadataSchema.IsExists(), $"The schema [{metadataKeyspaceName}] should exist.");
// Drop schema
metadataSchema.Drop();
Assert.False(metadataSchema.IsExists(), $"The schema [{metadataKeyspaceName}] should not exist.");
}
public void SerializeInOutTest()
{
const string insertCql = @"insert into SerializationTest.Types(
aInt,
aLong ,
aVarint ,
aTextString ,
aVarcharString ,
aASCIIString ,
aBlob ,
aBool ,
aDecimal ,
aDouble ,
aFloat ,
aTimestamp ,
aTimeUUID ,
aUUID ,
aInet ,
aList,
aSet,
aMap)
values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
const string selectCql = "select * from SerializationTest.Types limit 1;";
using(var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.Prepare();
insertCmd.Parameters["aasciistring"].Value = "hello world!";
insertCmd.Parameters["ablob"].Value = new byte[] {1, 2, 3, 4};
insertCmd.Parameters["abool"].Value = true;
insertCmd.Parameters["adecimal"].Value = -1234567890.0987654321m;
insertCmd.Parameters["adouble"].Value = 1.234;
insertCmd.Parameters["afloat"].Value = 5.789f;
insertCmd.Parameters["ainet"].Value = new IPAddress(new byte[] {127, 0, 0, 1});
insertCmd.Parameters["aint"].Value = 10;
insertCmd.Parameters["along"].Value = 56789012456;
insertCmd.Parameters["atextstring"].Value = "some other text with \u005C unicode";
insertCmd.Parameters["avarcharstring"].Value = "some other varchar with \u005C unicode";
insertCmd.Parameters["atimeuuid"].Value = DateTime.Now.GenerateTimeBasedGuid();
insertCmd.Parameters["auuid"].Value = Guid.NewGuid();
insertCmd.Parameters["atimestamp"].Value = DateTime.Now;
insertCmd.Parameters["avarint"].Value = new BigInteger(12345678901234);
insertCmd.Parameters["alist"].Value = new List<string> {"string 1", "string 2"};
insertCmd.Parameters["aset"].Value = new HashSet<int> {1, 3, 3};
insertCmd.Parameters["amap"].Value =
new Dictionary<long, string> {{1, "value 1"}, {2, "value 2"}, {3, "value 3"}};
insertCmd.ExecuteNonQuery();
string aAsciiString;
string aVarcharString;
BigInteger aVarint;
string aTextString;
bool aBool;
decimal aDecimal;
double aDouble;
float aFloat;
IPAddress aInet;
long aLong;
Guid aTimeUUID;
Guid aUUID;
byte[] aBlob;
List<string> aList;
HashSet<int> aSet;
Dictionary<long, string> aMap;
var selectCmd = new CqlCommand(connection, selectCql);
using(var reader = selectCmd.ExecuteReader())
{
if(reader.Read())
{
aAsciiString = reader.GetString(reader.GetOrdinal("aasciistring"));
aVarcharString = reader.GetString(reader.GetOrdinal("avarcharstring"));
aVarint = reader.GetBigInteger(reader.GetOrdinal("avarint"));
aTextString = reader.GetString(reader.GetOrdinal("atextstring"));
aBool = reader.GetBoolean(reader.GetOrdinal("abool"));
aDecimal = reader.GetDecimal(reader.GetOrdinal("adecimal"));
aDouble = reader.GetDouble(reader.GetOrdinal("adouble"));
aFloat = reader.GetFloat(reader.GetOrdinal("afloat"));
aInet = reader.GetIPAddress(reader.GetOrdinal("ainet"));
aLong = reader.GetInt64(reader.GetOrdinal("along"));
aTimeUUID = reader.GetGuid(reader.GetOrdinal("atimeuuid"));
aUUID = reader.GetGuid(reader.GetOrdinal("auuid"));
aBlob = reader.GetBytes(reader.GetOrdinal("ablob"));
aList = reader.GetList<string>(reader.GetOrdinal("alist"));
aSet = reader.GetSet<int>(reader.GetOrdinal("aset"));
aMap = reader.GetDictionary<long, string>(reader.GetOrdinal("amap"));
}
else
throw new Exception("No row returned!");
}
Assert.AreEqual(insertCmd.Parameters["aasciistring"].Value, aAsciiString);
Assert.AreEqual(insertCmd.Parameters["avarcharstring"].Value, aVarcharString);
Assert.AreEqual(insertCmd.Parameters["avarint"].Value, aVarint);
Assert.AreEqual(insertCmd.Parameters["atextstring"].Value, aTextString);
Assert.AreEqual(insertCmd.Parameters["abool"].Value, aBool);
Assert.AreEqual(insertCmd.Parameters["adecimal"].Value, aDecimal);
Assert.AreEqual(insertCmd.Parameters["adouble"].Value, aDouble);
Assert.AreEqual(insertCmd.Parameters["afloat"].Value, aFloat);
Assert.AreEqual(insertCmd.Parameters["ainet"].Value, aInet);
Assert.AreEqual(insertCmd.Parameters["along"].Value, aLong);
Assert.AreEqual(insertCmd.Parameters["atimeuuid"].Value, aTimeUUID);
Assert.AreEqual(insertCmd.Parameters["auuid"].Value, aUUID);
Assert.IsTrue(((byte[])insertCmd.Parameters["ablob"].Value).SequenceEqual(aBlob));
Assert.IsTrue(((List<string>)insertCmd.Parameters["alist"].Value).SequenceEqual(aList));
Assert.IsTrue(((HashSet<int>)insertCmd.Parameters["aset"].Value).SequenceEqual(aSet));
foreach(var entry in ((Dictionary<long, string>)insertCmd.Parameters["amap"].Value))
{
var val = aMap[entry.Key];
Assert.AreEqual(entry.Value, val);
}
}
}
public async Task PrepareTracing()
{
//Assume
const string insertCql = @"insert into Test.BasicFlow (id,value) values (542,'Hallo 542');";
//Act
using(var connection = new CqlConnection(ConnectionString))
{
await connection.OpenAsync();
//insert data
var cmd = new CqlCommand(connection, insertCql, CqlConsistency.One);
cmd.EnableTracing = true;
await cmd.PrepareAsync();
Assert.IsInstanceOfType(cmd.LastQueryResult, typeof(CqlPrepared));
Assert.IsTrue(cmd.LastQueryResult.TracingId.HasValue, "Expected a tracing id");
var tracer = new QueryTraceCommand(connection, cmd.LastQueryResult.TracingId.Value);
TracingSession session = await tracer.GetTraceSessionAsync(CancellationToken.None);
Assert.IsNotNull(session);
}
}
public async Task ErrorResult()
{
//Assume
const string insertCql = @"insert into Test.UnknownTable (id,value) values (1,'Hallo 1');";
//Act
using(var connection = new CqlConnection(ConnectionString))
{
await connection.OpenAsync();
//insert data
var cmd = new CqlCommand(connection, insertCql, CqlConsistency.One);
cmd.EnableTracing = true;
try
{
await cmd.ExecuteNonQueryAsync();
Assert.Fail("Should have thrown exception!");
}
catch(ProtocolException pex)
{
Assert.IsInstanceOfType(pex, typeof(InvalidException));
Assert.IsInstanceOfType(cmd.LastQueryResult, typeof(CqlError));
Assert.AreEqual(((CqlError)cmd.LastQueryResult).Exception, pex,
"CqlError does not contain thrown exception");
Assert.AreEqual(pex.TracingId, cmd.LastQueryResult.TracingId);
}
}
}
public void BasicFlowAdo()
{
//Assume
const string insertCql = @"insert into Test.BasicFlow (id,value) values (?,?);";
const string retrieveCql = @"select id,value,ignored from Test.BasicFlow;";
//Act
using(IDbConnection connection = new CqlConnection(ConnectionString))
{
connection.Open();
IDbCommand cmd = new CqlCommand(connection, insertCql, CqlConsistency.One);
cmd.Parameters.Add(new CqlParameter("id", CqlType.Int));
cmd.Parameters.Add(new CqlParameter("value", CqlType.Text));
cmd.Prepare();
((IDbDataParameter)cmd.Parameters["id"]).Value = 456;
((IDbDataParameter)cmd.Parameters["value"]).Value = "Hallo 456";
cmd.ExecuteNonQuery();
IDbCommand selectCmd = new CqlCommand(connection, retrieveCql, CqlConsistency.One)
{
EnableTracing = true
};
IDataReader reader = selectCmd.ExecuteReader();
DataTable schema = reader.GetSchemaTable();
Assert.AreEqual(3, schema.Rows.Count);
Assert.IsTrue(
schema.Rows.Cast<DataRow>().Any(row => row[CqlSchemaTableColumnNames.ColumnName].Equals("ignored")));
if(reader.Read())
{
int id = reader.GetInt32(0);
string value = reader.GetString(1);
Assert.AreEqual(456, id);
Assert.IsTrue(reader.IsDBNull(2));
Assert.AreEqual("Hallo 456", value);
}
else
Assert.Fail("Read should have succeeded");
}
}
public void Init()
{
using(var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var truncTable = new CqlCommand(connection, TruncateTableCql);
truncTable.ExecuteNonQuery();
}
}
public void NullDeserializeParameterTest()
{
const string insertCql = @"insert into Test.Types(aInt) values (1);";
const string selectCql = "select * from Test.Types limit 1;";
using (var connection = new CqlConnection(ConnectionString))
{
string aASCIIString;
string aVarcharString;
BigInteger? aVarint;
string aTextString;
bool? aBool;
double? aDouble;
float? aFloat;
IPAddress aInet;
long? aLong;
Guid? aTimeUUID;
Guid? aUUID;
byte[] aBlob;
List <string> aList;
HashSet <int> aSet;
Dictionary <long, string> aMap;
connection.Open();
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.ExecuteNonQuery();
var selectCmd = new CqlCommand(connection, selectCql);
using (var reader = selectCmd.ExecuteReader())
{
if (reader.Read())
{
aASCIIString = (string)reader["aasciistring"];
aVarcharString = (string)reader["avarcharstring"];
aVarint = (BigInteger?)reader["avarint"];
aTextString = (string)reader["atextstring"];
aBool = (bool?)reader["abool"];
aDouble = (double?)reader["adouble"];
aFloat = (float?)reader["afloat"];
aInet = (IPAddress)reader["ainet"];
aLong = (long?)reader["along"];
aTimeUUID = (Guid?)reader["atimeuuid"];
aUUID = (Guid?)reader["auuid"];
aBlob = (byte[])reader["ablob"];
aList = (List <string>)reader["alist"];
aSet = (HashSet <int>)reader["aset"];
aMap = (Dictionary <long, string>)reader["amap"];
}
else
{
throw new Exception("No row returned!");
}
}
Assert.AreEqual(aASCIIString, default(string));
Assert.AreEqual(aVarcharString, default(string));
Assert.AreEqual(aVarint, default(BigInteger?));
Assert.AreEqual(aTextString, default(string));
Assert.AreEqual(aBool, default(bool?));
Assert.AreEqual(aDouble, default(double?));
Assert.AreEqual(aFloat, default(float?));
Assert.AreEqual(aInet, default(IPAddress));
Assert.AreEqual(aLong, default(long?));
Assert.AreEqual(aTimeUUID, default(Guid?));
Assert.AreEqual(aUUID, default(Guid?));
Assert.AreEqual(aBlob, default(byte[]));
Assert.AreEqual(aList, default(List <string>));
Assert.AreEqual(aSet, default(HashSet <int>));
Assert.AreEqual(aMap, default(Dictionary <long, string>));
}
}
public void SerializeObjectOutNullTest()
{
const string insertCql = @"insert into SerializationTest.Types(aInt) values (4);";
const string selectCql = "select * from SerializationTest.Types limit 1;";
using(var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.ExecuteNonQuery();
var selectCmd = new CqlCommand(connection, selectCql);
NullableTypes result = null;
using(var reader = selectCmd.ExecuteReader<NullableTypes>())
{
if(reader.Read())
result = reader.Current;
}
Assert.IsNotNull(result);
Assert.IsNull(result.aASCIIString);
Assert.IsNull(result.aVarcharString);
Assert.IsNull(result.aVarint);
Assert.IsNull(result.aTextString);
Assert.IsNull(result.aBool);
Assert.IsNull(result.aDecimal);
Assert.IsNull(result.aDouble);
Assert.IsNull(result.aFloat);
Assert.IsNull(result.aInet);
Assert.IsNull(result.aLong);
Assert.IsNull(result.aTimeUUID);
Assert.IsNull(result.aUUID);
Assert.IsNull(result.aBlob);
Assert.IsNull(result.aList);
Assert.IsNull(result.aSet);
Assert.IsNull(result.aMap);
}
}
public void SerializeObjectInOutNullTest()
{
const string insertCql = @"insert into SerializationTest.Types(
aInt,
aLong ,
aVarint ,
aTextString ,
aVarcharString ,
aASCIIString ,
aBlob ,
aBool ,
aDecimal ,
aDouble ,
aFloat ,
aTimestamp ,
aTimeUUID ,
aUUID ,
aInet ,
aList,
aSet,
aMap)
values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
const string selectCql = "select * from SerializationTest.Types limit 1;";
using(var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var values = new NullableTypes
{
aInt = 3,
aASCIIString = null,
aBlob = null,
aBool = null,
aDecimal = null,
aDouble = null,
aFloat = null,
aInet = null,
aLong = null,
aTextString = null,
aVarcharString = null,
aTimeUUID = null,
aUUID = null,
aTimestamp = null,
aVarint = null,
aList = null,
aSet = null,
aMap = null
};
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.Prepare();
insertCmd.Parameters.Set(values);
insertCmd.ExecuteNonQuery();
var selectCmd = new CqlCommand(connection, selectCql);
NullableTypes result = null;
using(var reader = selectCmd.ExecuteReader<NullableTypes>())
{
if(reader.Read())
result = reader.Current;
}
Assert.IsNotNull(result);
Assert.IsNull(result.aASCIIString);
Assert.IsNull(result.aVarcharString);
Assert.IsNull(result.aVarint);
Assert.IsNull(result.aTextString);
Assert.IsNull(result.aBool);
Assert.IsNull(result.aDecimal);
Assert.IsNull(result.aDouble);
Assert.IsNull(result.aFloat);
Assert.IsNull(result.aInet);
Assert.IsNull(result.aLong);
Assert.IsNull(result.aTimeUUID);
Assert.IsNull(result.aUUID);
Assert.IsNull(result.aBlob);
Assert.IsNull(result.aList);
Assert.IsNull(result.aSet);
Assert.IsNull(result.aMap);
}
}
public void SerializeObjectInOutTest()
{
const string insertCql = @"insert into SerializationTest.Types(
aInt,
aLong ,
aVarint ,
aTextString ,
aVarcharString ,
aASCIIString ,
aBlob ,
aBool ,
aDecimal ,
aDouble ,
aFloat ,
aTimestamp ,
aTimeUUID ,
aUUID ,
aInet ,
aList,
aSet,
aMap)
values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
const string selectCql = "select * from SerializationTest.Types limit 1;";
using(var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var values = new Types
{
aASCIIString = "hello world!",
aBlob = new byte[] {1, 2, 3, 4},
aBool = true,
aDecimal = decimal.MaxValue/2,
aDouble = 1.234,
aFloat = 5.789f,
aInet = new IPAddress(new byte[] {127, 0, 0, 1}),
aInt = 10,
aLong = 56789012456,
aTextString = "some other text with \u005C unicode",
aVarcharString = "some other varchar with \u005C unicode",
aTimeUUID = DateTime.Now.GenerateTimeBasedGuid(),
aUUID = Guid.NewGuid(),
aTimestamp = DateTime.Now,
aVarint = new BigInteger(12345678901234),
aList = new List<string> {"string 1", "string 2"},
aSet = new HashSet<int> {1, 3, 3},
aMap =
new Dictionary<long, string> {{1, "value 1"}, {2, "value 2"}, {3, "value 3"}},
};
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.Prepare();
insertCmd.Parameters.Set(values);
insertCmd.ExecuteNonQuery();
var selectCmd = new CqlCommand(connection, selectCql);
Types result = null;
using(var reader = selectCmd.ExecuteReader<Types>())
{
if(reader.Read())
result = reader.Current;
}
Assert.IsNotNull(result);
Assert.AreEqual(values.aASCIIString, result.aASCIIString);
Assert.AreEqual(values.aVarcharString, result.aVarcharString);
Assert.AreEqual(values.aVarint, result.aVarint);
Assert.AreEqual(values.aTextString, result.aTextString);
Assert.AreEqual(values.aBool, result.aBool);
Assert.AreEqual(values.aDecimal, result.aDecimal);
Assert.AreEqual(values.aDouble, result.aDouble);
Assert.AreEqual(values.aFloat, result.aFloat);
Assert.AreEqual(values.aInet, result.aInet);
Assert.AreEqual(values.aInt, result.aInt);
Assert.AreEqual(values.aLong, result.aLong);
Assert.AreEqual(values.aTimeUUID, result.aTimeUUID);
Assert.AreEqual(values.aUUID, result.aUUID);
Assert.IsTrue(result.aBlob.SequenceEqual(values.aBlob));
Assert.IsTrue(result.aList.SequenceEqual(values.aList));
Assert.IsTrue(result.aSet.SequenceEqual(values.aSet));
}
}
public void SerializeObjectInOutDefaultsTest()
{
const string insertCql = @"insert into SerializationTest.Types(
aInt,
aLong ,
aVarint ,
aTextString ,
aVarcharString ,
aASCIIString ,
aBlob ,
aBool ,
aDecimal ,
aDouble ,
aFloat ,
aTimestamp ,
aTimeUUID ,
aUUID ,
aInet ,
aList,
aSet,
aMap)
values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
const string selectCql = "select * from SerializationTest.Types limit 1;";
using(var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var values = new Types
{
aInt = 2,
aASCIIString = default(string),
aBlob = default(byte[]),
aBool = default(bool),
aDecimal = default(decimal),
aDouble = default(double),
aFloat = default(float),
aInet = default(IPAddress),
aLong = default(long),
aTextString = default(string),
aVarcharString = default(string),
aTimeUUID = TimeGuid.Default,
aUUID = default(Guid),
aTimestamp = default(DateTime),
aVarint = default(BigInteger),
aList = default(List<string>),
aSet = default(HashSet<int>),
aMap = default(Dictionary<long, string>)
};
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.Prepare();
insertCmd.Parameters.Set(values);
insertCmd.ExecuteNonQuery();
var selectCmd = new CqlCommand(connection, selectCql);
Types result = null;
using(var reader = selectCmd.ExecuteReader<Types>())
{
if(reader.Read())
result = reader.Current;
}
Assert.IsNotNull(result);
Assert.AreEqual(result.aASCIIString, default(string));
Assert.AreEqual(result.aVarcharString, default(string));
Assert.AreEqual(result.aVarint, default(BigInteger));
Assert.AreEqual(result.aTextString, default(string));
Assert.AreEqual(result.aBool, default(bool));
Assert.AreEqual(result.aDecimal, default(decimal));
Assert.AreEqual(result.aDouble, default(double));
Assert.AreEqual(result.aFloat, default(float));
Assert.AreEqual(result.aInet, default(IPAddress));
Assert.AreEqual(result.aLong, default(long));
Assert.AreEqual(result.aTimeUUID, TimeGuid.Default);
Assert.AreEqual(result.aUUID, default(Guid));
Assert.AreEqual(result.aBlob, default(byte[]));
Assert.AreEqual(result.aList, default(List<string>));
Assert.AreEqual(result.aSet, default(HashSet<int>));
Assert.AreEqual(result.aMap, default(Dictionary<long, string>));
}
}
public void SerializeOutDefaultTest()
{
const string insertCql = @"insert into SerializationTest.Types(aInt) values (1);";
const string selectCql = "select * from SerializationTest.Types limit 1;";
using(var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.ExecuteNonQuery();
string aAsciiString;
string aVarcharString;
BigInteger aVarint;
string aTextString;
bool aBool;
decimal aDecimal;
double aDouble;
float aFloat;
IPAddress aInet;
long aLong;
Guid aTimeUUID;
Guid aUUID;
byte[] aBlob;
List<string> aList;
HashSet<int> aSet;
Dictionary<long, string> aMap;
var selectCmd = new CqlCommand(connection, selectCql);
using(var reader = selectCmd.ExecuteReader())
{
if(reader.Read())
{
aAsciiString = reader.GetString(reader.GetOrdinal("aasciistring"));
aVarcharString = reader.GetString(reader.GetOrdinal("avarcharstring"));
aVarint = reader.GetBigInteger(reader.GetOrdinal("avarint"));
aTextString = reader.GetString(reader.GetOrdinal("atextstring"));
aBool = reader.GetBoolean(reader.GetOrdinal("abool"));
aDecimal = reader.GetDecimal(reader.GetOrdinal("adecimal"));
aDouble = reader.GetDouble(reader.GetOrdinal("adouble"));
aFloat = reader.GetFloat(reader.GetOrdinal("afloat"));
aInet = reader.GetIPAddress(reader.GetOrdinal("ainet"));
aLong = reader.GetInt64(reader.GetOrdinal("along"));
aTimeUUID = reader.GetGuid(reader.GetOrdinal("atimeuuid"));
aUUID = reader.GetGuid(reader.GetOrdinal("auuid"));
aBlob = reader.GetBytes(reader.GetOrdinal("ablob"));
aList = reader.GetList<string>(reader.GetOrdinal("alist"));
aSet = reader.GetSet<int>(reader.GetOrdinal("aset"));
aMap = reader.GetDictionary<long, string>(reader.GetOrdinal("amap"));
}
else
throw new Exception("No row returned!");
}
Assert.AreEqual(aAsciiString, default(string));
Assert.AreEqual(aVarcharString, default(string));
Assert.AreEqual(aVarint, default(BigInteger));
Assert.AreEqual(aTextString, default(string));
Assert.AreEqual(aBool, default(bool));
Assert.AreEqual(aDecimal, default(decimal));
Assert.AreEqual(aDouble, default(double));
Assert.AreEqual(aFloat, default(float));
Assert.AreEqual(aInet, default(IPAddress));
Assert.AreEqual(aLong, default(long));
Assert.AreEqual(aTimeUUID, default(Guid));
Assert.AreEqual(aUUID, default(Guid));
Assert.AreEqual(aBlob, default(byte[]));
Assert.AreEqual(aList, default(List<string>));
Assert.AreEqual(aSet, default(HashSet<int>));
Assert.AreEqual(aMap, default(Dictionary<long, string>));
}
}
public void SetFixture()
{
connection = new CqlConnection("Contact Points=cassi.cloudapp.net;Port=9042");
}
public void Run_all_Cassandra_migrations_work()
{
var cnn = new CqlConnection($"Contact Points=127.0.0.1;Port={_cassandraFixture.Cassandra.HostPort};Cluster Name={_cassandraFixture.Cassandra.ClusterName}");
var evolve = new Evolve(cnn, msg => _output.WriteLine(msg))
{
Locations = new List <string> {
TestContext.MigrationFolder
},
CommandTimeout = 25,
MetadataTableSchema = "my_keyspace",
MetadataTableName = "evolve_change_log",
SqlMigrationSuffix = ".cql"
};
int nbMigration = Directory.GetFiles(TestContext.MigrationFolder).Length;
// Migrate Cql_Scripts\Migration
evolve.Migrate();
Assert.True(evolve.NbMigration == nbMigration, $"{nbMigration} migrations should have been applied, not {evolve.NbMigration}.");
Assert.Equal(ConnectionState.Closed, cnn.State);
// Migrate: nothing to do. Database is already up to date.
evolve.Migrate();
Assert.True(evolve.NbMigration == 0, $"There should be no more migration after a successful one, not {evolve.NbMigration}.");
Assert.Equal(ConnectionState.Closed, cnn.State);
// StartVersion fails because migraiton scripts has been applied.
evolve.StartVersion = new MigrationVersion("3.0");
Assert.Throws <EvolveConfigurationException>(() => evolve.Migrate());
evolve.StartVersion = MigrationVersion.MinVersion;
Assert.Equal(ConnectionState.Closed, cnn.State);
// Migrate Cql_Scripts\Checksum_mismatch: validation should fail due to a checksum mismatch.
evolve.Locations = new List <string> {
TestContext.ChecksumMismatchFolder
};
Assert.Throws <EvolveValidationException>(() => evolve.Migrate());
Assert.Equal(ConnectionState.Closed, cnn.State);
// Repair sucessfull
evolve.Repair();
Assert.True(evolve.NbReparation == 1, $"There should be 1 migration repaired, not {evolve.NbReparation}.");
Assert.Equal(ConnectionState.Closed, cnn.State);
// Migrate: nothing to do. Database is already up to date.
evolve.Migrate();
Assert.True(evolve.NbMigration == 0, $"There should be no more migration after a successful one, not {evolve.NbMigration}.");
Assert.Equal(ConnectionState.Closed, cnn.State);
// Erase cancelled (EraseDisabled = true)
evolve.IsEraseDisabled = true;
Assert.Throws <EvolveConfigurationException>(() => evolve.Erase());
Assert.Equal(ConnectionState.Closed, cnn.State);
// Erase sucessfull
evolve.IsEraseDisabled = false;
evolve.Erase();
Assert.True(evolve.NbSchemaErased == evolve.Schemas.Count(), $"{evolve.Schemas.Count()} schemas should have been erased, not {evolve.NbSchemaErased}.");
Assert.Equal(ConnectionState.Closed, cnn.State);
// Migrate sucessfull after a validation error (MustEraseOnValidationError = true)
evolve.Locations = new List <string> {
TestContext.MigrationFolder
}; // Migrate Sql_Scripts\Migration
evolve.Migrate();
Assert.True(evolve.NbMigration == nbMigration, $"{nbMigration} migrations should have been applied, not {evolve.NbMigration}.");
evolve.Locations = new List <string> {
TestContext.ChecksumMismatchFolder
}; // Migrate Cql_Scripts\Checksum_mismatch
evolve.MustEraseOnValidationError = true;
evolve.Migrate();
Assert.True(evolve.NbSchemaErased == evolve.Schemas.Count(), $"{evolve.Schemas.Count()} schemas should have been erased, not {evolve.NbSchemaErased}.");
Assert.True(evolve.NbMigration == 1, $"1 migration should have been applied, not {evolve.NbMigration}.");
Assert.Equal(ConnectionState.Closed, cnn.State);
// Erase sucessfull
evolve.IsEraseDisabled = false;
evolve.Erase();
Assert.True(evolve.NbSchemaErased == evolve.Schemas.Count(), $"{evolve.Schemas.Count()} schemas should have been erased, not {evolve.NbSchemaErased}.");
Assert.Equal(ConnectionState.Closed, cnn.State);
// StartVersion = 3
evolve.Erase();
evolve.Locations = new List <string> {
TestContext.MigrationFolder
}; // Migrate Cql_Scripts\Migration
evolve.StartVersion = new MigrationVersion("3");
evolve.Migrate();
Assert.True(evolve.NbMigration == (nbMigration - 2), $"{nbMigration - 2} migrations should have been applied, not {evolve.NbMigration} (StartVersion tests).");
evolve.Migrate();
Assert.True(evolve.NbMigration == 0, $"There should be no more migration after a successful one, not {evolve.NbMigration} (StartVersion tests).");
evolve.StartVersion = MigrationVersion.MinVersion;
evolve.Migrate();
Assert.True(evolve.NbMigration == 0, $"There should be no more migration after a successful one, not {evolve.NbMigration} (StartVersion tests).");
evolve.StartVersion = new MigrationVersion("3.0");
Assert.Throws <EvolveConfigurationException>(() => evolve.Migrate());
Assert.Equal(ConnectionState.Closed, cnn.State);
//DefaultKeyspaceReplicationStrategy
evolve.StartVersion = MigrationVersion.MinVersion;
evolve.Erase();
var configurationFileName = Dialect.Cassandra.Configuration.ConfigurationFile;
File.Copy($"_{configurationFileName}", configurationFileName);
var ex = Assert.Throws <EvolveSqlException>(() => evolve.Migrate());
Assert.Contains("Not enough replicas available for query at consistency", ex.Message);
File.Delete(configurationFileName);
}
public void PrepareTest()
{
const string truncateTableCql = @"truncate Test.BasicFlow;";
using(var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var truncTable = new CqlCommand(connection, truncateTableCql);
truncTable.ExecuteNonQuery();
}
}
public async Task PrepareAndReprepare()
{
//Assume
const string insertCql = @"insert into Test.BasicFlow (id,value) values (2, ?);";
//Act
using(var connection = new CqlConnection(ConnectionString))
{
await connection.OpenAsync();
//prepare command
var cmd = new CqlCommand(connection, insertCql, CqlConsistency.One);
await cmd.PrepareAsync();
Assert.IsTrue(cmd.IsPrepared);
Assert.AreEqual(1, cmd.Parameters.Count);
Assert.IsTrue(cmd.Parameters.IsReadOnly);
Assert.IsTrue(cmd.Parameters.IsFixedSize);
Assert.IsInstanceOfType(cmd.LastQueryResult, typeof(CqlPrepared));
var prepareResult = (CqlPrepared)cmd.LastQueryResult;
Assert.IsFalse(prepareResult.FromCache);
//reprepare
var cmd2 = new CqlCommand(connection, insertCql, CqlConsistency.One);
await cmd2.PrepareAsync();
Assert.IsTrue(cmd2.IsPrepared);
Assert.AreEqual(1, cmd2.Parameters.Count);
Assert.IsTrue(cmd2.Parameters.IsReadOnly);
Assert.IsTrue(cmd2.Parameters.IsFixedSize);
Assert.IsInstanceOfType(cmd2.LastQueryResult, typeof(CqlPrepared));
var prepareResult2 = (CqlPrepared)cmd2.LastQueryResult;
Assert.IsTrue(prepareResult2.FromCache);
}
}
public void SerializeTest()
{
const string insertCql = @"insert into Test.Types(
aInt,
aLong ,
aVarint ,
aTextString ,
aVarcharString ,
aASCIIString ,
aBlob ,
aBool ,
aDouble ,
aFloat ,
aTimestamp ,
aTimeUUID ,
aUUID ,
aInet ,
aList,
aSet,
aMap)
values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
const string selectCql = "select * from Test.Types limit 1;";
using (var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var values = new Types
{
aASCIIString = "hello world!",
aBlob = new byte[] { 1, 2, 3, 4 },
aBool = true,
aDouble = 1.234,
aFloat = 5.789f,
aInet = new IPAddress(new byte[] { 127, 0, 0, 1 }),
aInt = 10,
aLong = 56789012456,
aTextString = "some other text with \u005C unicode",
aVarcharString = "some other varchar with \u005C unicode",
aTimeUUID = DateTime.Now.GenerateTimeBasedGuid(),
aUUID = Guid.NewGuid(),
aTimestamp = DateTime.Now,
aVarint = new BigInteger(12345678901234),
aList = new List <string> {
"string 1", "string 2"
},
aSet = new HashSet <int> {
1, 3, 3
},
aMap =
new Dictionary <long, string> {
{ 1, "value 1" }, { 2, "value 2" }, { 3, "value 3" }
},
};
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.Prepare();
insertCmd.Parameters.Set(values);
insertCmd.ExecuteNonQuery();
var selectCmd = new CqlCommand(connection, selectCql);
Types result = null;
using (var reader = selectCmd.ExecuteReader <Types>())
{
if (reader.Read())
{
result = reader.Current;
}
}
Assert.IsNotNull(result);
Assert.AreEqual(result.aASCIIString, values.aASCIIString);
Assert.AreEqual(result.aVarcharString, values.aVarcharString);
Assert.AreEqual(result.aVarint, values.aVarint);
Assert.AreEqual(result.aTextString, values.aTextString);
Assert.AreEqual(result.aBool, values.aBool);
Assert.AreEqual(result.aDouble, values.aDouble);
Assert.AreEqual(result.aFloat, values.aFloat);
Assert.AreEqual(result.aInet, values.aInet);
Assert.AreEqual(result.aInt, values.aInt);
Assert.AreEqual(result.aLong, values.aLong);
Assert.AreEqual(result.aTimeUUID, values.aTimeUUID);
Assert.AreEqual(result.aUUID, values.aUUID);
Assert.IsTrue(result.aBlob.SequenceEqual(values.aBlob));
Assert.IsTrue(result.aList.SequenceEqual(values.aList));
Assert.IsTrue(result.aSet.SequenceEqual(values.aSet));
}
}
public MyContext(CqlConnection connection, bool ownsConnection)
: base(connection, ownsConnection)
{
}
public async Task QueryWithBoundParameters()
{
//Assume
const string insertCql = @"insert into Test.BasicFlow (id,value) values (?,?);";
const string retrieveCql = @"select * from Test.BasicFlow;";
//Act
using(var connection = new CqlConnection(ConnectionString))
{
await connection.OpenAsync();
//define command
var cmd = new CqlCommand(connection, insertCql, CqlConsistency.One);
//add parameters, infer Cql types
cmd.Parameters.Add("id", 123);
cmd.Parameters.Add("value", "Hallo");
try
{
//execute
await cmd.ExecuteNonQueryAsync();
}
catch(InvalidException)
{
Assert.IsNotNull(connection.ServerVersion);
if(String.Compare(connection.ServerVersion, "2.0.0", StringComparison.Ordinal) < 0)
return;
throw;
}
//select data
var selectCmd = new CqlCommand(connection, retrieveCql, CqlConsistency.One);
CqlDataReader<BasicFlowData> reader = await selectCmd.ExecuteReaderAsync<BasicFlowData>();
Assert.AreEqual(1, reader.Count);
if(await reader.ReadAsync())
{
BasicFlowData row = reader.Current;
Assert.AreEqual(123, row.Id);
Assert.AreEqual("Hallo", row.Data);
Assert.IsNull(row.Ignored);
}
else
Assert.Fail("Read should have succeeded");
}
}
public CqlContextBatchTransaction(CqlDatabase database, CqlConnection connection)
: base(connection)
{
_database = database;
_disposed = false;
}
private async Task BatchInsertInternal(CqlBatchType batchType)
{
//Assume
const string insertCql = @"insert into Test.BasicFlow (id,value) values (?,?);";
const string retrieveCql = @"select id,value,ignored from Test.BasicFlow;";
//Act
using(var connection = new CqlConnection(ConnectionString))
{
await connection.OpenAsync();
var transaction = connection.BeginTransaction();
transaction.BatchType = batchType;
//insert data
var cmd = new CqlCommand(connection, insertCql, CqlConsistency.One);
cmd.Transaction = transaction;
await cmd.PrepareAsync();
for(int i = 0; i < 10; i++)
{
cmd.Parameters[0].Value = i;
cmd.Parameters[1].Value = "Hello " + i;
await cmd.ExecuteNonQueryAsync();
}
var cmd2 = new CqlCommand(connection, insertCql, CqlConsistency.One);
cmd2.Transaction = transaction;
cmd2.Parameters.Add("id", CqlType.Int);
cmd2.Parameters.Add("value", CqlType.Text);
for(int i = 10; i < 20; i++)
{
cmd2.Parameters[0].Value = i;
cmd2.Parameters[1].Value = "Hello " + i;
await cmd2.ExecuteNonQueryAsync();
}
try
{
await transaction.CommitAsync();
}
catch(ProtocolException pex)
{
//skip when server version is below 2.0.0
if(pex.Code == ErrorCode.Protocol &&
String.Compare(connection.ServerVersion, "2.0.0", StringComparison.Ordinal) < 0)
return;
throw;
}
//select data
var selectCmd = new CqlCommand(connection, retrieveCql, CqlConsistency.One);
CqlDataReader reader = await selectCmd.ExecuteReaderAsync();
Assert.AreEqual(20, reader.Count);
var results = new bool[20];
for(int i = 0; i < 20; i++)
{
if(await reader.ReadAsync())
{
results[(int)reader["id"]] = true;
Assert.AreEqual("Hello " + reader["id"], reader["value"]);
}
else
Assert.Fail("Read should have succeeded");
}
Assert.IsTrue(results.All(p => p));
Assert.IsNotNull(transaction.LastBatchResult);
}
}
public void SetFixture()
{
connection = new CqlConnection("Contact Points=cassi.cloudapp.net;Port=9042");
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryTraceCommand" /> class.
/// </summary>
/// <param name="connection"> The connection. </param>
/// <param name="tracingId"> The tracing id. </param>
public QueryTraceCommand(CqlConnection connection, Guid tracingId)
{
_connection = connection;
_tracingId = tracingId;
}
public void SerializeObjectOutDefaultsTest()
{
const string insertCql = @"insert into SerializationTest.Types(aInt) values (1);";
const string selectCql = "select * from SerializationTest.Types limit 1;";
using(var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.ExecuteNonQuery();
var selectCmd = new CqlCommand(connection, selectCql);
Types result = null;
using(var reader = selectCmd.ExecuteReader<Types>())
{
if(reader.Read())
result = reader.Current;
}
Assert.IsNotNull(result);
Assert.AreEqual(result.aASCIIString, default(string));
Assert.AreEqual(result.aVarcharString, default(string));
Assert.AreEqual(result.aVarint, default(BigInteger));
Assert.AreEqual(result.aTextString, default(string));
Assert.AreEqual(result.aBool, default(bool));
Assert.AreEqual(result.aDecimal, default(decimal));
Assert.AreEqual(result.aDouble, default(double));
Assert.AreEqual(result.aFloat, default(float));
Assert.AreEqual(result.aInet, default(IPAddress));
Assert.AreEqual(result.aLong, default(long));
Assert.AreEqual(result.aTimeUUID, default(Guid));
Assert.AreEqual(result.aUUID, default(Guid));
Assert.AreEqual(result.aBlob, default(byte[]));
Assert.AreEqual(result.aList, default(List<string>));
Assert.AreEqual(result.aSet, default(HashSet<int>));
Assert.AreEqual(result.aMap, default(Dictionary<long, string>));
}
}
public void SerializeOutNullTest()
{
const string insertCql = @"insert into SerializationTest.Types(aInt) values (1);";
const string selectCql = "select * from SerializationTest.Types limit 1;";
using(var connection = new CqlConnection(ConnectionString))
{
string aAsciiString;
string aVarcharString;
BigInteger? aVarint;
string aTextString;
bool? aBool;
decimal? aDecimal;
double? aDouble;
float? aFloat;
IPAddress aInet;
long? aLong;
Guid? aTimeUUID;
Guid? aUUID;
byte[] aBlob;
List<string> aList;
HashSet<int> aSet;
Dictionary<long, string> aMap;
connection.Open();
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.ExecuteNonQuery();
var selectCmd = new CqlCommand(connection, selectCql);
using(var reader = selectCmd.ExecuteReader())
{
if(reader.Read())
{
aAsciiString = reader["aasciistring"] as string;
aVarcharString = reader["avarcharstring"] as string;
aVarint = reader["avarint"] as BigInteger?;
aTextString = reader["atextstring"] as string;
aBool = reader["abool"] as bool?;
aDecimal = reader["adecimal"] as decimal?;
aDouble = reader["adouble"] as double?;
aFloat = reader["afloat"] as float?;
aInet = reader["ainet"] as IPAddress;
aLong = reader["along"] as long?;
aTimeUUID = reader["atimeuuid"] as Guid?;
aUUID = reader["auuid"] as Guid?;
aBlob = reader["ablob"] as byte[];
aList = reader["alist"] as List<string>;
aSet = reader["aset"] as HashSet<int>;
aMap = reader["amap"] as Dictionary<long, string>;
}
else
throw new Exception("No row returned!");
}
Assert.AreEqual(aAsciiString, default(string));
Assert.AreEqual(aVarcharString, default(string));
Assert.AreEqual(aVarint, default(BigInteger?));
Assert.AreEqual(aTextString, default(string));
Assert.AreEqual(aBool, default(bool?));
Assert.AreEqual(aDecimal, default(decimal?));
Assert.AreEqual(aDouble, default(double?));
Assert.AreEqual(aFloat, default(float?));
Assert.AreEqual(aInet, default(IPAddress));
Assert.AreEqual(aLong, default(long?));
Assert.AreEqual(aTimeUUID, default(Guid?));
Assert.AreEqual(aUUID, default(Guid?));
Assert.AreEqual(aBlob, default(byte[]));
Assert.AreEqual(aList, default(List<string>));
Assert.AreEqual(aSet, default(HashSet<int>));
Assert.AreEqual(aMap, default(Dictionary<long, string>));
}
}
public void NullableSerializeTest()
{
const string insertCql = @"insert into Test.Types(
aInt,
aLong ,
aVarint ,
aTextString ,
aVarcharString ,
aASCIIString ,
aBlob ,
aBool ,
aDouble ,
aFloat ,
aTimestamp ,
aTimeUUID ,
aUUID ,
aInet ,
aList,
aSet,
aMap)
values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);";
const string selectCql = "select * from Test.Types limit 1;";
using (var connection = new CqlConnection(ConnectionString))
{
connection.Open();
var values = new NullableTypes
{
aInt = 3,
aASCIIString = null,
aBlob = null,
aBool = null,
aDouble = null,
aFloat = null,
aInet = null,
aLong = null,
aTextString = null,
aVarcharString = null,
aTimeUUID = null,
aUUID = null,
aTimestamp = null,
aVarint = null,
aList = null,
aSet = null,
aMap = null
};
var insertCmd = new CqlCommand(connection, insertCql);
insertCmd.Prepare();
insertCmd.Parameters.Set(values);
insertCmd.ExecuteNonQuery();
var selectCmd = new CqlCommand(connection, selectCql);
NullableTypes result = null;
using (var reader = selectCmd.ExecuteReader <NullableTypes>())
{
if (reader.Read())
{
result = reader.Current;
}
}
Assert.IsNotNull(result);
Assert.IsNull(result.aASCIIString);
Assert.IsNull(result.aVarcharString);
Assert.IsNull(result.aVarint);
Assert.IsNull(result.aTextString);
Assert.IsNull(result.aBool);
Assert.IsNull(result.aDouble);
Assert.IsNull(result.aFloat);
Assert.IsNull(result.aInet);
Assert.IsNull(result.aLong);
Assert.IsNull(result.aTimeUUID);
Assert.IsNull(result.aUUID);
Assert.IsNull(result.aBlob);
Assert.IsNull(result.aList);
Assert.IsNull(result.aSet);
Assert.IsNull(result.aMap);
}
}
