public void Insert(string family, string key, string superColumnName, string columnName, string value)
{
ICluster cluster = AquilesHelper.RetrieveCluster(Cluster);
byte[] keyAsByteArray = Encoding.ASCII.GetBytes(key);
byte[] valueAsByteArray = Encoding.ASCII.GetBytes(value);
var columnParent = new ColumnParent
{
Column_family = family,
};
var column = new Column
{
Name = ByteEncoderHelper.UTF8Encoder.ToByteArray(columnName),
Timestamp = UnixHelper.UnixTimestamp,
Value = valueAsByteArray
};
cluster.Execute(new ExecutionBlock(client =>
{
// http://www.dotnetperls.com/convert-string-byte-array
client.insert(keyAsByteArray, columnParent, column,
ConsistencyLevel.ONE);
return(null);
}), keyspaceName);
}
protected override void InternalRun(ICluster cluster)
{
const string insertBatch = "INSERT INTO Foo.Bar (id, Baz) VALUES (?, ?)";
var preparedInsert = cluster.Prepare(insertBatch);
const int times = 10;
var random = new Random();
for (int i = 0; i < times; i++)
{
long running = Interlocked.Increment(ref _running);
Console.WriteLine("Current {0} Running {1}", i, running);
var data = new byte[30000];
// var data = (float)random.NextDouble();
preparedInsert.ExecuteNonQuery(new {id = i, Baz = data}, ConsistencyLevel.ONE)
.ContinueWith(_ => Interlocked.Decrement(ref _running));
}
while (Thread.VolatileRead(ref _running) > 0)
{
Console.WriteLine("Running {0}", _running);
Thread.Sleep(1000);
}
var result = cluster.Execute<Foo>("select * from Foo.Bar where id = 50").Result;
foreach (var res in result)
{
Console.WriteLine("{0} len={1}", res.Id, res.Baz.Length);
}
}
protected override void InternalRun(ICluster cluster)
{
const string cqlKeyspaces = "SELECT * from system.schema_columns";
var req = from t in cluster.Execute<SchemaColumns>(cqlKeyspaces).Result
where t.KeyspaceName == "system"
select t;
DisplayResult(req);
}
public IEnumerable<IPAddress> DiscoverPeers(ICluster cluster)
{
var futPeers = cluster.Execute<Peer>("select rpc_address from system.peers", ConsistencyLevel.ONE).AsFuture();
List<IPAddress> newPeers = new List<IPAddress>();
foreach (Peer peer in futPeers.Result)
{
IPAddress newPeer = peer.RpcAddress;
newPeers.Add(newPeer);
_logger.Debug("Discovered peer {0}", newPeer);
}
return newPeers;
}
protected virtual async Task <IGetOperationResult> PerformGetCore(string key, ulong cas)
{
try
{
var op = opFactory.Get(keyTransformer.Transform(key), cas);
await cluster.Execute(op).ConfigureAwait(false);
return(op.Result);
}
catch (IOException e)
{
return(new GetOperationResult().FailWith(e));
}
}
protected override void InternalRun(ICluster cluster)
{
const string cqlKeyspaces = "SELECT * from system.schema_keyspaces";
var allTasks = new List<Task>();
for (int i = 0; i < 100; ++i)
{
var futRes = cluster.Execute<SchemaKeyspaces>(cqlKeyspaces).ContinueWith(t => DisplayKeyspace(t.Result));
allTasks.Add(futRes);
}
Task.WaitAll(allTasks.ToArray());
}
/// <summary>
/// Adds or updates value in the storage
/// </summary>
/// <param name="key">Key which identifies the data</param>
/// <param name="value">Data to store</param>
/// <returns>True if operation was success</returns>
public bool AddOrUpdate(Guid key, object value)
{
// Insert statement
byte[] keyEncoded = key.ToByteArray();
ColumnParent columnParent = new ColumnParent();
columnParent.Column_family = columnFamily;
using (var ms = new MemoryStream())
{
using (var bw = new BinaryWriter(ms))
{
Serializer.Serialize(value, bw);
byte[] data = new byte[ms.Length];
// Copy only the used portion of the buffer
Array.Copy(ms.GetBuffer(), data, ms.Length);
Column column = new Column()
{
Name = ByteEncoderHelper.UTF8Encoder.ToByteArray("Value"),
Timestamp = UnixHelper.UnixTimestamp,
Value = data,
};
cluster.Execute(new ExecutionBlock(delegate(Cassandra.Client client)
{
client.insert(keyEncoded, columnParent, column, ConsistencyLevel.ONE);
return(null);
}), keySpace);
}
}
return(true);
}
protected override void InternalRun(ICluster cluster)
{
const string cqlKeyspaces = "SELECT * from system.schema_keyspaces";
var allResults = new List<Task<IList<SchemaKeyspaces>>>();
for (int i = 0; i < 100; ++i)
{
var futRes = cluster.Execute<SchemaKeyspaces>(cqlKeyspaces).AsFuture();
allResults.Add(futRes);
}
foreach (var result in allResults)
{
DisplayKeyspace(result);
}
}
public List <ColumnOrSuperColumn> GetSlice(string family, string key, string superColumnName, int count)
{
//var getSliceCommand = new GetSliceCommand
// {
// KeySpace = Name,
// Key = key,
// ColumnFamily = family,
// SuperColumn = superColumnName,
// Predicate =
// new SlicePredicate
// {
// Slice_range = new SliceRange {Count = count}
// }
//
//using (var connection = AquilesHelper.RetrieveConnection(Cluster))
//{
// connection.Execute(getSliceCommand);
// return getSliceCommand.Output == null
// ? new List<AquilesColumn>()
// : getSliceCommand.Output.Results.Select(o => o.Column).ToList();
//}
byte[] keyAsByteArray = Encoding.ASCII.GetBytes(key);
var columnParent = new ColumnParent
{
Column_family = family,
};
var predicate = new SlicePredicate
{
Slice_range = new SliceRange
{
Count = 1000,
Reversed = false,
Start = new byte[0],
Finish = new byte[0],
},
};
ICluster cluster = AquilesHelper.RetrieveCluster(Cluster);
object rtnValue = cluster.Execute(new ExecutionBlock(
client =>
client.get_slice(keyAsByteArray, columnParent, predicate,
ConsistencyLevel.ONE)), keyspaceName);
return(rtnValue as List <ColumnOrSuperColumn>);
}
protected override void InternalRun(ICluster cluster)
{
const string cqlKeyspaces = "SELECT * from system.schema_keyspaces";
Random rnd = new Random();
for (int i = 0; i < 10; ++i)
{
DateTime dtStart = DateTime.Now;
DateTime dtStop = dtStart.AddSeconds(2); // 2 second max
int wait = rnd.Next(4*1000);
var futRes = cluster.Execute<SchemaKeyspaces>(cqlKeyspaces)
.ContinueWith(t =>
{
// simulate an eventually long operation
Thread.Sleep(wait);
return t;
}).Unwrap().ContinueWith(t => DisplayKeyspace(t.Result, dtStop));
futRes.Wait();
}
}
public ColumnOrSuperColumn GetColumn(string family, string key, string superColumnName, string columnName)
{
//var getCommand = new GetCommand
// {
// KeySpace = Name,
// Key = key,
// ColumnFamily = family,
// ColumnName = columnName,
// SuperColumnName = superColumnName
// };
//using (var connection = AquilesHelper.RetrieveConnection(Cluster))
//{
// connection.Execute(getCommand);
// return getCommand.Output == null ? null : getCommand.Output.Column;
//}
byte[] keyAsByteArray = Encoding.ASCII.GetBytes(key);
byte[] columnNameAsByteArray = Encoding.ASCII.GetBytes(columnName);
var columnPath = new ColumnPath
{
Column = columnNameAsByteArray,
Column_family = family,
};
ICluster cluster = AquilesHelper.RetrieveCluster(Cluster);
return((ColumnOrSuperColumn)cluster.Execute(new ExecutionBlock(client =>
{
try
{
return client.get(keyAsByteArray, columnPath,
ConsistencyLevel.ONE);
}
catch (Exception e)
{
return null;
}
}), keyspaceName));
}
protected override void InternalRun(ICluster cluster)
{
const string insertNerdMovie = "INSERT INTO videos.NerdMovies (movie, director, main_actor, year)" +
"VALUES ('Serenity', 'Joss Whedon', 'Nathan Fillion', 2005) " +
"USING TTL 86400";
Console.WriteLine(insertNerdMovie);
cluster.ExecuteNonQuery(insertNerdMovie).Wait();
Console.WriteLine();
const string selectNerdMovies = "select * from videos.NerdMovies";
Console.WriteLine(selectNerdMovies);
var taskSelectStartMovies = cluster.Execute<NerdMovie>(selectNerdMovies).ContinueWith(res => DisplayMovies(res.Result));
taskSelectStartMovies.Wait();
Console.WriteLine();
const string selectAllFrom = "select * from videos.NerdMovies where director=? ALLOW FILTERING";
Console.WriteLine(selectAllFrom);
var preparedAllFrom = cluster.Prepare(selectAllFrom);
var ds = new {Director = "Joss Whedon"};
var taskSelectWhere =
preparedAllFrom.Execute<NerdMovie>(ds).ContinueWith(res => DisplayMovies(res.Result));
taskSelectWhere.Wait();
Console.WriteLine();
}
