public void QueryFilter()
{
string nameFilter = "Bill";
string passFilter = "hknfpkj";
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetFilters(Filter.Equal(binName, nameFilter));
stmt.SetAggregateFunction(Assembly.GetExecutingAssembly(), "Aerospike.Test.Resources.filter_example.lua", "filter_example", "profile_filter", Value.Get(passFilter));
// passFilter will be applied in filter_example.lua.
ResultSet rs = client.QueryAggregate(null, stmt);
try
{
int count = 0;
while (rs.Next())
{
IDictionary map = (IDictionary)rs.Object;
Assert.AreEqual(nameFilter, map["name"]);
Assert.AreEqual(passFilter, map["password"]);
count++;
}
Assert.AreNotEqual(0, count);
}
finally
{
rs.Close();
}
}
public void QueryKey()
{
int begin = 2;
int end = 5;
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetBinNames(binName);
stmt.SetFilters(Filter.Range(binName, begin, end));
RecordSet rs = client.Query(null, stmt);
try
{
int count = 0;
while (rs.Next())
{
Key key = rs.Key;
Assert.IsNotNull(key.userKey);
object userkey = key.userKey.Object;
Assert.IsNotNull(userkey);
count++;
}
Assert.AreEqual(4, count);
}
finally
{
rs.Close();
}
}
public void QueryInteger()
{
int begin = 14;
int end = 18;
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetBinNames(binName);
stmt.SetFilters(Filter.Range(binName, begin, end));
RecordSet rs = client.Query(null, stmt);
try
{
int count = 0;
while (rs.Next())
{
count++;
}
Assert.AreEqual(5, count);
}
finally
{
rs.Close();
}
}
public void InsertByKey()
{
int i = 0;
for (int x = 1; x <= TestQueryEngine.RECORD_COUNT; x++)
{
String keyString = "selector-test:" + x;
Bin name = new Bin("name", "name:" + x);
Bin age = new Bin("age", ages[i]);
Bin colour = new Bin("color", colours[i]);
Bin animal = new Bin("animal", animals[i]);
List<Bin> bins = new List<Bin>() { name, age, colour, animal };
Key key = new Key(TestQueryEngine.NAMESPACE, TestQueryEngine.SET_NAME, keyString);
this.client.Delete(null, key);
KeyQualifier kq = new KeyQualifier(Value.Get(keyString));
Statement stmt = new Statement();
stmt.Namespace = TestQueryEngine.NAMESPACE;
stmt.SetName = TestQueryEngine.SET_NAME;
queryEngine.Insert(stmt, kq, bins);
Record record = this.client.Get(null, key);
Assert.NotNull(record);
i++;
if (i == 5)
i = 0;
}
}
public void selectByKeyNoIndex()
{
// Execute the Query
Statement stmt = new Statement();
stmt.Namespace = TestQueryEngine.NAMESPACE;
stmt.SetName = SET;
Qualifier qual1 = new Qualifier(mapBinNoIndex, Qualifier.FilterOperation.MAP_KEYS_CONTAINS, Value.Get("dogs7"));
KeyRecordEnumerator it = queryEngine.Select(stmt, qual1);
int count2 = 0;
try
{
while (it.MoveNext())
{
KeyRecord rec = it.Current;
Dictionary<string, Object> map = (Dictionary<string, Object>)rec.record.GetMap(mapBinNoIndex);
Assert.True(map.ContainsKey("dogs7"));
count2++;
}
}
finally
{
it.Close();
}
}
public QueryRecordCommand(Node node, Policy policy, Statement statement, RecordSet recordSet)
: base(node, true)
{
this.policy = policy;
this.statement = statement;
this.recordSet = recordSet;
}
public QueryAggregateExecutor(Cluster cluster, QueryPolicy policy, Statement statement)
: base(cluster, policy, statement)
{
inputQueue = new BlockingCollection<object>(500);
resultSet = new ResultSet(this, policy.recordQueueSize, cancel.Token);
InitializeThreads();
}
public void QueryString()
{
string filter = valuePrefix + 3;
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetBinNames(binName);
stmt.SetFilters(Filter.Equal(binName, filter));
RecordSet rs = client.Query(null, stmt);
try
{
int count = 0;
while (rs.Next())
{
Record record = rs.Record;
string result = record.GetString(binName);
Assert.AreEqual(filter, result);
count++;
}
Assert.AreNotEqual(0, count);
}
finally
{
rs.Close();
}
}
public void deleteStartsWith()
{
Qualifier qual1 = new Qualifier("color", Qualifier.FilterOperation.ENDS_WITH, Value.Get("e"));
Statement stmt = new Statement();
stmt.Namespace = TestQueryEngine.NAMESPACE;
stmt.SetName = TestQueryEngine.SET_NAME;
IDictionary<string, long> counts = queryEngine.Delete(stmt, qual1);
Assert.AreEqual(400L, counts["read"]);
Assert.AreEqual(400L, counts["write"]);
}
public void aggregateUsersByTweetCountByRegion()
{
ResultSet rs = null;
try
{
int min;
int max;
Console.WriteLine("\nEnter Min Tweet Count:");
min = int.Parse(Console.ReadLine());
Console.WriteLine("Enter Max Tweet Count:");
max = int.Parse(Console.ReadLine());
// NOTE: UDF registration has been included here for convenience and to demonstrate the syntax.
// NOTE: The recommended way of registering UDFs in production env is via AQL
string luaDirectory = @"..\..\udf";
LuaConfig.PackagePath = luaDirectory + @"\?.lua";
string filename = "aggregationByRegion.lua";
string path = Path.Combine(luaDirectory, filename);
RegisterTask rt = client.Register(null, path, filename, Language.LUA);
rt.Wait();
string[] bins = { "tweetcount", "region" };
Statement stmt = new Statement();
stmt.SetNamespace("test");
stmt.SetSetName("users");
stmt.SetIndexName("tweetcount_index");
stmt.SetBinNames(bins);
stmt.SetFilters(Filter.Range("tweetcount", min, max));
Console.WriteLine("\nAggregating users with " + min + "-" + max + " tweets by region. Hang on...\n");
rs = client.QueryAggregate(null, stmt, "aggregationByRegion", "sum");
if (rs.Next())
{
Dictionary<object, object> result = (Dictionary<object, object>)rs.Object;
Console.WriteLine("Total Users in North: " + result["n"]);
Console.WriteLine("Total Users in South: " + result["s"]);
Console.WriteLine("Total Users in East: " + result["e"]);
Console.WriteLine("Total Users in West: " + result["w"]);
}
}
finally
{
if (rs != null)
{
// Close record set
rs.Close();
}
}
}
public QueryAggregateCommand(
Node node,
Policy policy,
Statement statement,
BlockingCollection<object> inputQueue,
CancellationToken cancelToken
)
: base(node, true)
{
this.policy = policy;
this.statement = statement;
this.inputQueue = inputQueue;
this.cancelToken = cancelToken;
}
public void QueryExecute()
{
int begin = 3;
int end = 9;
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetFilters(Filter.Range(binName1, begin, end));
ExecuteTask task = client.Execute(null, stmt, "record_example", "processRecord", Value.Get(binName1), Value.Get(binName2), Value.Get(100));
task.Wait();
ValidateRecords();
}
public void deleteByKey()
{
for (int x = 1; x <= TestQueryEngine.RECORD_COUNT; x++)
{
String keyString = "selector-test:" + x;
Key key = new Key(TestQueryEngine.NAMESPACE, TestQueryEngine.SET_NAME, keyString);
KeyQualifier kq = new KeyQualifier(Value.Get(keyString));
Statement stmt = new Statement();
stmt.Namespace = TestQueryEngine.NAMESPACE;
stmt.SetName = TestQueryEngine.SET_NAME;
IDictionary<string, long> counts = queryEngine.Delete(stmt, kq);
Assert.AreEqual(1L, counts["write"]);
Record record = this.client.Get(null, key);
Assert.Null(record);
}
}
private void RunQuery(AerospikeClient client, Arguments args, string indexName, string binName, string valuePrefix)
{
string filter = valuePrefix + 3;
console.Info("Query for: ns={0} set={1} index={2} bin={3} filter={4}",
args.ns, args.set, indexName, binName, filter);
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetBinNames(binName);
stmt.SetFilters(Filter.Equal(binName, filter));
RecordSet rs = client.Query(null, stmt);
try
{
int count = 0;
while (rs.Next())
{
Key key = rs.Key;
Record record = rs.Record;
string result = (string)record.GetValue(binName);
if (result.Equals(filter))
{
console.Info("Record found: namespace={0} set={1} digest={2} bin={3} value={4}",
key.ns, key.setName, ByteUtil.BytesToHexString(key.digest), binName, result);
}
else
{
console.Error("Query mismatch: Expected {0}. Received {1}.", filter, result);
}
count++;
}
if (count == 0)
{
console.Error("Query failed. No records returned.");
}
}
finally
{
rs.Close();
}
}
public QueryExecutor(Cluster cluster, QueryPolicy policy, Statement statement)
{
this.policy = policy;
this.statement = statement;
this.cancel = new CancellationTokenSource();
this.nodes = cluster.Nodes;
if (this.nodes.Length == 0)
{
throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Query failed because cluster is empty.");
}
this.threads = new QueryThread[nodes.Length];
// Initialize maximum number of nodes to query in parallel.
this.maxConcurrentNodes = (policy.maxConcurrentNodes == 0 || policy.maxConcurrentNodes >= threads.Length) ? threads.Length : policy.maxConcurrentNodes;
}
public void selectOneWitKey()
{
Statement stmt = new Statement();
stmt.Namespace = TestQueryEngine.NAMESPACE;
stmt.SetName = TestQueryEngine.SET_NAME;
KeyQualifier kq = new KeyQualifier(Value.Get("selector-test:3"));
KeyRecordEnumerator it = queryEngine.Select(stmt, kq);
int count = 0;
while (it.MoveNext())
{
KeyRecord rec = it.Current;
count++;
// System.out.println(rec);
}
it.Close();
// System.out.println(count);
Assert.Equals(1, count);
}
public void selectByKey()
{
// Execute the Query
Statement stmt = new Statement();
stmt.Namespace = TestQueryEngine.NAMESPACE;
stmt.SetName = SET;
stmt.SetFilters(Filter.Contains(mapBin, IndexCollectionType.MAPKEYS, "dogs7"));
int count = 0;
RecordSet recordSet = client.Query(null, stmt);
try
{
Console.WriteLine("\nRecords with map keys equal to dogs7:");
while (recordSet != null & recordSet.Next())
{
//Console.WriteLine("\t" + recordSet.getKey().userKey);
count++;
}
}
finally
{
if (recordSet != null) recordSet.Close();
}
Console.WriteLine("\t" + count);
Qualifier qual1 = new Qualifier(mapBin, Qualifier.FilterOperation.MAP_KEYS_CONTAINS, Value.Get("dogs7"));
KeyRecordEnumerator it = queryEngine.Select(stmt, qual1);
int count2 = 0;
try
{
while (it.MoveNext())
{
KeyRecord rec = it.Current;
Dictionary<string, Object> map = (Dictionary<string, Object>)rec.record.GetMap(mapBin);
Assert.True(map.ContainsKey("dogs7"));
count2++;
}
}
finally
{
it.Close();
}
Assert.Equals(count, count2);
}
public void QuerySum()
{
int begin = 4;
int end = 7;
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetBinNames(binName);
stmt.SetFilters(Filter.Range(binName, begin, end));
stmt.SetAggregateFunction(Assembly.GetExecutingAssembly(), "Aerospike.Test.Resources.sum_example.lua", "sum_example", "sum_single_bin", Value.Get(binName));
ResultSet rs = client.QueryAggregate(null, stmt);
try
{
int expected = 22; // 4 + 5 + 6 + 7
int count = 0;
while (rs.Next())
{
object obj = rs.Object;
long sum = 0;
if (obj is long)
{
sum = (long)rs.Object;
}
else
{
Assert.Fail("Return value not a long: " + obj);
}
Assert.AreEqual(expected, (int)sum);
count++;
}
Assert.AreNotEqual(0, count);
}
finally
{
rs.Close();
}
}
private void RunQuery(AerospikeClient client, Arguments args, string indexName, string binName)
{
int begin = 14;
int end = 18;
console.Info("Query for: ns={0} set={1} index={2} bin={3} >= {4} <= {5}",
args.ns, args.set, indexName, binName, begin, end);
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetBinNames(binName);
stmt.SetFilters(Filter.Range(binName, begin, end));
RecordSet rs = client.Query(null, stmt);
try
{
int count = 0;
while (rs.Next())
{
Key key = rs.Key;
Record record = rs.Record;
long result = record.GetLong(binName);
console.Info("Record found: namespace={0} set={1} digest={2} bin={3} value={4}",
key.ns, key.setName, ByteUtil.BytesToHexString(key.digest), binName, result);
count++;
}
if (count != 5)
{
console.Error("Query count mismatch. Expected 5. Received " + count);
}
}
finally
{
rs.Close();
}
}
public AsyncQueryExecutor(AsyncCluster cluster, QueryPolicy policy, RecordSequenceListener listener, Statement statement)
{
this.listener = listener;
statement.Prepare(true);
Node[] nodes = cluster.Nodes;
if (nodes.Length == 0)
{
throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Query failed because cluster is empty.");
}
// Create commands.
AsyncQuery[] tasks = new AsyncQuery[nodes.Length];
int count = 0;
foreach (Node node in nodes)
{
tasks[count++] = new AsyncQuery(this, cluster, (AsyncNode)node, policy, listener, statement);
}
// Dispatch commands to nodes.
Execute(tasks, policy.maxConcurrentNodes);
}
public void QueryAverage()
{
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetFilters(Filter.Range(binName, 0, 1000));
stmt.SetAggregateFunction(Assembly.GetExecutingAssembly(), "Aerospike.Test.Resources.average_example.lua", "average_example", "average");
ResultSet rs = client.QueryAggregate(null, stmt);
try
{
if (rs.Next())
{
object obj = rs.Object;
if (obj is IDictionary)
{
IDictionary map = (IDictionary)obj;
long sum = (long)map["sum"];
long count = (long)map["count"];
double avg = (double) sum / count;
Assert.AreEqual(5.5, avg, 0.00000001);
}
else
{
Assert.Fail("Unexpected object returned: " + obj);
}
}
else
{
Assert.Fail("Query Assert.Failed. No records returned.");
}
}
finally
{
rs.Close();
}
}
protected internal void SetQuery(Policy policy, Statement statement, bool write)
{
byte[] functionArgBuffer = null;
int fieldCount = 0;
int filterSize = 0;
int binNameSize = 0;
Begin();
if (statement.ns != null)
{
dataOffset += ByteUtil.EstimateSizeUtf8(statement.ns) + FIELD_HEADER_SIZE;
fieldCount++;
}
if (statement.indexName != null)
{
dataOffset += ByteUtil.EstimateSizeUtf8(statement.indexName) + FIELD_HEADER_SIZE;
fieldCount++;
}
if (statement.setName != null)
{
dataOffset += ByteUtil.EstimateSizeUtf8(statement.setName) + FIELD_HEADER_SIZE;
fieldCount++;
}
// Allocate space for TaskId field.
dataOffset += 8 + FIELD_HEADER_SIZE;
fieldCount++;
if (statement.filters != null)
{
if (statement.filters.Length >= 1)
{
IndexCollectionType type = statement.filters[0].CollectionType;
if (type != IndexCollectionType.DEFAULT)
{
dataOffset += FIELD_HEADER_SIZE + 1;
fieldCount++;
}
}
dataOffset += FIELD_HEADER_SIZE;
filterSize++; // num filters
foreach (Filter filter in statement.filters)
{
filterSize += filter.EstimateSize();
}
dataOffset += filterSize;
fieldCount++;
// Query bin names are specified as a field (Scan bin names are specified later as operations)
if (statement.binNames != null)
{
dataOffset += FIELD_HEADER_SIZE;
binNameSize++; // num bin names
foreach (string binName in statement.binNames)
{
binNameSize += ByteUtil.EstimateSizeUtf8(binName) + 1;
}
dataOffset += binNameSize;
fieldCount++;
}
}
else
{
// Calling query with no filters is more efficiently handled by a primary index scan.
// Estimate scan options size.
dataOffset += 2 + FIELD_HEADER_SIZE;
fieldCount++;
}
if (statement.functionName != null)
{
dataOffset += FIELD_HEADER_SIZE + 1; // udf type
dataOffset += ByteUtil.EstimateSizeUtf8(statement.packageName) + FIELD_HEADER_SIZE;
dataOffset += ByteUtil.EstimateSizeUtf8(statement.functionName) + FIELD_HEADER_SIZE;
if (statement.functionArgs.Length > 0)
{
functionArgBuffer = Packer.Pack(statement.functionArgs);
}
else
{
functionArgBuffer = new byte[0];
}
dataOffset += FIELD_HEADER_SIZE + functionArgBuffer.Length;
fieldCount += 4;
}
if (statement.filters == null)
{
if (statement.binNames != null)
{
foreach (string binName in statement.binNames)
{
EstimateOperationSize(binName);
}
}
}
SizeBuffer();
int operationCount = (statement.filters == null && statement.binNames != null) ? statement.binNames.Length : 0;
if (write)
{
WriteHeader((WritePolicy)policy, Command.INFO1_READ, Command.INFO2_WRITE, fieldCount, operationCount);
}
else
{
WriteHeader(policy, Command.INFO1_READ, 0, fieldCount, operationCount);
}
if (statement.ns != null)
{
WriteField(statement.ns, FieldType.NAMESPACE);
}
if (statement.indexName != null)
{
WriteField(statement.indexName, FieldType.INDEX_NAME);
}
if (statement.setName != null)
{
WriteField(statement.setName, FieldType.TABLE);
}
// Write taskId field
WriteFieldHeader(8, FieldType.TRAN_ID);
ByteUtil.LongToBytes(statement.taskId, dataBuffer, dataOffset);
dataOffset += 8;
if (statement.filters != null)
{
if (statement.filters.Length >= 1)
{
IndexCollectionType type = statement.filters[0].CollectionType;
if (type != IndexCollectionType.DEFAULT)
{
WriteFieldHeader(1, FieldType.INDEX_TYPE);
dataBuffer[dataOffset++] = (byte)type;
}
}
WriteFieldHeader(filterSize, FieldType.INDEX_RANGE);
dataBuffer[dataOffset++] = (byte)statement.filters.Length;
foreach (Filter filter in statement.filters)
{
dataOffset = filter.Write(dataBuffer, dataOffset);
}
// Query bin names are specified as a field (Scan bin names are specified later as operations)
if (statement.binNames != null)
{
WriteFieldHeader(binNameSize, FieldType.QUERY_BINLIST);
dataBuffer[dataOffset++] = (byte)statement.binNames.Length;
foreach (string binName in statement.binNames)
{
int len = ByteUtil.StringToUtf8(binName, dataBuffer, dataOffset + 1);
dataBuffer[dataOffset] = (byte)len;
dataOffset += len + 1;
}
}
}
else
{
// Calling query with no filters is more efficiently handled by a primary index scan.
WriteFieldHeader(2, FieldType.SCAN_OPTIONS);
byte priority = (byte)policy.priority;
priority <<= 4;
dataBuffer[dataOffset++] = priority;
dataBuffer[dataOffset++] = (byte)100;
}
if (statement.functionName != null)
{
WriteFieldHeader(1, FieldType.UDF_OP);
dataBuffer[dataOffset++] = (statement.returnData) ? (byte)1 : (byte)2;
WriteField(statement.packageName, FieldType.UDF_PACKAGE_NAME);
WriteField(statement.functionName, FieldType.UDF_FUNCTION);
WriteField(functionArgBuffer, FieldType.UDF_ARGLIST);
}
// Scan bin names are specified after all fields.
if (statement.filters == null)
{
if (statement.binNames != null)
{
foreach (string binName in statement.binNames)
{
WriteOperation(binName, Operation.Type.READ);
}
}
}
End();
}
private void RunQuery(AerospikeClient client, Arguments args, string indexName, string binName)
{
string nameFilter = "Bill";
string passFilter = "hknfpkj";
console.Info("Query for: ns=%s set=%s index=%s name=%s pass=%s", args.ns, args.set, indexName, nameFilter, passFilter);
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetFilters(Filter.Equal(binName, nameFilter));
stmt.SetAggregateFunction("filter_example", "profile_filter", Value.Get(passFilter));
// passFilter will be applied in filter_example.lua.
ResultSet rs = client.QueryAggregate(null, stmt);
try
{
int count = 0;
while (rs.Next())
{
Dictionary<object, object> map = (Dictionary<object, object>)rs.Object;
Validate(map, "name", nameFilter);
Validate(map, "password", passFilter);
count++;
}
if (count == 0)
{
console.Error("Query failed. No records returned.");
}
}
finally
{
rs.Close();
}
}
private void RunQueryExecute(AerospikeClient client, Arguments args, string indexName, string binName1, string binName2)
{
int begin = 3;
int end = 9;
console.Info("For ns={0} set={1} index={2} bin={3} >= {4} <= {5}", args.ns, args.set, indexName, binName1, begin, end);
console.Info("Even integers: add 100 to existing " + binName1);
console.Info("Multiple of 5: delete " + binName2 + " bin");
console.Info("Multiple of 9: delete record");
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetFilters(Filter.Range(binName1, begin, end));
ExecuteTask task = client.Execute(args.writePolicy, stmt, "record_example", "processRecord", Value.Get(binName1), Value.Get(binName2), Value.Get(100));
task.Wait();
}
private void ValidateRecords(AerospikeClient client, Arguments args, string indexName, string binName1, string binName2, int size)
{
int begin = 1;
int end = size + 100;
console.Info("Validate records");
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetFilters(Filter.Range(binName1, begin, end));
RecordSet rs = client.Query(null, stmt);
try
{
int[] expectedList = new int[] {1,2,3,104,5,106,7,108,-1,10};
int expectedSize = size - 1;
int count = 0;
while (rs.Next())
{
Key key = rs.Key;
Record record = rs.Record;
object value1 = null;
object value2 = null;
record.bins.TryGetValue(binName1, out value1);
record.bins.TryGetValue(binName2, out value2);
console.Info("Record found: ns={0} set={1} bin1={2} value1={3} bin2={4} value2={5}",
key.ns, key.setName, binName1, value1, binName2, value2);
if (value1 == null)
{
console.Error("Data mismatch. value1 is null");
break;
}
long val1 = (long)value1;
if (val1 == 9)
{
console.Error("Data mismatch. value1 " + val1 + " should not exist");
break;
}
if (val1 == 5)
{
if (value2 != null)
{
console.Error("Data mismatch. value2 " + value2 + " should be null");
break;
}
}
else
{
long val2 = (long)value2;
if (val1 != expectedList[val2 - 1])
{
console.Error("Data mismatch. Expected " + expectedList[val2 - 1] + ". Received " + value1);
break;
}
}
count++;
}
if (count != expectedSize)
{
console.Error("Query count mismatch. Expected " + expectedSize + ". Received " + count);
}
}
finally
{
rs.Close();
}
}
public void OnSuccess(Key key)
{
int rows = Interlocked.Increment(ref count);
if (rows == size)
{
int begin = 26;
int end = 34;
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetBinNames(binName);
stmt.SetFilters(Filter.Range(binName, begin, end));
client.Query(null, new RecordSequenceHandler(parent), stmt);
}
}
private void RunQuery(AerospikeClient client, Arguments args, string binName, string binName2, IndexCollectionType indexType)
{
console.Info("Query for: ns={0} set={1} bin={2} {3} within <region>", args.ns, args.set, binName, indexType.ToString());
StringBuilder rgnsb = GenerateQueryRegion();
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetFilters(Filter.GeoWithinRegion(binName, indexType, rgnsb.ToString()));
RecordSet rs = client.Query(null, stmt);
try
{
int count = 0;
HashSet<string> uniques = new HashSet<string>();
while (rs.Next())
{
Record record = rs.Record;
string val = record.GetString(binName2);
uniques.Add(val);
count++;
}
if (count != 697)
{
console.Error("Query failed. {0} records expected. {1} returned.", 697, count);
}
else if (uniques.Count != 21)
{
console.Error("Query failed. {0} unique records expected. {1} unique returned.", 21, uniques.Count);
}
else
{
console.Info("query succeeded with {0} records {1} unique", count, uniques.Count);
}
}
finally
{
rs.Close();
}
}
public static void PurgeDay(string date, AerospikeClient client)
{
Console.WriteLine ("Purgin data for {0}", date);
Stopwatch stopwatch = new Stopwatch ();
stopwatch.Start ();
Statement statement = new Statement ();
statement.Namespace = ns;
statement.SetName = seqSet;
//statement.SetFilters (Filter.Equal (dayBinName, date));
ExecuteTask task = client.Execute (null, statement, "utility", "purge",
Value.Get(dayBinName),
Value.Get(date));
while (!task.IsDone())
Thread.Sleep (100);
stopwatch.Stop ();
Console.WriteLine ("Purge completed {0} ms", stopwatch.ElapsedMilliseconds);
}
private void RunQuery(AerospikeClient client, Arguments args, string indexName, string binName)
{
console.Info("Query for:ns={0} set={1} index={2} bin={3}",
args.ns, args.set, indexName, binName);
Statement stmt = new Statement();
stmt.SetNamespace(args.ns);
stmt.SetSetName(args.set);
stmt.SetFilters(Filter.Equal(binName, 1));
ResultSet rs = client.QueryAggregate(null, stmt, "average_example", "average");
try
{
if (rs.Next())
{
object obj = rs.Object;
if (obj is Dictionary<object,object>)
{
Dictionary<object, object> map = (Dictionary<object, object>)obj;
object objsum = map["sum"];
object objcount = map["count"];
double sum = (double)(long)objsum;
double count = (double)(long)objcount;
double avg = sum / count;
console.Info("Sum=" + sum + " Count=" + count + " Average=" + avg);
double expected = 5.5;
if (avg != expected)
{
console.Error("Data mismatch: Expected {0}. Received {1}.", expected, avg);
}
}
else
{
console.Error("Unexpected object returned: " + obj);
}
}
else
{
console.Error("Query failed. No records returned.");
}
}
finally
{
rs.Close();
}
}
protected internal void SetQuery(Policy policy, Statement statement, bool write)
{
byte[] functionArgBuffer = null;
int fieldCount = 0;
int filterSize = 0;
int binNameSize = 0;
Begin();
if (statement.ns != null)
{
dataOffset += ByteUtil.EstimateSizeUtf8(statement.ns) + FIELD_HEADER_SIZE;
fieldCount++;
}
if (statement.indexName != null)
{
dataOffset += ByteUtil.EstimateSizeUtf8(statement.indexName) + FIELD_HEADER_SIZE;
fieldCount++;
}
if (statement.setName != null)
{
dataOffset += ByteUtil.EstimateSizeUtf8(statement.setName) + FIELD_HEADER_SIZE;
fieldCount++;
}
// Allocate space for TaskId field.
dataOffset += 8 + FIELD_HEADER_SIZE;
fieldCount++;
if (statement.filter != null)
{
IndexCollectionType type = statement.filter.CollectionType;
if (type != IndexCollectionType.DEFAULT)
{
dataOffset += FIELD_HEADER_SIZE + 1;
fieldCount++;
}
dataOffset += FIELD_HEADER_SIZE;
filterSize++; // num filters
filterSize += statement.filter.EstimateSize();
dataOffset += filterSize;
fieldCount++;
// Query bin names are specified as a field (Scan bin names are specified later as operations)
if (statement.binNames != null && statement.binNames.Length > 0)
{
dataOffset += FIELD_HEADER_SIZE;
binNameSize++; // num bin names
foreach (string binName in statement.binNames)
{
binNameSize += ByteUtil.EstimateSizeUtf8(binName) + 1;
}
dataOffset += binNameSize;
fieldCount++;
}
}
else
{
// Calling query with no filters is more efficiently handled by a primary index scan.
// Estimate scan options size.
dataOffset += 2 + FIELD_HEADER_SIZE;
fieldCount++;
// Estimate scan timeout size.
dataOffset += 4 + FIELD_HEADER_SIZE;
fieldCount++;
}
PredExp[] predExp = statement.PredExp;
int predSize = 0;
if (predExp != null)
{
dataOffset += FIELD_HEADER_SIZE;
predSize = PredExp.EstimateSize(predExp);
dataOffset += predSize;
fieldCount++;
}
if (statement.functionName != null)
{
dataOffset += FIELD_HEADER_SIZE + 1; // udf type
dataOffset += ByteUtil.EstimateSizeUtf8(statement.packageName) + FIELD_HEADER_SIZE;
dataOffset += ByteUtil.EstimateSizeUtf8(statement.functionName) + FIELD_HEADER_SIZE;
if (statement.functionArgs.Length > 0)
{
functionArgBuffer = Packer.Pack(statement.functionArgs);
}
else
{
functionArgBuffer = new byte[0];
}
dataOffset += FIELD_HEADER_SIZE + functionArgBuffer.Length;
fieldCount += 4;
}
if (statement.filter == null)
{
if (statement.binNames != null)
{
foreach (string binName in statement.binNames)
{
EstimateOperationSize(binName);
}
}
}
SizeBuffer();
int operationCount = (statement.filter == null && statement.binNames != null) ? statement.binNames.Length : 0;
if (write)
{
WriteHeader((WritePolicy)policy, Command.INFO1_READ, Command.INFO2_WRITE, fieldCount, operationCount);
}
else
{
QueryPolicy qp = (QueryPolicy)policy;
int readAttr = qp.includeBinData ? Command.INFO1_READ : Command.INFO1_READ | Command.INFO1_NOBINDATA;
WriteHeader(policy, readAttr, 0, fieldCount, operationCount);
}
if (statement.ns != null)
{
WriteField(statement.ns, FieldType.NAMESPACE);
}
if (statement.indexName != null)
{
WriteField(statement.indexName, FieldType.INDEX_NAME);
}
if (statement.setName != null)
{
WriteField(statement.setName, FieldType.TABLE);
}
// Write taskId field
WriteFieldHeader(8, FieldType.TRAN_ID);
ByteUtil.LongToBytes(statement.taskId, dataBuffer, dataOffset);
dataOffset += 8;
if (statement.filter != null)
{
IndexCollectionType type = statement.filter.CollectionType;
if (type != IndexCollectionType.DEFAULT)
{
WriteFieldHeader(1, FieldType.INDEX_TYPE);
dataBuffer[dataOffset++] = (byte)type;
}
WriteFieldHeader(filterSize, FieldType.INDEX_RANGE);
dataBuffer[dataOffset++] = (byte)1;
dataOffset = statement.filter.Write(dataBuffer, dataOffset);
// Query bin names are specified as a field (Scan bin names are specified later as operations)
if (statement.binNames != null && statement.binNames.Length > 0)
{
WriteFieldHeader(binNameSize, FieldType.QUERY_BINLIST);
dataBuffer[dataOffset++] = (byte)statement.binNames.Length;
foreach (string binName in statement.binNames)
{
int len = ByteUtil.StringToUtf8(binName, dataBuffer, dataOffset + 1);
dataBuffer[dataOffset] = (byte)len;
dataOffset += len + 1;
}
}
}
else
{
// Calling query with no filters is more efficiently handled by a primary index scan.
WriteFieldHeader(2, FieldType.SCAN_OPTIONS);
byte priority = (byte)policy.priority;
priority <<= 4;
if (!write && ((QueryPolicy)policy).failOnClusterChange)
{
priority |= 0x08;
}
dataBuffer[dataOffset++] = priority;
dataBuffer[dataOffset++] = (byte)100;
// Write scan timeout
WriteFieldHeader(4, FieldType.SCAN_TIMEOUT);
dataOffset += ByteUtil.IntToBytes((uint)policy.socketTimeout, dataBuffer, dataOffset);
}
if (predExp != null)
{
WriteFieldHeader(predSize, FieldType.PREDEXP);
dataOffset = PredExp.Write(predExp, dataBuffer, dataOffset);
}
if (statement.functionName != null)
{
WriteFieldHeader(1, FieldType.UDF_OP);
dataBuffer[dataOffset++] = (statement.returnData) ? (byte)1 : (byte)2;
WriteField(statement.packageName, FieldType.UDF_PACKAGE_NAME);
WriteField(statement.functionName, FieldType.UDF_FUNCTION);
WriteField(functionArgBuffer, FieldType.UDF_ARGLIST);
}
// Scan bin names are specified after all fields.
if (statement.filter == null)
{
if (statement.binNames != null)
{
foreach (string binName in statement.binNames)
{
WriteOperation(binName, Operation.Type.READ);
}
}
}
End();
}
//-------------------------------------------------------
// Query Operations
//-------------------------------------------------------
/// <summary>
/// Asynchronously execute query on all server nodes. The query policy's
/// <code>maxConcurrentNodes</code> dictate how many nodes can be queried in parallel.
/// The default is to query all nodes in parallel.
/// <para>
/// This method schedules the node's query commands with channel selectors and returns.
/// Selector threads will process the commands and send the results to the listener.
/// </para>
/// </summary>
/// <param name="policy">query configuration parameters, pass in null for defaults</param>
/// <param name="listener">where to send results</param>
/// <param name="statement">database query command parameters</param>
/// <exception cref="AerospikeException">if query fails</exception>
public void Query(QueryPolicy policy, RecordSequenceListener listener, Statement statement)
{
if (policy == null)
{
policy = queryPolicyDefault;
}
new AsyncQueryExecutor(cluster, policy, listener, statement);
}
public AsyncQueryExecutor(AsyncCluster cluster, QueryPolicy policy, RecordSequenceListener listener, Statement statement)
{
this.listener = listener;
statement.Prepare(true);
Node[] nodes = cluster.Nodes;
if (nodes.Length == 0)
{
throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Query failed because cluster is empty.");
}
// Create commands.
AsyncQuery[] tasks = new AsyncQuery[nodes.Length];
int count = 0;
foreach (Node node in nodes)
{
tasks[count++] = new AsyncQuery(this, cluster, (AsyncNode)node, policy, listener, statement);
}
// Dispatch commands to nodes.
Execute(tasks, policy.maxConcurrentNodes);
}