public void Can_Update_A_Hll()
{
string key = Guid.NewGuid().ToString();
SaveHll(key);
var add_3 = new RiakString("add_3");
var adds = new HashSet <string> {
add_3
};
var update = new UpdateHll.Builder(adds)
.WithBucketType(BucketType)
.WithBucket(Bucket)
.WithKey(key)
.WithReturnBody(true)
.WithTimeout(TimeSpan.FromMilliseconds(20000))
.Build();
RiakResult rslt = client.Execute(update);
Assert.IsTrue(rslt.IsSuccess, rslt.ErrorMessage);
HllResponse response = update.Response;
Assert.AreEqual(3, response.Cardinality);
}
internal static Cell FromTsCell(TsCell tsc)
{
if (tsc.boolean_valueSpecified)
{
return(new Cell <bool>(tsc.boolean_value));
}
else if (tsc.double_valueSpecified)
{
return(new Cell <double>(tsc.double_value));
}
else if (tsc.sint64_valueSpecified)
{
return(new Cell <long>(tsc.sint64_value));
}
else if (tsc.timestamp_valueSpecified)
{
return(new Cell <DateTime>(
DateTimeUtil.FromUnixTimeMillis(tsc.timestamp_value)));
}
else if (tsc.varchar_valueSpecified)
{
return(new Cell <string>(RiakString.FromBytes(tsc.varchar_value)));
}
return(new Cell());
}
/// <summary>
/// Initializes a new instance of the <see cref="KvCommandOptions"/> class.
/// </summary>
/// <param name="bucketType">The bucket type in Riak. Required.</param>
/// <param name="bucket">The bucket in Riak. Required.</param>
/// <param name="key">The key in Riak.</param>
/// <param name="keyIsRequired">If <b>true</b> and no key given, an exception is thrown.</param>
public KvCommandOptions(
string bucketType,
string bucket,
string key,
bool keyIsRequired)
{
if (string.IsNullOrEmpty(bucketType))
{
throw new ArgumentNullException("bucketType");
}
else
{
this.bucketType = bucketType;
}
if (string.IsNullOrEmpty(bucket))
{
throw new ArgumentNullException("bucket");
}
else
{
this.bucket = bucket;
}
if (keyIsRequired && string.IsNullOrEmpty(key))
{
throw new ArgumentNullException("key");
}
else
{
this.key = key;
}
}
public void Should_Construct_PreflistResponse_From_Resp()
{
string node_name = "node-foo";
long partitionId = long.MaxValue;
var preflistItem = new RpbBucketKeyPreflistItem();
preflistItem.node = RiakString.ToBytes(node_name);
preflistItem.partition = partitionId;
preflistItem.primary = true;
var fetchResp = new RpbGetBucketKeyPreflistResp();
fetchResp.preflist.Add(preflistItem);
var fetch = new FetchPreflist.Builder()
.WithBucketType(BucketType)
.WithBucket(Bucket)
.WithKey(Key)
.Build();
fetch.OnSuccess(fetchResp);
Assert.AreEqual(1, fetch.Response.Value.Count());
}
public void Should_Build_Req()
{
var cmd = new Get.Builder()
.WithTable(Table)
.WithKey(Key)
.Build();
Assert.AreEqual(MessageCode.TsGetResp, cmd.ExpectedCode);
TsGetReq pb = (TsGetReq)cmd.ConstructPbRequest();
Assert.AreEqual(Table, RiakString.FromBytes(pb.table));
Assert.IsFalse(pb.timeoutSpecified);
Assert.True(pb.key[0].boolean_valueSpecified);
Assert.AreEqual(Cells0[0].AsObject, pb.key[0].boolean_value);
Assert.True(pb.key[1].double_valueSpecified);
Assert.AreEqual(Cells0[1].AsObject, pb.key[1].double_value);
Assert.True(pb.key[2].sint64_valueSpecified);
Assert.AreEqual(Cells0[2].AsObject, pb.key[2].sint64_value);
var dt = (DateTime)Cells0[3].AsObject;
Assert.True(pb.key[3].timestamp_valueSpecified);
Assert.AreEqual(DateTimeUtil.ToUnixTimeMillis(dt), pb.key[3].timestamp_value);
var s = RiakString.ToBytes((string)Cells0[4].AsObject);
Assert.True(pb.key[4].varchar_valueSpecified);
CollectionAssert.AreEqual(s, pb.key[4].varchar_value);
}
public void Should_Construct_SetResponse_From_DtFetchResp()
{
var set_item_1 = new RiakString("set_item_1");
var set_item_2 = new RiakString("set_item_2");
var value = new DtValue();
value.set_value.Add(set_item_1);
value.set_value.Add(set_item_2);
var fetchResp = new DtFetchResp();
fetchResp.value = value;
fetchResp.type = DtFetchResp.DataType.SET;
var fetch = new FetchSet.Builder()
.WithBucketType(BucketType)
.WithBucket(Bucket)
.WithKey(Key)
.Build();
fetch.OnSuccess(fetchResp);
var itemList = fetch.Response.Value.Select(v => new RiakString(v)).ToList();
Assert.AreEqual(set_item_1, itemList[0]);
Assert.AreEqual(set_item_2, itemList[1]);
}
public MapOperation RemoveSet(RiakString key)
{
addToSets.Remove(key);
removeFromSets.Remove(key);
removeSets.Add(key);
return(this);
}
public void Should_Construct_CounterResponse_From_DtUpdateResp()
{
var key = new RiakString("riak_generated_key");
var context = new RiakString("1234");
var updateResp = new DtUpdateResp();
updateResp.key = key;
updateResp.context = context;
updateResp.counter_value = DefaultIncrement;
var update = new UpdateCounter.Builder(DefaultIncrement)
.WithBucketType(BucketType)
.WithBucket(Bucket)
.Build();
update.OnSuccess(updateResp);
CounterResponse response = update.Response;
Assert.NotNull(response);
Assert.AreEqual(key, response.Key);
Assert.AreEqual(RiakString.ToBytes(context), response.Context);
Assert.AreEqual(DefaultIncrement, response.Value);
}
public void Can_Construct_From_Null()
{
var rs = new RiakString((byte[])null);
Assert.False(rs.HasValue);
Assert.IsNull((byte[])rs);
Assert.IsNull(rs.ToString());
}
internal TsColumnDescription ToTsColumn()
{
return(new TsColumnDescription
{
name = RiakString.ToBytes(name),
type = (TsColumnType)type
});
}
public void Can_Construct_From_Null()
{
var rs = new RiakString((byte[])null);
Assert.False(rs.HasValue);
Assert.IsNull((byte[])rs);
Assert.IsNull(rs.ToString());
}
public Cell(object value, ColumnType valueType)
{
if (value == null)
{
isNull = true;
this.valueType = ColumnType.Null;
}
else
{
this.valueType = valueType;
switch (valueType)
{
case ColumnType.Boolean:
booleanValue = Convert.ToBoolean(value);
break;
case ColumnType.Double:
doubleValue = Convert.ToDouble(value);
break;
case ColumnType.SInt64:
sint64Value = Convert.ToInt64(value);
break;
case ColumnType.Timestamp:
if (value is DateTime)
{
timestampValue = DateTimeUtil.ToUnixTimeMillis((DateTime)value);
}
else
{
timestampValue = Convert.ToInt64(value);
}
break;
case ColumnType.Varchar:
case ColumnType.Blob:
var bytes = value as byte[];
if (bytes != null)
{
varcharValue = bytes;
}
else
{
var s = Convert.ToString(value);
varcharValue = RiakString.ToBytes(s);
}
break;
default:
string msg = string.Format("Unknown value type: {0}", valueType);
throw new ArgumentException(msg);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TimeseriesCommandOptions"/> class.
/// </summary>
/// <param name="table">The table in Riak TS. Required.</param>
public TimeseriesCommandOptions(string table)
{
if (string.IsNullOrEmpty(table))
{
throw new ArgumentNullException("table");
}
this.table = table;
}
public void Add(RiakString key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
this[key] = default(TValue);
}
public Cell(string value)
{
if (value == null)
{
throw new ArgumentNullException("value", "Value must not be null.");
}
varcharValue = RiakString.ToBytes(value);
valueType = ColumnType.Varchar;
}
public void Can_Convert_To_Boolean_To_Indicate_Non_Null_Value()
{
var rs = new RiakString(testString);
Assert.True(rs);
Assert.True(rs.HasValue);
rs = new RiakString((string)null);
Assert.False(rs);
Assert.False(rs.HasValue);
}
public MapOperation RemoveFromSet(RiakString key, IEnumerable <RiakString> values)
{
removeSets.Remove(key);
foreach (var value in values)
{
removeFromSets.Add(key, value);
}
return(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="PreflistItem"/> class.
/// </summary>
/// <param name="node">A <see cref="RiakString"/> representing the node owning the partition.</param>
/// <param name="id">The partition ID.</param>
/// <param name="primary">Will be <b>true</b> if this is a primary node for the partition.</param>
public PreflistItem(RiakString node, long id, bool primary)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
this.node = node;
this.id = id;
this.primary = primary;
}
public void Can_Convert_To_Boolean_To_Indicate_Non_Null_Value()
{
var rs = new RiakString(testString);
Assert.True(rs);
Assert.True(rs.HasValue);
rs = new RiakString((string)null);
Assert.False(rs);
Assert.False(rs.HasValue);
}
/// <summary>
/// Initializes a new instance of the <see cref="PreflistItem"/> class.
/// </summary>
/// <param name="node">A <see cref="RiakString"/> representing the node owning the partition.</param>
/// <param name="id">The partition ID.</param>
/// <param name="primary">Will be <b>true</b> if this is a primary node for the partition.</param>
public PreflistItem(RiakString node, long id, bool primary)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
this.node = node;
this.id = id;
this.primary = primary;
}
public void Increment(RiakString key, long increment)
{
if (this.ContainsKey(key))
{
this[key] += increment;
}
else
{
this[key] = increment;
}
}
public void Add(RiakString key, byte[] value)
{
IList <byte[]> values = null;
if (!this.TryGetValue(key, out values))
{
values = new List <byte[]>();
this[key] = values;
}
values.Add(value);
}
public void Are_Equatable()
{
TsCell c0 = new TsCell {
boolean_value = Boolean0
};
TsCell c1 = new TsCell {
boolean_value = Boolean0
};
Assert.AreEqual(c0, c1, string.Format("c0 {0} c1 {1}", c0, c1));
c0 = new TsCell {
double_value = Double0
};
c1 = new TsCell {
double_value = Double0
};
Assert.AreEqual(c0, c1, string.Format("c0 {0} c1 {1}", c0, c1));
c0 = new TsCell {
sint64_value = Long0
};
c1 = new TsCell {
sint64_value = Long0
};
Assert.AreEqual(c0, c1, string.Format("c0 {0} c1 {1}", c0, c1));
var ut = DateTimeUtil.ToUnixTimeMillis(Timestamp0);
c0 = new TsCell {
timestamp_value = ut
};
c1 = new TsCell {
timestamp_value = ut
};
Assert.AreEqual(c0, c1, string.Format("c0 {0} c1 {1}", c0, c1));
c0 = new TsCell {
varchar_value = RiakString.ToBytes(Varchar0)
};
c1 = new TsCell {
varchar_value = RiakString.ToBytes(Varchar0)
};
Assert.AreEqual(c0, c1, string.Format("c0 {0} c1 {1}", c0, c1));
c0 = new TsCell {
varchar_value = Blob0
};
c1 = new TsCell {
varchar_value = Blob0
};
Assert.AreEqual(c0, c1, string.Format("c0 {0} c1 {1}", c0, c1));
}
public IEnumerable <RiakString> GetValueAsRiakStrings(RiakString key)
{
IEnumerable <RiakString> valueAsRiakStrings = null;
IList <byte[]> value = null;
if (TryGetValue(key, out value))
{
valueAsRiakStrings = value.Select(v => RiakString.FromBytes(v));
}
return(valueAsRiakStrings);
}
public void Should_Build_Req_With_Timeout()
{
Get cmd = BuildGetReqWithTimeout();
Assert.AreEqual(MessageCode.TsGetResp, cmd.ExpectedCode);
TsGetReq pb = (TsGetReq)cmd.ConstructRequest(false);
Assert.AreEqual(Table, RiakString.FromBytes(pb.table));
Assert.IsTrue(pb.timeoutSpecified);
Assert.AreEqual(Timeout.TotalMilliseconds, pb.timeout);
}
public RiakString GetValueAsRiakString(RiakString key)
{
RiakString valueAsRiakString = null;
byte[] value = null;
if (TryGetValue(key, out value))
{
valueAsRiakString = new RiakString(value);
}
return(valueAsRiakString);
}
public long GetValue(RiakString key)
{
long value;
if (TryGetValue(key, out value))
{
return(value);
}
else
{
return(default(long));
}
}
public void Should_Build_Req()
{
var cmd = new ListKeys.Builder()
.WithTable(Table)
.Build();
Assert.AreEqual(MessageCode.TsListKeysResp, cmd.ExpectedCode);
TsListKeysReq pb = (TsListKeysReq)cmd.ConstructPbRequest();
Assert.AreEqual(Table, RiakString.FromBytes(pb.table));
Assert.IsFalse(pb.timeoutSpecified);
}
protected RiakString GetKey(RiakString optskey, RiakResp response)
{
RiakString key = optskey;
IRpbGeneratedKey krsp = response as IRpbGeneratedKey;
if (krsp != null && krsp.HasKey)
{
key = new RiakString(krsp.key);
}
return(key);
}
/// <summary>
/// Initializes a new instance of the <see cref="Response"/> class.
/// </summary>
/// <param name="key">A <see cref="RiakString"/> representing the key.</param>
public Response(RiakString key)
{
if (key == null)
{
throw new ArgumentNullException("key", "key is required!");
}
else
{
this.key = key;
}
this.notFound = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="Response"/> class.
/// </summary>
/// <param name="key">A <see cref="RiakString"/> representing the key.</param>
public Response(RiakString key)
{
if (key == null)
{
throw new ArgumentNullException("key", "key is required!");
}
else
{
this.key = key;
}
this.notFound = false;
}
public void Should_Build_Req()
{
Store cmd = BuildStoreReq();
Assert.AreEqual(MessageCode.TsPutResp, cmd.ExpectedCode);
TsPutReq pb = (TsPutReq)cmd.ConstructPbRequest();
Assert.AreEqual(Table, RiakString.FromBytes(pb.table));
CollectionAssert.AreEqual(TsCols, pb.columns);
CollectionAssert.AreEqual(TsRows, pb.rows);
}
public override string Save(User model)
{
var mapOperation = new UpdateMap.MapOperation();
mapOperation.SetRegister(firstNameRegister, model.FirstName);
mapOperation.SetRegister(lastNameRegister, model.LastName);
mapOperation.IncrementCounter(pageVisitsCounter, model.PageVisits);
mapOperation.AddToSet(interestsSet, model.Interests);
// Insert does not require context
RiakString key = UpdateMap(model, mapOperation, fetchFirst: false);
return((string)key);
}
public MapOperation Map(RiakString key)
{
removeMaps.Remove(key);
MapOperation mapOp;
if (!maps.TryGetValue(key, out mapOp))
{
mapOp = new MapOperation();
maps.Add(key, mapOp);
}
return(mapOp);
}
public void Can_Update_A_Set()
{
string key = Guid.NewGuid().ToString();
SetResponse resp = SaveSet(key);
var add_3 = new RiakString("add_3");
var adds = new HashSet<string> { add_3 };
var add_1 = new RiakString("add_1");
var removes = new HashSet<string> { add_1 };
var update = new UpdateSet.Builder(adds, removes)
.WithBucketType(BucketType)
.WithBucket(Bucket)
.WithKey(key)
.WithContext(resp.Context)
.WithReturnBody(true)
.WithTimeout(TimeSpan.FromMilliseconds(20000))
.Build();
RiakResult rslt = client.Execute(update);
Assert.IsTrue(rslt.IsSuccess, rslt.ErrorMessage);
SetResponse response = update.Response;
bool found_add_1 = false;
bool found_add_3 = false;
foreach (RiakString value in response.Value)
{
if (value.Equals(add_1))
{
found_add_1 = true;
}
if (value.Equals(add_3))
{
found_add_3 = true;
}
}
Assert.True(found_add_3);
Assert.False(found_add_1);
}
public ServerInfo(RiakString node, RiakString serverVersion)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
else
{
this.node = node;
}
if (serverVersion == null)
{
throw new ArgumentNullException("serverVersion");
}
else
{
this.serverVersion = serverVersion;
}
}
public void Should_Construct_HllResponse_From_DtUpdateResp()
{
var key = new RiakString("riak_generated_key");
var updateResp = new DtUpdateResp();
updateResp.key = key;
updateResp.hll_value = 42;
var update = new UpdateHll.Builder(DefaultAdds)
.WithBucketType(BucketType)
.WithBucket(Bucket)
.Build();
update.OnSuccess(updateResp);
HllResponse response = update.Response;
Assert.NotNull(response);
Assert.AreEqual(key, response.Key);
Assert.AreEqual(42, response.Value);
}
public void Can_Update_A_Hll()
{
string key = Guid.NewGuid().ToString();
SaveHll(key);
var add_3 = new RiakString("add_3");
var adds = new HashSet<string> { add_3 };
var update = new UpdateHll.Builder(adds)
.WithBucketType(BucketType)
.WithBucket(Bucket)
.WithKey(key)
.WithReturnBody(true)
.WithTimeout(TimeSpan.FromMilliseconds(20000))
.Build();
RiakResult rslt = client.Execute(update);
Assert.IsTrue(rslt.IsSuccess, rslt.ErrorMessage);
HllResponse response = update.Response;
Assert.AreEqual(3, response.Cardinality);
}
public void Should_Construct_CounterResponse_From_DtUpdateResp()
{
var key = new RiakString("riak_generated_key");
var context = new RiakString("1234");
var updateResp = new DtUpdateResp();
updateResp.key = key;
updateResp.context = context;
updateResp.counter_value = DefaultIncrement;
var update = new UpdateCounter.Builder(DefaultIncrement)
.WithBucketType(BucketType)
.WithBucket(Bucket)
.Build();
update.OnSuccess(updateResp);
CounterResponse response = update.Response;
Assert.NotNull(response);
Assert.AreEqual(key, response.Key);
Assert.AreEqual(RiakString.ToBytes(context), response.Context);
Assert.AreEqual(DefaultIncrement, response.Value);
}
public void Should_Construct_SetResponse_From_DtFetchResp()
{
var set_item_1 = new RiakString("set_item_1");
var set_item_2 = new RiakString("set_item_2");
var value = new DtValue();
value.set_value.Add(set_item_1);
value.set_value.Add(set_item_2);
var fetchResp = new DtFetchResp();
fetchResp.value = value;
fetchResp.type = DtFetchResp.DataType.SET;
var fetch = new FetchSet.Builder()
.WithBucketType(BucketType)
.WithBucket(Bucket)
.WithKey(Key)
.Build();
fetch.OnSuccess(fetchResp);
var itemList = fetch.Response.Value.Select(v => new RiakString(v)).ToList();
Assert.AreEqual(set_item_1, itemList[0]);
Assert.AreEqual(set_item_2, itemList[1]);
}
public void Should_Construct_SetResponse_From_DtUpdateResp()
{
var key = new RiakString("riak_generated_key");
var updateResp = new DtUpdateResp();
updateResp.key = key;
updateResp.context = Context;
updateResp.set_value.AddRange(DefaultAdds);
var update = new UpdateSet.Builder(DefaultAdds, null)
.WithBucketType(BucketType)
.WithBucket(Bucket)
.Build();
update.OnSuccess(updateResp);
SetResponse response = update.Response;
Assert.NotNull(response);
Assert.AreEqual(key, response.Key);
Assert.AreEqual(Context, response.Context);
Assert.AreEqual(DefaultAdds, response.Value);
}
public void Should_Construct_MapResponse_From_DtFetchResp()
{
var key = new RiakString("riak_generated_key");
var context = new RiakString("1234");
var fetchResp = new DtFetchResp();
fetchResp.type = DtFetchResp.DataType.MAP;
fetchResp.value = new DtValue();
fetchResp.context = context;
Func<IEnumerable<MapEntry>> createMapEntries = () =>
{
var mapEntries = new List<MapEntry>();
var mapField = new MapField();
mapField.type = MapField.MapFieldType.COUNTER;
mapField.name = new RiakString("counter_1");
var mapEntry = new MapEntry();
mapEntry.field = mapField;
mapEntry.counter_value = 50;
mapEntries.Add(mapEntry);
mapField = new MapField();
mapField.type = MapField.MapFieldType.SET;
mapField.name = new RiakString("set_1");
mapEntry = new MapEntry();
mapEntry.field = mapField;
mapEntry.set_value.Add(RiakString.ToBytes("value_1"));
mapEntry.set_value.Add(RiakString.ToBytes("value_2"));
mapEntries.Add(mapEntry);
mapField = new MapField();
mapField.type = MapField.MapFieldType.REGISTER;
mapField.name = new RiakString("register_1");
mapEntry = new MapEntry();
mapEntry.field = mapField;
mapEntry.register_value = RiakString.ToBytes("1234");
mapEntries.Add(mapEntry);
mapField = new MapField();
mapField.type = MapField.MapFieldType.FLAG;
mapField.name = new RiakString("flag_1");
mapEntry = new MapEntry();
mapEntry.field = mapField;
mapEntry.flag_value = true;
mapEntries.Add(mapEntry);
return mapEntries;
};
fetchResp.value.map_value.AddRange(createMapEntries());
var map_1_field = new MapField();
map_1_field.type = MapField.MapFieldType.MAP;
map_1_field.name = new RiakString("map_1");
var map_1_entry = new MapEntry();
map_1_entry.field = map_1_field;
map_1_entry.map_value.AddRange(createMapEntries());
fetchResp.value.map_value.Add(map_1_entry);
Action<Map> verifyMap = (map) =>
{
Assert.AreEqual(50, map.Counters["counter_1"]);
Assert.AreEqual(RiakString.ToBytes("value_1"), map.Sets["set_1"][0]);
Assert.AreEqual(RiakString.ToBytes("value_2"), map.Sets["set_1"][1]);
Assert.AreEqual(RiakString.ToBytes("1234"), map.Registers["register_1"]);
Assert.IsTrue(map.Flags["flag_1"]);
};
var fetch = new FetchMap.Builder()
.WithBucketType(BucketType)
.WithBucket(Bucket)
.WithKey(key)
.Build();
fetch.OnSuccess(fetchResp);
MapResponse response = fetch.Response;
Assert.NotNull(response);
Assert.AreEqual(key, response.Key);
Assert.AreEqual(RiakString.ToBytes(context), response.Context);
verifyMap(response.Value);
verifyMap(response.Value.Maps["map_1"]);
}
public void Can_Construct_From_Byte_Array()
{
var rs = new RiakString(testBytes);
Assert.AreEqual(testBytes, (byte[])rs);
}
public void Can_Cast_To_Byte_Array()
{
var rs = new RiakString(testString);
Assert.AreEqual(testBytes, (byte[])rs);
}
