/// <summary>
/// Create map put items operation
/// Server writes each map item to map bin and returns map size.
/// <para>
/// The required map policy dictates the type of map to create when it does not exist.
/// The map policy also specifies the flags used when writing items to the map.
/// See policy <seealso cref="Aerospike.Client.MapPolicy"/>.
/// </para>
/// </summary>
public static Operation PutItems(MapPolicy policy, string binName, IDictionary map)
{
Packer packer = new Packer();
if (policy.flags != 0)
{
packer.PackRawShort(PUT_ITEMS);
packer.PackArrayBegin(3);
packer.PackMap(map);
packer.PackNumber(policy.attributes);
packer.PackNumber(policy.flags);
}
else
{
packer.PackRawShort(policy.itemsCommand);
if (policy.itemsCommand == REPLACE_ITEMS)
{
// Replace doesn't allow map attributes because it does not create on non-existing key.
packer.PackArrayBegin(1);
packer.PackMap(map);
}
else
{
packer.PackArrayBegin(2);
packer.PackMap(map);
packer.PackNumber(policy.attributes);
}
}
return(new Operation(Operation.Type.MAP_MODIFY, binName, Value.Get(packer.ToByteArray())));
}
/// <summary>
/// Create map put items operation
/// Server writes each map item to map bin and returns map size.
/// <para>
/// The required map policy dictates the type of map to create when it does not exist.
/// The map policy also specifies the flags used when writing items to the map.
/// See policy <seealso cref="Aerospike.Client.MapPolicy"/>.
/// </para>
/// </summary>
public static Operation PutItems(MapPolicy policy, string binName, IDictionary map, params CTX[] ctx)
{
Packer packer = new Packer();
if (policy.flags != 0)
{
CDT.Init(packer, ctx, PUT_ITEMS, 3);
packer.PackMap(map);
packer.PackNumber(policy.attributes);
packer.PackNumber(policy.flags);
}
else
{
if (policy.itemsCommand == REPLACE_ITEMS)
{
// Replace doesn't allow map attributes because it does not create on non-existing key.
CDT.Init(packer, ctx, policy.itemsCommand, 1);
packer.PackMap(map);
}
else
{
CDT.Init(packer, ctx, policy.itemsCommand, 2);
packer.PackMap(map);
packer.PackNumber(policy.attributes);
}
}
return(new Operation(Operation.Type.MAP_MODIFY, binName, Value.Get(packer.ToByteArray())));
}
/// <summary>
/// Create map put operation.
/// Server writes key/value item to map bin and returns map size.
/// <para>
/// The required map policy dictates the type of map to create when it does not exist.
/// The map policy also specifies the mode used when writing items to the map.
/// See policy <seealso cref="Aerospike.Client.MapPolicy"/> and write mode
/// <seealso cref="Aerospike.Client.MapWriteMode"/>.
/// </para>
/// </summary>
public static Operation Put(MapPolicy policy, string binName, Value key, Value value)
{
Packer packer = new Packer();
packer.PackRawShort(policy.itemCommand);
if (policy.itemCommand == REPLACE)
{
// Replace doesn't allow map attributes because it does not create on non-existing key.
packer.PackArrayBegin(2);
key.Pack(packer);
value.Pack(packer);
}
else
{
packer.PackArrayBegin(3);
key.Pack(packer);
value.Pack(packer);
packer.PackNumber(policy.attributes);
}
return(new Operation(Operation.Type.MAP_MODIFY, binName, Value.Get(packer.ToByteArray())));
}
/// <summary>
/// Create map put operation.
/// Server writes key/value item to map bin and returns map size.
/// <para>
/// The required map policy dictates the type of map to create when it does not exist.
/// The map policy also specifies the flags used when writing items to the map.
/// See policy <see cref="Aerospike.Client.MapPolicy"/>.
/// </para>
/// </summary>
public static Operation Put(MapPolicy policy, string binName, Value key, Value value, params CTX[] ctx)
{
Packer packer = new Packer();
if (policy.flags != 0)
{
PackUtil.Init(packer, ctx);
packer.PackArrayBegin(5);
packer.PackNumber(MapOperation.PUT);
key.Pack(packer);
value.Pack(packer);
packer.PackNumber(policy.attributes);
packer.PackNumber(policy.flags);
}
else
{
if (policy.itemCommand == REPLACE)
{
// Replace doesn't allow map attributes because it does not create on non-existing key.
PackUtil.Init(packer, ctx);
packer.PackArrayBegin(3);
packer.PackNumber(policy.itemCommand);
key.Pack(packer);
value.Pack(packer);
}
else
{
PackUtil.Init(packer, ctx);
packer.PackArrayBegin(4);
packer.PackNumber(policy.itemCommand);
key.Pack(packer);
value.Pack(packer);
packer.PackNumber(policy.attributes);
}
}
byte[] bytes = packer.ToByteArray();
return(new Operation(Operation.Type.MAP_MODIFY, binName, Value.Get(bytes)));
}
/// <summary>
/// Create map decrement operation.
/// Server decrements values by decr for all items identified by key and returns final result.
/// Valid only for numbers.
/// <para>
/// The required map policy dictates the type of map to create when it does not exist.
/// The map policy also specifies the mode used when writing items to the map.
/// See policy <seealso cref="Aerospike.Client.MapPolicy"/> and write mode
/// <seealso cref="Aerospike.Client.MapWriteMode"/>.
/// </para>
/// </summary>
public static Operation Decrement(MapPolicy policy, string binName, Value key, Value decr)
{
return MapBase.CreateOperation(MapBase.DECREMENT, policy.attributes, binName, key, decr);
}
/// <summary>
/// Create set map policy operation.
/// Server sets map policy attributes. Server returns null.
/// <para>
/// The required map policy attributes can be changed after the map is created.
/// </para>
/// </summary>
public static Operation SetMapPolicy(MapPolicy policy, string binName)
{
return MapBase.SetMapPolicy(binName, policy.attributes);
}
/// <summary>
/// Create map put items operation
/// Server writes each map item to map bin and returns map size.
/// <para>
/// The required map policy dictates the type of map to create when it does not exist.
/// The map policy also specifies the mode used when writing items to the map.
/// See policy <seealso cref="Aerospike.Client.MapPolicy"/> and write mode
/// <seealso cref="Aerospike.Client.MapWriteMode"/>.
/// </para>
/// </summary>
public static Operation PutItems(MapPolicy policy, string binName, IDictionary map)
{
Packer packer = new Packer();
packer.PackRawShort(policy.itemsCommand);
if (policy.itemsCommand == MapBase.REPLACE_ITEMS)
{
// Replace doesn't allow map attributes because it does not create on non-existing key.
packer.PackArrayBegin(1);
packer.PackMap(map);
}
else
{
packer.PackArrayBegin(2);
packer.PackMap(map);
packer.PackNumber(policy.attributes);
}
return new Operation(Operation.Type.MAP_MODIFY, binName, Value.Get(packer.ToByteArray()));
}
/// <summary>
/// Create map put operation.
/// Server writes key/value item to map bin and returns map size.
/// <para>
/// The required map policy dictates the type of map to create when it does not exist.
/// The map policy also specifies the mode used when writing items to the map.
/// See policy <seealso cref="Aerospike.Client.MapPolicy"/> and write mode
/// <seealso cref="Aerospike.Client.MapWriteMode"/>.
/// </para>
/// </summary>
public static Operation Put(MapPolicy policy, string binName, Value key, Value value)
{
return MapBase.CreatePut(policy.itemCommand, policy.attributes, binName, key, value);
}
/// <summary>
/// Create set map policy operation.
/// Server sets map policy attributes. Server returns null.
/// <para>
/// The required map policy attributes can be changed after the map is created.
/// </para>
/// </summary>
public static Operation SetMapPolicy(MapPolicy policy, string binName)
{
return(MapBase.SetMapPolicy(binName, policy.attributes));
}
/// <summary>
/// Create map decrement operation.
/// Server decrements values by decr for all items identified by key and returns final result.
/// Valid only for numbers.
/// <para>
/// The required map policy dictates the type of map to create when it does not exist.
/// The map policy also specifies the mode used when writing items to the map.
/// See policy <seealso cref="Aerospike.Client.MapPolicy"/> and write mode
/// <seealso cref="Aerospike.Client.MapWriteMode"/>.
/// </para>
/// </summary>
public static Operation Decrement(MapPolicy policy, string binName, Value key, Value decr)
{
return(MapBase.CreateOperation(MapBase.DECREMENT, policy.attributes, binName, key, decr));
}
public void OperateMapScore()
{
// Test score.
if (!args.ValidateMap())
{
return;
}
Key key = new Key(args.ns, args.set, "opmkey10");
client.Delete(null, key);
MapPolicy mapPolicy = new MapPolicy(MapOrder.KEY_VALUE_ORDERED, MapWriteMode.UPDATE);
Dictionary<Value, Value> inputMap = new Dictionary<Value, Value>();
inputMap[Value.Get("weiling")] = Value.Get(0);
inputMap[Value.Get("briann")] = Value.Get(0);
inputMap[Value.Get("brianb")] = Value.Get(0);
inputMap[Value.Get("meher")] = Value.Get(0);
// Create map.
Record record = client.Operate(null, key, MapOperation.PutItems(mapPolicy, binName, inputMap));
AssertRecordFound(key, record);
// Change scores
record = client.Operate(null, key,
MapOperation.Increment(mapPolicy, binName, Value.Get("weiling"), Value.Get(10)),
MapOperation.Increment(mapPolicy, binName, Value.Get("briann"), Value.Get(20)),
MapOperation.Increment(mapPolicy, binName, Value.Get("brianb"), Value.Get(1)),
MapOperation.Increment(mapPolicy, binName, Value.Get("meher"), Value.Get(20))
);
AssertRecordFound(key, record);
// Query top 3 scores
record = client.Operate(null, key, MapOperation.GetByRankRange(binName, -3, 3, MapReturnType.KEY));
AssertRecordFound(key, record);
// Remove people with score 10 and display top 3 again
record = client.Operate(null, key,
MapOperation.RemoveByValue(binName, Value.Get(10), MapReturnType.KEY),
MapOperation.GetByRankRange(binName, -3, 3, MapReturnType.KEY)
);
AssertRecordFound(key, record);
IList results = record.GetList(binName);
int i = 0;
IList list = (IList)results[i++];
string s = (string)list[0];
Assert.AreEqual("weiling", s);
list = (IList)results[i++];
s = (string)list[0];
Assert.AreEqual("brianb", s);
s = (string)list[1];
Assert.AreEqual("briann", s);
s = (string)list[2];
Assert.AreEqual("meher", s);
}
public void OperateMapPutItems()
{
if (!args.ValidateMap())
{
return;
}
Key key = new Key(args.ns, args.set, "opmkey2");
client.Delete(null, key);
Dictionary<Value, Value> addMap = new Dictionary<Value, Value>();
addMap[Value.Get(12)] = Value.Get("myval");
addMap[Value.Get(-8734)] = Value.Get("str2");
addMap[Value.Get(1)] = Value.Get("my default");
Dictionary<Value, Value> putMap = new Dictionary<Value, Value>();
putMap[Value.Get(12)] = Value.Get("myval12222");
putMap[Value.Get(13)] = Value.Get("str13");
Dictionary<Value, Value> updateMap = new Dictionary<Value, Value>();
updateMap[Value.Get(13)] = Value.Get("myval2");
updateMap[Value.Get(14)] = Value.Get("str14");
Dictionary<Value, Value> replaceMap = new Dictionary<Value, Value>();
replaceMap[Value.Get(12)] = Value.Get(23);
replaceMap[Value.Get(-8734)] = Value.Get("changed");
MapPolicy putMode = MapPolicy.Default;
MapPolicy addMode = new MapPolicy(MapOrder.KEY_ORDERED, MapWriteMode.CREATE_ONLY);
MapPolicy updateMode = new MapPolicy(MapOrder.KEY_ORDERED, MapWriteMode.UPDATE_ONLY);
Record record = client.Operate(null, key,
MapOperation.PutItems(addMode, binName, addMap),
MapOperation.PutItems(putMode, binName, putMap),
MapOperation.PutItems(updateMode, binName, updateMap),
MapOperation.PutItems(updateMode, binName, replaceMap),
MapOperation.GetByKey(binName, Value.Get(1), MapReturnType.VALUE),
MapOperation.GetByKey(binName, Value.Get(-8734), MapReturnType.VALUE),
MapOperation.GetByKeyRange(binName, Value.Get(12), Value.Get(15), MapReturnType.KEY_VALUE)
);
AssertRecordFound(key, record);
IList results = record.GetList(binName);
int i = 0;
long size = (long)results[i++];
Assert.AreEqual(3, size);
size = (long)results[i++];
Assert.AreEqual(4, size);
size = (long)results[i++];
Assert.AreEqual(4, size);
size = (long)results[i++];
Assert.AreEqual(4, size);
string str = (string)results[i++];
Assert.AreEqual("my default", str);
str = (string)results[i++];
Assert.AreEqual("changed", str);
IList list = (IList)results[i++];
Assert.AreEqual(2, list.Count);
}
public void OperateMapPut()
{
if (! args.ValidateMap()) {
return;
}
Key key = new Key(args.ns, args.set, "opmkey1");
client.Delete(null, key);
MapPolicy putMode = MapPolicy.Default;
MapPolicy addMode = new MapPolicy(MapOrder.UNORDERED, MapWriteMode.CREATE_ONLY);
MapPolicy updateMode = new MapPolicy(MapOrder.UNORDERED, MapWriteMode.UPDATE_ONLY);
MapPolicy orderedUpdateMode = new MapPolicy(MapOrder.KEY_ORDERED, MapWriteMode.UPDATE_ONLY);
// Calling put() multiple times performs poorly because the server makes
// a copy of the map for each call, but we still need to test it.
// putItems() should be used instead for best performance.
Record record = client.Operate(null, key,
MapOperation.Put(putMode, binName, Value.Get(11), Value.Get(789)),
MapOperation.Put(putMode, binName, Value.Get(10), Value.Get(999)),
MapOperation.Put(addMode, binName, Value.Get(12), Value.Get(500)),
MapOperation.Put(addMode, binName, Value.Get(15), Value.Get(1000)),
// Ordered type should be ignored since map has already been created in first put().
MapOperation.Put(orderedUpdateMode, binName, Value.Get(10), Value.Get(1)),
MapOperation.Put(updateMode, binName, Value.Get(77), Value.Get(5))
);
AssertRecordFound(key, record);
IList results = record.GetList(binName);
int i = 0;
long size = (long)results[i++];
Assert.AreEqual(1, size);
size = (long)results[i++];
Assert.AreEqual(2, size);
size = (long)results[i++];
Assert.AreEqual(3, size);
size = (long)results[i++];
Assert.AreEqual(4, size);
size = (long)results[i++];
Assert.AreEqual(4, size);
size = (long)results[i++];
Assert.AreEqual(4, size);
record = client.Get(null, key, binName);
IDictionary map = record.GetMap(binName);
Assert.AreEqual(4, map.Count);
Assert.AreEqual(1L, map[10L]);
}
public static Operation Decrement(MapPolicy policy, string binName, Value key, Value decr, params CTX[] ctx)
{
byte[] bytes = PackUtil.Pack(MapOperation.DECREMENT, key, decr, policy.attributes, ctx);
return(new Operation(Operation.Type.MAP_MODIFY, binName, Value.Get(bytes)));
}
/// <summary>
/// Create map increment operation.
/// Server increments values by incr for all items identified by key and returns final result.
/// Valid only for numbers.
/// <para>
/// The required map policy dictates the type of map to create when it does not exist.
/// The map policy also specifies the mode used when writing items to the map.
/// See policy <seealso cref="Aerospike.Client.MapPolicy"/> and write mode
/// <seealso cref="Aerospike.Client.MapWriteMode"/>.
/// </para>
/// </summary>
public static Operation Increment(MapPolicy policy, string binName, Value key, Value incr)
{
return(CDT.CreateOperation(INCREMENT, Operation.Type.MAP_MODIFY, binName, key, incr, policy.attributes));
}
/// <summary>
/// Create set map policy operation.
/// Server sets map policy attributes. Server returns null.
/// <para>
/// The required map policy attributes can be changed after the map is created.
/// </para>
/// </summary>
public static Operation SetMapPolicy(MapPolicy policy, string binName, params CTX[] ctx)
{
return(CDT.CreateOperation(SET_TYPE, Operation.Type.MAP_MODIFY, binName, ctx, policy.attributes));
}
/// <summary>
/// Create map put operation.
/// Server writes key/value item to map bin and returns map size.
/// <para>
/// The required map policy dictates the type of map to create when it does not exist.
/// The map policy also specifies the mode used when writing items to the map.
/// See policy <seealso cref="Aerospike.Client.MapPolicy"/> and write mode
/// <seealso cref="Aerospike.Client.MapWriteMode"/>.
/// </para>
/// </summary>
public static Operation Put(MapPolicy policy, string binName, Value key, Value value)
{
return(MapBase.CreatePut(policy.itemCommand, policy.attributes, binName, key, value));
}
/// <summary>
/// Create map decrement operation.
/// Server decrements values by decr for all items identified by key and returns final result.
/// Valid only for numbers.
/// <para>
/// The required map policy dictates the type of map to create when it does not exist.
/// The map policy also specifies the mode used when writing items to the map.
/// See policy <seealso cref="Aerospike.Client.MapPolicy"/> and write mode
/// <seealso cref="Aerospike.Client.MapWriteMode"/>.
/// </para>
/// </summary>
public static Operation Decrement(MapPolicy policy, string binName, Value key, Value decr, params CTX[] ctx)
{
return(CDT.CreateOperation(DECREMENT, Operation.Type.MAP_MODIFY, binName, ctx, key, decr, policy.attributes));
}
/// <summary>
/// Create set map policy operation.
/// Server sets map policy attributes. Server returns null.
/// <para>
/// The required map policy attributes can be changed after the map is created.
/// </para>
/// </summary>
public static Operation SetMapPolicy(MapPolicy policy, string binName, params CTX[] ctx)
{
byte[] bytes = PackUtil.Pack(MapOperation.SET_TYPE, policy.attributes, ctx);
return(new Operation(Operation.Type.MAP_MODIFY, binName, Value.Get(bytes)));
}
