public void TestJsonConstructorAsDocumentProjection()
{
// same as we use in find().field("{...}")
string projString = "{'a':'value for a', 'b':1+1, 'c'::bindvar, 'd':$.member[22], 'e':{'nested':'doc'}}";
Projection proj = new Projection();
proj.Source = new ExprParser(projString, false).Parse();
Assert.Equal(Expr.Types.Type.Object, proj.Source.Type);
IEnumerator <Mysqlx.Expr.Object.Types.ObjectField> fields = proj.Source.Object.Fld.GetEnumerator();
string[][] array = new string[][] {
new string[] { "a", "\"value for a\"" },
new string[] { "b", "(1 + 1)" },
new string[] { "c", ":0" },
new string[] { "d", "$.member[22]" },
new string[] { "e", "{'nested':\"doc\"}" }
};
array.ToList().ForEach(pair =>
{
fields.MoveNext();
Mysqlx.Expr.Object.Types.ObjectField f = fields.Current;
Assert.Equal(pair[0], f.Key);
Assert.Equal(pair[1], ExprUnparser.ExprToString(f.Value));
});
Assert.False(fields.MoveNext());
}
public long TableCount(Schema schema, string name)
{
string sql = String.Format("SELECT COUNT(*) FROM {0}.{1}",
ExprUnparser.QuoteIdentifier(schema.Name), ExprUnparser.QuoteIdentifier(name));
return((long)ExecuteQueryAsScalar(sql));
}
public void TestExprAsPathDocumentProjection()
{
List <Projection> projList = new ExprParser("$.a as b, (1 + 1) * 100 as x, 2 as j42").ParseDocumentProjection();
Assert.Equal(3, projList.Count);
// check $.a as b
Projection proj = projList[0];
IList <DocumentPathItem> paths = proj.Source.Identifier.DocumentPath;
Assert.Equal(1, paths.Count);
Assert.Equal(DocumentPathItem.Types.Type.Member, paths[0].Type);
Assert.Equal("a", paths[0].Value);
Assert.Equal("b", proj.Alias);
// check (1 + 1) * 100 as x
proj = projList[1];
Assert.Equal("((1 + 1) * 100)", ExprUnparser.ExprToString(proj.Source));
Assert.Equal("x", proj.Alias);
// check 2 as j42
proj = projList[2];
Assert.Equal("2", ExprUnparser.ExprToString(proj.Source));
Assert.Equal("j42", proj.Alias);
}
public void TestStarTableSelectProjection()
{
List <Projection> proj = new ExprParser("*, b as c").ParseTableSelectProjection();
Assert.Equal(2, proj.Count);
Assert.Equal("*", ExprUnparser.ExprToString(proj[0].Source));
Assert.Equal(string.Empty, proj[0].Alias);
Assert.Equal("b", ExprUnparser.ExprToString(proj[1].Source));
Assert.NotEqual(string.Empty, proj[1].Alias);
Assert.Equal("c", proj[1].Alias);
}
public void UnqualifiedDocPaths()
{
Expr expr = new ExprParser("1 + b[0]", false).Parse();
Assert.Equal("(1 + $.b[0])", ExprUnparser.ExprToString(expr));
expr = new ExprParser("a.*", false).Parse();
Assert.Equal("$.a.*", ExprUnparser.ExprToString(expr));
expr = new ExprParser("bL . vT .*", false).Parse();
Assert.Equal("$.bL.vT.*", ExprUnparser.ExprToString(expr));
expr = new ExprParser("dd ** .X", false).Parse();
Assert.Equal("$.dd**.X", ExprUnparser.ExprToString(expr));
}
public void TestComplexTableSelectProjection()
{
string projectionString = "(1 + 1) * 100 as `one-o-two`, 'a is \\'a\\'' as `what is 'a'`";
List <Projection> proj = new ExprParser(projectionString).ParseTableSelectProjection();
Assert.Equal(2, proj.Count);
Assert.Equal("((1 + 1) * 100)", ExprUnparser.ExprToString(proj[0].Source));
Assert.Equal("one-o-two", proj[0].Alias);
Assert.Equal("a is 'a'", proj[1].Source.Literal.VString.Value.ToStringUtf8());
Assert.Equal("what is 'a'", proj[1].Alias);
}
public void JsonColumnPath(string exprString, string unparserString, bool isRelational)
{
if (unparserString == null)
{
Assert.Equal($"Unable to parse query '{exprString}'",
Assert.ThrowsAny <ArgumentException>(() => new ExprParser(exprString, isRelational).Parse()).Message);
}
else
{
Expr expr = new ExprParser(exprString, isRelational).Parse();
Assert.Equal(unparserString, ExprUnparser.ExprToString(expr));
}
}
public long TableCount(Schema schema, string name, string type)
{
try
{
string sql = String.Format("SELECT COUNT(*) FROM {0}.{1}",
ExprUnparser.QuoteIdentifier(schema.Name), ExprUnparser.QuoteIdentifier(name));
return((long)ExecuteQueryAsScalar(sql));
}
catch (MySqlException ex) when(ex.Code == 1146)
{
throw new MySqlException(string.Format(ResourcesX.CollectionTableDoesNotExist, type.ToString(), name, schema.Name));
}
}
public void TestOrderByParserBasic()
{
List <Order> orderSpec = new ExprParser("a, b desc").ParseOrderSpec();
Assert.Equal(2, orderSpec.Count);
Order o1 = orderSpec[0];
Assert.Equal(Order.Types.Direction.None, o1.Direction);
Assert.Equal("a", ExprUnparser.ExprToString(o1.Expr));
Order o2 = orderSpec[1];
Assert.NotEqual(Order.Types.Direction.None, o2.Direction);
Assert.Equal(Order.Types.Direction.Desc, o2.Direction);
Assert.Equal("b", ExprUnparser.ExprToString(o2.Expr));
}
/**
* Check that a string parses and is reconstituted as a string that we expect. Futher we parse the canonical version to make sure it doesn't change.
*/
private void CheckParseRoundTrip(string input, string expected)
{
if (expected == null)
{
expected = input;
}
Expr expr = new ExprParser(input).Parse();
string canonicalized = ExprUnparser.ExprToString(expr);
Assert.Equal(expected, canonicalized);
// System.err.println("Canonicalized: " + canonicalized);
Expr expr2 = new ExprParser(canonicalized).Parse();
string recanonicalized = ExprUnparser.ExprToString(expr2);
Assert.Equal(expected, recanonicalized);
}
public void TestOrderByParserComplexExpressions()
{
List <Order> orderSpec = new ExprParser("field not in ('a',func('b', 2.0),'c') desc, 1-a$**[0].*, now () + $.b + c > 2 asc").ParseOrderSpec();
Assert.Equal(3, orderSpec.Count);
Order o1 = orderSpec[0];
Assert.NotEqual(Order.Types.Direction.None, o1.Direction);
Assert.Equal(Order.Types.Direction.Desc, o1.Direction);
Assert.Equal("field not in(\"a\", func(\"b\", 2), \"c\")", ExprUnparser.ExprToString(o1.Expr));
Order o2 = orderSpec[1];
Assert.Equal(Order.Types.Direction.None, o2.Direction);
Assert.Equal("(1 - a$**[0].*)", ExprUnparser.ExprToString(o2.Expr));
Order o3 = orderSpec[2];
Assert.NotEqual(Order.Types.Direction.None, o3.Direction);
Assert.Equal(Order.Types.Direction.Asc, o3.Direction);
Assert.Equal("(((now() + $.b) + c) > 2)", ExprUnparser.ExprToString(o3.Expr));
}
public void TestJsonLiteral()
{
Expr e = new ExprParser("{'a':1, 'b':\"a string\"}").Parse();
Assert.Equal("{'a':1, 'b':\"a string\"}", ExprUnparser.ExprToString(e));
Assert.Equal(Expr.Types.Type.Object, e.Type);
Mysqlx.Expr.Object o = e.Object;
Assert.Equal(2, o.Fld.Count);
Mysqlx.Expr.Object.Types.ObjectField of;
of = o.Fld[0];
Assert.Equal("a", of.Key);
e = of.Value;
Assert.Equal(Expr.Types.Type.Literal, e.Type);
Assert.Equal(1, e.Literal.VSignedInt);
of = o.Fld[1];
Assert.Equal("b", of.Key);
e = of.Value;
Assert.Equal(Expr.Types.Type.Literal, e.Type);
Assert.Equal("a string", e.Literal.VString.Value.ToStringUtf8());
}
