public void ArangoDoc_CrossJoin()
{
var db = DatabaseGenerator.Get();
var query = db.Query()
.For(_ => new int[] { 2011, 2012, 2013 }
.For(year => new int[] { 1, 2, 3, 4 }
.Select(quarter => new
{
y = year,
q = quarter,
nice = AQL.Concat(AQL.ToString(quarter), "/", AQL.ToString(year))
})));
var queryData = query.GetQueryData();
Assert.Equal(queryData.Query.RemoveSpaces(), @"
for `year` in @P1
for `quarter` in @P2
return {
`y` : `year` ,
`q` : `quarter` ,
`nice` : concat( [ to_string( `quarter` ) , @P3 , to_string( `year` ) ] )
}
".RemoveSpaces());
Assert.Equal(queryData.BindVars.Count, 3);
Assert.Equal(JsonConvert.SerializeObject(queryData.BindVars[0].Value), "[2011,2012,2013]");
Assert.Equal(JsonConvert.SerializeObject(queryData.BindVars[1].Value), "[1,2,3,4]");
Assert.Equal(queryData.BindVars[2].Value, "/");
}
public void Upsert()
{
var query = db.Query()
.Upsert <Host>(_ => new Host {
Ip = "192.168.173.94"
},
_ => new Host {
Ip = "192.168.173.94", Name = "chorweiler", Tags = new string[] { "development" }
},
(_, o) => new Host {
Tags = AQL.Push(o.Tags, "production", true)
})
.In <Host>();
// execute query for the first time
var firstResult = query.Select((n, o) => n).ToList();
Assert.Equal(firstResult.Count, 1);
Assert.Equal(firstResult[0].Tags.Count, 1);
Assert.Equal(firstResult[0].Tags[0], "development");
// execute query for the second time
var secondResult = query.Select((n, o) => n).ToList();
Assert.Equal(secondResult.Count, 1);
Assert.Equal(secondResult[0].Tags.Count, 2);
Assert.Equal(secondResult[0].Tags[0], "development");
Assert.Equal(secondResult[0].Tags[1], "production");
}
public void UpsertWithFor()
{
var db = DatabaseGenerator.Get();
var query = db.Query <Host>()
.Upsert(h => new Host {
Key = h.Key
},
h => new Host {
},
(h, old) => new Host {
Tags = AQL.Append(h.Tags, old.Tags)
});
var queryData = query.GetQueryData();
Assert.Equal(queryData.Query.RemoveSpaces(), @"
for `h` in `hosts`
upsert { `_key` : `h`.`_key` }
insert @P1
update { `tags` : append( `h`.`tags` , `OLD` .`tags` ) }
in `hosts`
".RemoveSpaces());
ObjectUtility.AssertSerialize(queryData.BindVars[0].Value, new { }, db);
}
public void UpsertComplexUpdate()
{
var db = DatabaseGenerator.Get();
var query = db.Query()
.Upsert <Host>(_ => new Host {
Ip = "192.168.173.94"
},
_ => new Host {
Ip = "192.168.173.94", Name = "chorweiler", Tags = new string[] { "development" }
},
(_, o) => new Host {
Tags = AQL.Push(o.Tags, "development", true)
})
.In <Host>().ReturnResult(true);
var queryData = query.GetQueryData();
Assert.Equal(queryData.Query.RemoveSpaces(), @"
upsert @P1
insert @P2
update { `tags` : push( `OLD` .`tags` , @P3 , @P4 ) }
in `hosts`
let crudResult = NEW
return crudResult
".RemoveSpaces());
ObjectUtility.AssertSerialize(queryData.BindVars[0].Value, new { ip = "192.168.173.94" }, db);
ObjectUtility.AssertSerialize(queryData.BindVars[1].Value, new { ip = "192.168.173.94", name = "chorweiler", tags = new string[] { "development" } }, db);
Assert.Equal(queryData.BindVars[2].Value, "development");
Assert.Equal(queryData.BindVars[3].Value, true);
}
public static List <Appointment> GetApprovedAppointmentsByDateAndTime(DatabaseManager databaseManager, string date, string time, int minutesgap)
{
long millisecs = minutesgap * 60 * 1000;
return(databaseManager.Database.Query <Appointment>().
Where(s => s.IsApproved && s.Date == date &&
AQL.Abs(AQL.DateTimestamp(time) - AQL.DateTimestamp(s.Time)) < millisecs).ToList());
}
public void GroupBySelectAggregation()
{
var db = DatabaseGenerator.Get();
var query = db.Query <Person>().GroupBy(x => x.Age)
.Select(byAge => new { len = AQL.Length(byAge), byAge.Key, Ages = byAge.Select(x => x.Age) });
Assert.Equal(query.GetQueryData().Query.RemoveSpaces(),
@"for `x` in `Person` collect `CV1` = `x`.`Age` into `C1` return { `len` : length( `C1` ) , `Key` : `CV1` , `Ages` : ( for `x` in `C1` return `x`.`x`.`Age` ) }".RemoveSpaces());
}
public void GroupByNewSingleSelectExpressionKey_SelectOnlyOneKey()
{
var db = DatabaseGenerator.Get();
db.Setting.Linq.TranslateGroupByIntoName = identifier => identifier;
var query = db.Query <Person>().GroupBy(x => new { cage = AQL.ToString(x.Age) }).Select(byAge => byAge.Key.cage);
Assert.Equal(query.GetQueryData().Query.RemoveSpaces(), "for `x` in `Person` collect `cage` = to_string( `x`.`Age` ) into `byAge` return `cage`");
db.Setting.Linq.TranslateGroupByIntoName = null;
}
public void GroupBySingleSelectExpressionKey()
{
var db = DatabaseGenerator.Get();
db.Setting.Linq.TranslateGroupByIntoName = identifier => identifier;
var query = db.Query <Person>().GroupBy(x => AQL.ToString(x.Age)).Select(byAge => byAge.Key);
Assert.Equal("for `x` in `Person` collect `CV1` = to_string( `x`.`Age` ) into `byAge` return `CV1`", query.GetQueryData().Query.RemoveSpaces());
db.Setting.Linq.TranslateGroupByIntoName = null;
}
public IActionResult GetAllUsers([FromQuery] UsersQueryOptions options)
{
using (var db = ArangoDatabase.CreateWithSetting())
{
var query = from u in db.Query <User>()
select new
{
u.Key,
u.Username,
u.RealName,
u.Email,
u.Description,
u.Occupation,
birthday = AQL.DateFormat(u.Birthday, "%dd/%mm/%yyyy")
};
if (options.Name != null)
{
query = query.Where(u => AQL.Contains(AQL.Lower(u.Username), AQL.Lower(options.Name)));
}
if (options.Email != null)
{
query = from u in query
where AQL.Lower(u.Email) == AQL.Lower(options.Email)
select u;
}
if (options.Limit.HasValue)
{
query = query.Take(options.Limit.Value);
}
if (options.Sorted.HasValue && options.Sorted.Value == true)
{
query = query.OrderBy(user => user.Username);
}
var defaultValue = query.FirstOrDefault();
var queryCount = query.Count();
if (query.Count() >= 250 || options.Page.HasValue)
{
var skipValue = (options.Page ?? 0) * 250;
query = query.Skip(skipValue).Take(250).Select(u => u);
}
if (options.MaxElements.HasValue && options.MaxElements.Value > 0)
{
query = query.Take(options.MaxElements.Value);
}
return(Ok(query));
}
}
public async Task <TUser> FindByLoginAsync(string loginProvider, string providerKey, CancellationToken cancellationToken)
{
return(await Database.Query <TUser>()
.Where(d =>
AQL.Length(
Database.Query <TUser>()
.For(a => a.Logins)
.Where(b => b.LoginProvider == loginProvider && b.ProviderKey == providerKey)
.Select(c => c)
) != 0
)
.Select(d => d)
.FirstOrDefaultAsync());
}
public void Create(ConcreteSyntaxEntity syntaxEntity)
{
var syntax = _mapper.Map <ConcreteSyntax>(syntaxEntity);
using (var db = GetDatabase(_config))
{
if (!db.ListCollections().Any(c => c.Name == "ConcreteSyntax"))
{
db.CreateCollection("ConcreteSyntax");
}
if (db.Query <ConcreteSyntax>().Where(p => AQL.Contains(p.FullName, syntax.FullName)).Count() == 0)
{
db.Insert <ConcreteSyntax>(syntax);
}
}
}
public void TraversalFilter()
{
InitiateGraph();
var result = db.Query()
.Traversal <Person, Follow>(alice.Id)
.Depth(1, 6)
.Graph(graphName)
.Where(g => AQL.Length(
db.Query().For(_ => g.Path.Vertices)
.Where(v => v.Id == charlie.Id)
.Select(v => v))
== 0)
.Select(g => g.Vertex)
.ToList();
Assert.Equal(2, result.Count);
}
private string GetLoginFromName(string name)
{
name = name.ToLower();
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException();
}
string[] parts = name.Split(' ');
if (parts.Length != 2)
{
throw new ArgumentException();
}
string userName = parts[0][0].ToString() + "." + parts[1];
int repeats = databaseManager.Database.Query <Credential>()
.Where(c => AQL.Contains(c.Key, userName)).Count();
return(userName + Convert.ToString(repeats));
}
public void UpsertOnCollection()
{
// insert a host
db.Insert <Host>(new Host {
Key = "123", Tags = new string[] { "1", "2", "3" }
});
var result = db.Query <Host>()
.Upsert(h => new Host {
Key = h.Key
},
h => new Host {
},
(h, old) => new Host {
Tags = AQL.Append(h.Tags, old.Tags)
}).Select((n, o) => n).ToList();
Assert.Equal(result.Count, 1);
Assert.Equal(result[0].Tags.Count, 6);
Assert.Equal(result[0].Tags.Count(t => t == "2"), 2);
}
