public void SortTest()
{
AQuery query = _db.Query
.Sort(AValue <Dummy> .Field(x => x.Foo), AqlSort.Direction.Desc);
Assert.AreEqual("SORT x.Foo DESC", query.GetExpression());
}
public void LimitTest()
{
AQuery query = _db.Query
.Limit(5);
Assert.AreEqual("LIMIT 5", query.GetExpression());
}
public void ForTest()
{
AQuery query = _db.Query
.For("x", AValue.Field(TestDocumentCollectionName));
Assert.AreEqual("FOR x IN " + TestDocumentCollectionName, query.GetExpression());
}
public override Android.Views.View GetView(int position, Android.Views.View convertView, Android.Views.ViewGroup parent)
{
if (convertView == null)
{
convertView = _activity.LayoutInflater.Inflate(Resource.Layout.list_item, parent, false);
}
Product product = _products[position];
AQuery aq = new AQuery(convertView);
TextView txtProductName = convertView.FindViewById <TextView>(Resource.Id.txtProductName);
txtProductName.Text = product.Name;
Bitmap imgLoading = aq.GetCachedImage(Resource.Drawable.img_loading);
if (aq.ShouldDelay(position, convertView, parent, product.ImageUrl))
{
((AQuery)aq.Id(Resource.Id.imgProduct)).Image(imgLoading, 0.75f);
}
else
{
((AQuery)aq.Id(Resource.Id.imgProduct)).Image(product.ImageUrl, true, true, 0, 0, imgLoading, 0, 0.75f);
}
return(convertView);
}
public void LetTest()
{
AQuery query = _db.Query
.Let("x", AValue.Document <Dummy>(TestDocumentCollectionName, AValue.Field <string>("asd")));
Assert.AreEqual("LET x = DOCUMENT('" + TestDocumentCollectionName + "',asd)", query.GetExpression());
}
public void OperationTest()
{
AQuery query = _db.Query
.Let("x", AValue.Op(AValue <Dummy> .Field(x => x.Baz), "/", AValue <Dummy> .Field(x => x.Bar)));
Assert.AreEqual("LET x = (x.Baz / x.Bar)", query.GetExpression());
}
public override Android.Views.View GetView(int position, Android.Views.View convertView, Android.Views.ViewGroup parent)
{
if (convertView == null)
{
convertView = _activity.LayoutInflater.Inflate(Resource.Layout.list_item, parent, false);
}
Product product = _products[position];
AQuery aq = new AQuery(convertView);
TextView txtProductName = convertView.FindViewById<TextView>(Resource.Id.txtProductName);
txtProductName.Text = product.Name;
Bitmap imgLoading = aq.GetCachedImage(Resource.Drawable.img_loading);
if (aq.ShouldDelay(position, convertView, parent, product.ImageUrl))
{
((AQuery)aq.Id(Resource.Id.imgProduct)).Image(imgLoading, 0.75f);
}
else
{
((AQuery)aq.Id(Resource.Id.imgProduct)).Image(product.ImageUrl, true, true, 0, 0, imgLoading, 0, 0.75f);
}
return convertView;
}
public void ReturnTest()
{
AQuery query = _db.Query
.Return(AReturn.Variable("x"));
Assert.AreEqual("RETURN x", query.GetExpression());
}
public void RangeTest()
{
AQuery query = _db.Query
.For("x", AValue.Range(0, 200));
Assert.AreEqual("FOR x IN 0..200", query.GetExpression());
}
public void ReturnPartialTest()
{
AQuery query = _db.Query
.Return(AReturn.Partial <Dummy>(x => x.Key, x => x.Foo));
Assert.AreEqual("RETURN {_key:x._key, Foo:x.Foo}", query.GetExpression());
}
public void FieldTest()
{
AQuery query = _db.Query
.Let("x", AValue <Dummy> .Field(x => x.Bar));
Assert.AreEqual("LET x = x.Bar", query.GetExpression());
}
public void ObjectTest()
{
AQuery query = _db.Query
.Let("x", AValue <Dummy> .Object(
(
x => x.Id,
AValue.Bind("asdf")
),
(
x => x.Foo,
AValue <Dummy> .Field(z => z.Foo)
),
(
x => x.Bar,
AValue.Bind(10)
),
(
x => x.Baz,
AValue <Dummy> .Field(x => x.Bar)
)
));
Assert.AreEqual("LET x = {\"_id\":@var0,\"Foo\":z.Foo,\"Bar\":@var1,\"Baz\":x.Bar}", query.GetExpression());
Assert.AreEqual(typeof(string), query.GetBindedVars()[0].GetType());
Assert.AreEqual(typeof(int), query.GetBindedVars()[1].GetType());
}
public void FieldSuffixTest()
{
AQuery query = _db.Query
.Let("x", AValue <Dummy> .Field <int>(x => x.Foo, ".was"));
Assert.AreEqual("LET x = x.Foo.was", query.GetExpression());
}
public void AttributesTest()
{
AQuery query = _db.Query
.Let("x", AValue.Attributes(AValue <Dummy> .Field(x => x.Foo)));
Assert.AreEqual("LET x = ATTRIBUTES(x.Foo)", query.GetExpression());
}
private object handleQuery(AQuery query, bool _workerQuery = false, bool _fromService = false)
{
if (_workerQuery)
{
pushQueryToServiceWorkerNoexcept(query);
}
else
{
if (workerLocked)
{
pushAQueryToActors(query);
}
else
{
object result =
handleQuery(new AQuery(-1, !_fromService, -1, new ParameterizedActorQueryRet(pushQueryToActorsNoexcept), query), true);
if (result != null)
{
throw result as Exception;
}
}
}
if (query.Sync)
{
query.StartWait();
query.HandleException();
return(query.GetResult());
}
else
{
return(null);
}
}
public void BetweenTest()
{
AQuery query = _db.Query.Filter(AFilter.Between(AValue <Dummy> .Field(x => x.Bar), AValue.Bind(1), AValue.Bind(50)));
Assert.AreEqual("FILTER (x.Bar >= @var0 AND x.Bar <= @var1)", query.GetExpression());
Assert.AreEqual(1, query.GetBindedVars()[0]);
Assert.AreEqual(50, query.GetBindedVars()[1]);
}
public void SimpleTest()
{
//AQuery query = _db.Query.Filter(FilterBuilder<Dummy>.Eq( x => x.Foo, "asd"));
AQuery query = _db.Query.Filter(AFilter.Eq(AValue <Dummy> .Field(x => x.Foo), AValue.Bind("asd")));
Assert.AreEqual("FILTER x.Foo == @var0", query.GetExpression());
Assert.AreEqual("asd", query.GetBindedVars()[0]);
}
/// <summary>
/// Добавляет "хэндлер" актеру
/// </summary>
/// <param name="actorNo">номер актера</param>
/// <param name="queryHandle">хэндлер</param>
public void AddQueryHandleToActor(int actorNo, int queryHandle)
{
if (!IsWorking)
{
throw new WorkerDisposed();
}
if (workerLocked)
{
throw new WorkerAreLocked();
}
if (queryHandle < 0)
{
throw new ArgumentException("queryHandle < 0");
}
AQuery addQueryQ = new AQuery(-1, true, -1,
new ParameterizedActorQueryRet(
(qObj) =>
{
_maintainQueryStruct qInfo = (_maintainQueryStruct)qObj;
Actor thisActor = getActor(qInfo.actorNo);
if (thisActor == null)
{
return(new ActorNotExists(qInfo.actorNo));
}
if (_actorsQHandlers.TryGetValue(qInfo.queryHandle, out List <Actor> currentActorList))
{
if (currentActorList.Contains(thisActor))
{
return(new ActorAlreadyAddedInThisQGroup(qInfo.actorNo));
}
currentActorList.Add(thisActor);
}
else
{
return(new QHandleNotExists(qInfo.queryHandle));
}
return(null);
}),
new _maintainQueryStruct()
{
actorNo = actorNo, queryHandle = queryHandle
});
object result = handleQuery(addQueryQ, true);
if (result != null)
{
throw result as Exception;
}
}
public void FunctionMultipleTest()
{
AQuery query = _db.Query
.Let("x", ANumeric.Coalesce(AValue.Bind(2), AValue.Bind(5)));
Assert.AreEqual("LET x = NOT_NULL(@var0,@var1)", query.GetExpression());
Assert.AreEqual(2, query.GetBindedVars()[0]);
Assert.AreEqual(5, query.GetBindedVars()[1]);
}
public void Should_minify_query()
{
var singleLineQuery = AQuery.Minify(@"
FOR item IN MyDocumentCollection
RETURN item
");
Assert.AreEqual("FOR item IN MyDocumentCollection\nRETURN item\n", singleLineQuery);
}
public void InTest()
{
//AQuery query = _db.Query.Filter(FilterBuilder<Dummy>.In(x => x.Foo, new[] {"asd", "qwe"}));
AQuery query = _db.Query.Filter(AFilter.In(AValue <Dummy> .Field(x => x.Foo), AValueArray.Bind("asd", "qwe")));
Assert.AreEqual("FILTER x.Foo IN [@var0,@var1]", query.GetExpression());
Assert.AreEqual("asd", query.GetBindedVars()[0]);
Assert.AreEqual("qwe", query.GetBindedVars()[1]);
}
public void SimpleTest()
{
var returns = AReturn.Variable("Foo");
AQuery query = _db.Query
.Return(returns);
Assert.AreEqual("RETURN Foo", query.GetExpression());
}
public void PartialTest()
{
var returns = AReturn.Partial <Dummy>(x => x.Bar, x => x.Foo);
AQuery query = _db.Query
.Return(returns);
Assert.AreEqual("RETURN {Bar:x.Bar, Foo:x.Foo}", query.GetExpression());
}
public void ManualTest()
{
var returns = AReturn.Manual(("lala", new AqlReturnFull("Foo")));
AQuery query = _db.Query
.Return(returns);
Assert.AreEqual("RETURN {lala:Foo}", query.GetExpression());
}
/// <summary>
/// Aggregation of filtered "categories" term.
/// </summary>
/// <returns></returns>
public IActionResult Categories()
{
FLogger.LogInformation("Return aggregation of filtered terms");
return(View(FClient.Search <BookModel>(ASearch => ASearch
.Query(AQuery => AQuery
.MatchAll())
.Aggregations(AAggregate => AAggregate
.Terms("categories", ATerms => ATerms
.Field("categories.keyword"))))));
}
public void FunctionSingleTest()
{
AQuery query = _db.Query
.Let("x", ANumeric.Min(AValueArray.Bind(2, 5, 6)));
Assert.AreEqual("LET x = MIN([@var0,@var1,@var2])", query.GetExpression());
Assert.AreEqual(2, query.GetBindedVars()[0]);
Assert.AreEqual(5, query.GetBindedVars()[1]);
Assert.AreEqual(6, query.GetBindedVars()[2]);
}
public void TypeTest()
{
Type dummyType = typeof(Dummy);
//AQuery query = _db.Query.Filter(FilterBuilder<Dummy>.Eq(x => x.GetType(), dummyType));
AQuery query = _db.Query.Filter(AFilter.Eq(AValue <Dummy> .Field(x => x.GetType()), AValue.Bind(dummyType)));
Assert.AreEqual("FILTER x.$type == @var0", query.GetExpression());
Assert.AreEqual(dummyType.FullName + ", " + dummyType.Assembly.GetName().Name, query.GetBindedVars()[0]);
}
private void serviceWorker()
{
try
{
int countDeferredQueryes = 0;
while (IsWorking)
{
serviceEventNotify.WaitOne(100);
while (serviceQueue.TryDequeue(out AQuery q))
{
q.Process();
if (!IsWorking)
{
return;
}
}
countDeferredQueryes = deferredQueryes.Count;
long nowMoment = getTime().Ticks;
for (int i = 0; i < countDeferredQueryes; ++i)
{
AQuery currentQuery = deferredQueryes[i];
if (nowMoment >= currentQuery.ExecuteTime)
{
deferredQueryes.RemoveAt(i);
i--;
countDeferredQueryes--;
if (i < 0)
{
i = 0;
}
handleQuery(currentQuery, _fromService: true);
}
}
}
}
catch (Exception e)
{
if (OnActorException != null)
{
OnActorException(-1, "serviceWorker", -1, e);
}
_destroyWorker(true);
}
}
private void pushAQueryToActors(AQuery thisQuery)
{
object rslt = null;
rslt = pushQueryToActorsNoexcept(thisQuery);
if (rslt != null)
{
throw rslt as Exception;
}
}
public void ReturnPartial2Test()
{
AQuery query = _db.Query
.Return(
AReturn.Partial <Dummy>(
Expression.Property(Expression.Parameter(typeof(Dummy), "x"), "Key"),
Expression.Property(Expression.Parameter(typeof(Dummy), "x"), "Foo")
)
);
Assert.AreEqual("RETURN {_key:x._key, Foo:x.Foo}", query.GetExpression());
}
public void MultipleTest()
{
AQuery query = _db.Query
//.Filter(FilterBuilder<Dummy>.Lt(x => x.Baz, 50))
//.Filter(FilterBuilder<Dummy>.Gte(x => x.Bar, 1));
.Filter(AFilter.Lt(AValue <Dummy> .Field(x => x.Baz), AValue.Bind(50)))
.Filter(AFilter.Gte(AValue <Dummy> .Field(x => x.Bar), AValue.Bind(1)));
Assert.AreEqual("FILTER x.Baz < @var0 FILTER x.Bar >= @var1", query.GetExpression());
Assert.AreEqual(50, query.GetBindedVars()[0]);
Assert.AreEqual(1, query.GetBindedVars()[1]);
}
