public void TestCqlCommand_Prepare_Without_Connection() { var target = new CqlCommand(); target.Parameters.Add("p1", "1"); target.Prepare(); }
/// <summary> /// Initializes a new instance of the <see cref="CqlBatchTransaction" /> class. /// </summary> public CqlBatchTransaction() { _batchCommand = new CqlCommand {Transaction = this}; _commands = new List<BatchFrame.BatchedCommand>(); _batchType = CqlBatchType.Logged; _state = TransactionState.Pending; }
/// <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> /// Gets the trace session async. /// </summary> /// <returns> TracingSession if any, null otherwise </returns> public async Task<TracingSession> GetTraceSessionAsync(CancellationToken token) { TracingSession session; var sessionCmd = new CqlCommand(_connection, "select * from system_traces.sessions where session_id=" + _tracingId + ";", CqlConsistency.One); using( CqlDataReader<TracingSession> reader = await sessionCmd.ExecuteReaderAsync<TracingSession>(token).AutoConfigureAwait()) { if(await reader.ReadAsync(token).AutoConfigureAwait()) session = reader.Current; else return null; } var eventsCmd = new CqlCommand(_connection, "select * from system_traces.events where session_id=" + _tracingId + ";", CqlConsistency.One); using( CqlDataReader<TracingEvent> reader = await eventsCmd.ExecuteReaderAsync<TracingEvent>(token).AutoConfigureAwait()) { var events = new List<TracingEvent>(reader.Count); while(await reader.ReadAsync().AutoConfigureAwait()) events.Add(reader.Current); session.Events = events; } return session; }
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 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 TestCqlCommand_Prepare_Without_Connection() { var target = new CqlCommand(); target.Parameters.Add("p1", "1"); Assert.Throws <InvalidOperationException>(() => target.Prepare()); }
/// <summary> /// Gets the trace session async. /// </summary> /// <returns> TracingSession if any, null otherwise </returns> public async Task<TracingSession> GetTraceSessionAsync() { TracingSession session = null; var sessionCmd = new CqlCommand(_connection, "select * from system_traces.sessions where session_id=" + _tracingId.ToString() + ";", CqlConsistency.One); using (CqlDataReader<TracingSession> reader = await sessionCmd.ExecuteReaderAsync<TracingSession>().ConfigureAwait(false)) { if (await reader.ReadAsync().ConfigureAwait(false)) { session = reader.Current; } else return null; } var eventsCmd = new CqlCommand(_connection, "select * from system_traces.events where session_id=" + _tracingId.ToString() + ";", CqlConsistency.One); using (CqlDataReader<TracingEvent> reader = await eventsCmd.ExecuteReaderAsync<TracingEvent>().ConfigureAwait(false)) { var events = new List<TracingEvent>(reader.Count); while (await reader.ReadAsync().ConfigureAwait(false)) { events.Add(reader.Current); } session.Events = events; } return session; }
/// <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 async Task<List<string>> Get(string appId, string itemId, string relation, string userId) { using (var conn = new CqlConnection(_connString)) { await conn.OpenAsync().ConfigureAwait(false); var query = string.Format( System.Globalization.CultureInfo.InvariantCulture, "select values from negrapi.relations where app_id = '{0}' and item_id='{1}' and relation='{2}';", appId, GetKey(itemId, userId), relation); var cmd = new CqlCommand( conn, query, CqlConsistency.One); var result = await cmd.ExecuteScalarAsync().ConfigureAwait(false) as string; if (string.IsNullOrEmpty(result)) { return null; } var list = JsonConvert.DeserializeObject<List<RecommendationsDataValue>>(result); return list .Select(i => i.ItemId) .ToList(); } }
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(); } } }
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); } }
/// <summary> /// Initializes a new instance of the <see cref="CqlBatchTransaction" /> class. /// </summary> /// <param name="connection"> The connection. </param> /// <param name="batchType"> Type of the batch. </param> /// <param name="consistency"> The consistency. </param> public CqlBatchTransaction(CqlConnection connection, CqlBatchType batchType = CqlBatchType.Logged, CqlConsistency consistency = CqlConsistency.One) { _batchCommand = new CqlCommand(connection) {Consistency = consistency, Transaction = this}; _commands = new List<BatchFrame.BatchedCommand>(); _batchType = batchType; _state = TransactionState.Pending; }
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(); } }
/// <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) { } } }
/// <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); } } }
/// <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) { } } }
/// <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) { } } }
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) { } } }
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 } } }
public 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>)); } }
/// <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); } } }
/// <summary> /// Gets the trace session async. /// </summary> /// <returns> TracingSession if any, null otherwise </returns> public async Task <TracingSession> GetTraceSessionAsync() { TracingSession session = null; var sessionCmd = new CqlCommand(_connection, "select * from system_traces.sessions where session_id=" + _tracingId.ToString() + ";", CqlConsistency.One); using (CqlDataReader <TracingSession> reader = await sessionCmd.ExecuteReaderAsync <TracingSession>().ConfigureAwait(false)) { if (await reader.ReadAsync().ConfigureAwait(false)) { session = reader.Current; } else { return(null); } } var eventsCmd = new CqlCommand(_connection, "select * from system_traces.events where session_id=" + _tracingId.ToString() + ";", CqlConsistency.One); using (CqlDataReader <TracingEvent> reader = await eventsCmd.ExecuteReaderAsync <TracingEvent>().ConfigureAwait(false)) { var events = new List <TracingEvent>(reader.Count); while (await reader.ReadAsync().ConfigureAwait(false)) { events.Add(reader.Current); } session.Events = events; } return(session); }
/// <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 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 Append(CqlCommand s) { _batch.Append(s); }
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 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 Init() { using(var connection = new CqlConnection(ConnectionString)) { connection.Open(); var truncTable = new CqlCommand(connection, TruncateTableCql); truncTable.ExecuteNonQuery(); } }
/// <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 PrepareTest() { const string truncateTableCql = @"truncate Test.BasicFlow;"; using(var connection = new CqlConnection(ConnectionString)) { connection.Open(); var truncTable = new CqlCommand(connection, truncateTableCql); truncTable.ExecuteNonQuery(); } }
/// <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; } } }
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 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 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)); } }
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 ExecuteNonQuery(CqlCommand command) { _batch.Append(command); }
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); } }
/// <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 void AppendCommand(CqlCommand cqlCommand) { _additionalCommands.Add(cqlCommand); }
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 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 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); } }
/// <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(); } }
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 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)); } }