public void Query_with_contains_operator()
{
var schema = SchemaFactory.New("items").PrimaryKey("id")
.WithServerSideValue("tags")
.Build();
{
var query = new Parser().ParseSql("select from items where tags contains 'geek' or tags contains electronics").ToQuery(schema);
Assert.AreEqual("items", query.CollectionName);
var q = FindAtomicQuery(query, "tags");
Assert.AreEqual(QueryOperator.Contains, q.Operator);
Assert.IsTrue(q.Values.All(v => v.Type == KeyValue.OriginalType.String));
}
{
var query = new Parser().ParseSql("select * from items where tags not contains 'geek'").ToQuery(schema);
var q = FindAtomicQuery(query, "tags");
Assert.AreEqual(QueryOperator.NotContains, q.Operator);
Assert.IsTrue(q.Values.All(v => v.Type == KeyValue.OriginalType.String));
}
}
public void Query_with_in_operator()
{
var schema = SchemaFactory.New("collection").PrimaryKey("id")
.WithServerSideValue("a")
.WithServerSideValue("x", IndexType.Ordered)
.WithServerSideValue("age", IndexType.Ordered)
.WithServerSideValue("date", IndexType.Ordered)
.Build();
{
var query = new Parser().ParseSql("select from collection where a in (1, 2, 3)").ToQuery(schema);
var q = FindAtomicQuery(query, "a");
Assert.AreEqual(3, q.Values.Count);
Assert.AreEqual(QueryOperator.In, q.Operator);
Assert.IsTrue(q.Values.All(v => v.Type == KeyValue.OriginalType.SomeInteger));
}
{
var query = new Parser().ParseSql("select from collection where a not in (1, 2, 3)").ToQuery(schema);
var q = FindAtomicQuery(query, "a");
Assert.AreEqual(3, q.Values.Count);
Assert.AreEqual(QueryOperator.NotIn, q.Operator);
Assert.IsTrue(q.Values.All(v => v.Type == KeyValue.OriginalType.SomeInteger));
}
}
public void Select_to_query()
{
var schema = SchemaFactory.New("collection").PrimaryKey("id")
.WithServerSideValue("a")
.WithServerSideValue("x", IndexType.Ordered)
.WithServerSideValue("age", IndexType.Ordered)
.WithServerSideValue("date", IndexType.Ordered)
.Build();
var result = new Parser().ParseSql("select from collection where a<>'ttt' or x < 1.22 and x >= 0,5 or age > 18 ");
var query = result.ToQuery(schema);
Assert.AreEqual("collection", query.CollectionName);
Assert.IsTrue(query.IsValid);
var result1 = new Parser().ParseSql("select * from collection where a != 'ttt' or x < 1.22 and x >= 0,5 or age > 18 ");
var query1 = result1.ToQuery(schema);
// the two queries must be identical
Assert.AreEqual(query.ToString(), query1.ToString());
// check if the atomic queries have been correctly generated
var q1 = FindAtomicQuery(query, "a");
Assert.NotNull(q1);
Assert.AreEqual(KeyValue.OriginalType.String, q1.Value.Type);
Assert.AreEqual(QueryOperator.NotEq, q1.Operator);
var q2 = FindAtomicQuery(query, "x");
Assert.NotNull(q2);
Assert.AreEqual(KeyValue.OriginalType.SomeFloat, q2.Value.Type);
Assert.AreEqual(QueryOperator.GeLt, q2.Operator, "query should be optimized as range operator");
var q3 = FindAtomicQuery(query, "age");
Assert.NotNull(q3);
Assert.AreEqual(KeyValue.OriginalType.SomeInteger, q3.Value.Type);
Assert.AreEqual(QueryOperator.Gt, q3.Operator);
var query2 = new Parser().ParseSql("select * from collection where date = 2012-01-31 ").ToQuery(schema);
var q4 = FindAtomicQuery(query2, "date");
Assert.NotNull(q4);
Assert.AreEqual(KeyValue.OriginalType.Date, q4.Value.Type);
Assert.AreEqual(QueryOperator.Eq, q4.Operator);
}
public void Test_manual_schema_factory()
{
var schema = SchemaFactory.New("heroes")
.PrimaryKey("id")
.WithServerSideCollection("tags")
.WithServerSideValue("name", IndexType.Dictionary)
.WithServerSideValue("age", IndexType.Ordered)
.EnableFullTextSearch("tags", "name")
.Build();
// order is preserved for scalars
Assert.Less(schema.OrderOf("name"), schema.OrderOf("age"));
// collections come after all scalar properties
Assert.Less(schema.OrderOf("age"), schema.OrderOf("tags"));
}
public void Other_query_operators()
{
var schema = SchemaFactory.New("collection").PrimaryKey("id")
.WithServerSideValue("a")
.WithServerSideValue("x", IndexType.Ordered)
.WithServerSideValue("age", IndexType.Ordered)
.WithServerSideValue("date", IndexType.Ordered)
.Build();
{
var query = new Parser().ParseSql("select * from collection order by age take 10").ToQuery(schema);
// no where clause
Assert.AreEqual(0, query.Elements.Count);
Assert.AreEqual(10, query.Take);
Assert.AreEqual("age", query.OrderByProperty);
Assert.IsFalse(query.OrderByIsDescending);
}
{
var query = new Parser().ParseSql("select * from collection order by age descending").ToQuery(schema);
// no where clause
Assert.AreEqual(0, query.Elements.Count);
Assert.AreEqual(0, query.Take); // no take clause
Assert.AreEqual("age", query.OrderByProperty);
Assert.IsTrue(query.OrderByIsDescending);
}
{
var query = new Parser().ParseSql("select distinct a, x from collection").ToQuery(schema);
// no where clause
Assert.AreEqual(0, query.Elements.Count);
Assert.AreEqual(0, query.Take); // no take clause
Assert.AreEqual(2, query.SelectClause.Count);
Assert.AreEqual("a", query.SelectClause[0].Name);
Assert.AreEqual("x", query.SelectClause[1].Name);
Assert.IsTrue(query.Distinct);
}
}
public void FluentDescriptionIsEquivalentToTheOldOne()
{
var description = SchemaFactory.New("Order")
.PrimaryKey("Id")
.WithServerSideValue("Amount", IndexType.Ordered)
.WithServerSideValue("Quantity")
.WithServerSideValue("Category", IndexType.Dictionary)
.WithServerSideValue("ProductId", IndexType.Dictionary)
.WithServerSideValue("ClientId", IndexType.Dictionary)
.WithServerSideValue("Date", IndexType.Dictionary)
.WithServerSideValue("DayOfWeek", IndexType.Dictionary)
.WithServerSideValue("Month", IndexType.Dictionary)
.WithServerSideValue("Year", IndexType.Dictionary)
.WithServerSideValue("IsDelivered", IndexType.Dictionary)
.Build();
var description1 = TypedSchemaFactory.FromType <Order>();
Assert.AreEqual(description, description1);
}
public void Projection_query()
{
var schema = SchemaFactory.New("collection").PrimaryKey("id")
.WithServerSideValue("a")
.WithServerSideValue("fx", IndexType.Ordered)
.WithServerSideValue("age", IndexType.Ordered)
.WithServerSideValue("date", IndexType.Ordered)
.Build();
{
var query = new Parser().ParseSql("select fx, age from collection where a in (1, 2, 3)").ToQuery(schema);
var q = FindAtomicQuery(query, "a");
Assert.AreEqual(3, q.Values.Count);
Assert.AreEqual(QueryOperator.In, q.Operator);
Assert.IsTrue(q.Values.All(v => v.Type == KeyValue.OriginalType.SomeInteger));
Assert.AreEqual(2, query.SelectClause.Count);
Assert.AreEqual("fx", query.SelectClause[0].Name);
Assert.AreEqual("fx", query.SelectClause[0].Alias);
}
{
// same with alias
var query = new Parser().ParseSql("select fx forex, age from collection where a in (1, 2, 3)").ToQuery(schema);
var q = FindAtomicQuery(query, "a");
Assert.AreEqual(3, q.Values.Count);
Assert.AreEqual(QueryOperator.In, q.Operator);
Assert.IsTrue(q.Values.All(v => v.Type == KeyValue.OriginalType.SomeInteger));
Assert.AreEqual(2, query.SelectClause.Count);
Assert.AreEqual("fx", query.SelectClause[0].Name);
Assert.AreEqual("forex", query.SelectClause[0].Alias);
}
}
public void Query_with_string_operators()
{
var schema = SchemaFactory.New("items").PrimaryKey("id")
.WithServerSideValue("name")
.Build();
{
var query = new Parser().ParseSql("select from items where name like john% ").ToQuery(schema);
var q = FindAtomicQuery(query, "name");
Assert.AreEqual(QueryOperator.StrStartsWith, q.Operator);
Assert.AreEqual("john", q.Value.StringValue);
Assert.AreEqual(KeyValue.OriginalType.String, q.Value.Type);
}
{
var query = new Parser().ParseSql("select from items where name like %john ").ToQuery(schema);
var q = FindAtomicQuery(query, "name");
Assert.AreEqual(QueryOperator.StrEndsWith, q.Operator);
Assert.AreEqual("john", q.Value.StringValue);
Assert.AreEqual(KeyValue.OriginalType.String, q.Value.Type);
}
{
var query = new Parser().ParseSql("select * from items where name like '%john%' ").ToQuery(schema);
var q = FindAtomicQuery(query, "name");
Assert.AreEqual(QueryOperator.StrContains, q.Operator);
Assert.AreEqual("john", q.Value.StringValue);
Assert.AreEqual(KeyValue.OriginalType.String, q.Value.Type);
}
}
