public override SqlObject VisitLiteral([NotNull] sqlParser.LiteralContext context)
{
TerminalNodeImpl terminalNode = (TerminalNodeImpl)context.children[0];
SqlLiteral sqlLiteral;
switch (terminalNode.Symbol.Type)
{
case sqlParser.STRING_LITERAL:
string value = CstToAstVisitor.GetStringValueFromNode(terminalNode);
sqlLiteral = SqlStringLiteral.Create(value);
break;
case sqlParser.NUMERIC_LITERAL:
Number64 number64 = CstToAstVisitor.GetNumber64ValueFromNode(terminalNode);
sqlLiteral = SqlNumberLiteral.Create(number64);
break;
case sqlParser.K_TRUE:
sqlLiteral = SqlBooleanLiteral.Create(true);
break;
case sqlParser.K_FALSE:
sqlLiteral = SqlBooleanLiteral.Create(false);
break;
case sqlParser.K_NULL:
sqlLiteral = SqlNullLiteral.Create();
break;
case sqlParser.K_UNDEFINED:
sqlLiteral = SqlUndefinedLiteral.Create();
break;
default:
throw new ArgumentOutOfRangeException($"Unknown symbol type: {terminalNode.Symbol.Type}");
}
return(sqlLiteral);
}
public void SqlInScalarExpressionTest()
{
SqlLiteralScalarExpression one = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(1));
SqlLiteralScalarExpression two = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(2));
SqlLiteralScalarExpression three = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(3));
SqlInScalarExpression oneInOneTwoThree = SqlInScalarExpression.Create(one, false, one, two, three);
AssertEvaluation(CosmosBoolean.Create(true), oneInOneTwoThree);
SqlInScalarExpression oneNotInOneTwoThree = SqlInScalarExpression.Create(one, true, one, two, three);
AssertEvaluation(CosmosBoolean.Create(false), oneNotInOneTwoThree);
SqlInScalarExpression oneInTwoThree = SqlInScalarExpression.Create(one, false, two, three);
AssertEvaluation(CosmosBoolean.Create(false), oneInTwoThree);
SqlInScalarExpression oneNotInTwoThree = SqlInScalarExpression.Create(one, true, two, three);
AssertEvaluation(CosmosBoolean.Create(true), oneNotInTwoThree);
}
public override SqlObject VisitTop_spec([NotNull] sqlParser.Top_specContext context)
{
Contract.Requires(context != null);
SqlTopSpec sqlTopSpec;
if (context.NUMERIC_LITERAL() != null)
{
Number64 topCount = CstToAstVisitor.GetNumber64ValueFromNode(context.NUMERIC_LITERAL());
sqlTopSpec = SqlTopSpec.Create(SqlNumberLiteral.Create(topCount));
}
else if (context.PARAMETER() != null)
{
sqlTopSpec = SqlTopSpec.Create(SqlParameter.Create(context.PARAMETER().GetText()));
}
else
{
throw new InvalidOperationException();
}
return(sqlTopSpec);
}
public void SqlSubqueryScalarExpressionTest()
{
SqlLiteralScalarExpression five = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(5));
SqlLiteralScalarExpression three = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(3));
// (SELECT VALUE 5 + 3)
SqlSubqueryScalarExpression subqueryScalarExpression = SqlSubqueryScalarExpression.Create(
SqlQuery.Create(
SqlSelectClause.Create(
SqlSelectValueSpec.Create(
SqlBinaryScalarExpression.Create(
SqlBinaryScalarOperatorKind.Add,
five,
three))),
fromClause: null,
whereClause: null,
groupByClause: null,
orderByClause: null,
offsetLimitClause: null));
AssertEvaluation(CosmosNumber64.Create(5 + 3), subqueryScalarExpression);
}
/// <summary>
/// Constructs <see cref="SqlScalarExpression"/> from a geometry <see cref="JToken"/>.
/// </summary>
/// <param name="jToken">Json token.</param>
/// <returns>Instance of <see cref="SqlScalarExpression"/>.</returns>
private static SqlScalarExpression FromJToken(JToken jToken)
{
switch (jToken.Type)
{
case JTokenType.Array:
return(SqlArrayCreateScalarExpression.Create(jToken.Select(FromJToken).ToArray()));
case JTokenType.Boolean:
return(SqlLiteralScalarExpression.Create(SqlBooleanLiteral.Create(jToken.Value <bool>())));
case JTokenType.Null:
return(SqlLiteralScalarExpression.SqlNullLiteralScalarExpression);
case JTokenType.String:
return(SqlLiteralScalarExpression.Create(SqlStringLiteral.Create(jToken.Value <string>())));
case JTokenType.Object:
SqlObjectProperty[] properties =
((JObject)jToken).Properties()
.Select(
p =>
SqlObjectProperty.Create(
SqlPropertyName.Create(p.Name),
FromJToken(p.Value)))
.ToArray();
return(SqlObjectCreateScalarExpression.Create(properties));
case JTokenType.Float:
case JTokenType.Integer:
SqlNumberLiteral sqlNumberLiteral = SqlNumberLiteral.Create(jToken.Value <double>());
return(SqlLiteralScalarExpression.Create(sqlNumberLiteral));
default:
throw new DocumentQueryException(string.Format(CultureInfo.CurrentCulture, ClientResources.UnexpectedTokenType, jToken.Type));
}
}
public void REPLICATE()
{
// REPLICATE("Hello", -1)
// -> undefined
AssertEvaluation(
expected: Undefined,
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.Replicate,
hello,
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(-1))));
// REPLICATE("Hello", 1.5)
// -> REPLICATE("Hello", 1) due to truncation
AssertEvaluation(
expected: CosmosString.Create("Hello"),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.Replicate,
hello,
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(1.5))));
// REPLICATE("Hello", 10000)
// -> undefined due to 10kb string cap
AssertEvaluation(
expected: Undefined,
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.Replicate,
hello,
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(10000))));
// REPLICATE("Hello", EXP(400))
// -> undefined due to 10kb string cap
AssertEvaluation(
expected: Undefined,
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.Replicate,
hello,
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(Math.Exp(400)))));
}
public void Binary()
{
// Positive
List <SqlParserBaselineTestInput> inputs = new List <SqlParserBaselineTestInput>();
foreach (SqlBinaryScalarOperatorKind binaryOperator in (SqlBinaryScalarOperatorKind[])Enum.GetValues(typeof(SqlBinaryScalarOperatorKind)))
{
inputs.Add(
CreateInput(
description: binaryOperator.ToString(),
scalarExpression: SqlBinaryScalarExpression.Create(
binaryOperator,
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(42)),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(1337))).ToString()));
}
// Order of operations
inputs.Add(CreateInput(
description: "Multiplication, division, and remainder -> left to right",
scalarExpression: "1 / 2 * 3 % 4"));
inputs.Add(CreateInput(
description: "Addition and subtraction -> left to right",
scalarExpression: "1 + 2 - 3 + 4"));
inputs.Add(CreateInput(
description: "Relational operators -> left to right",
scalarExpression: "1 < 2 <= 3 > 4 >= 5"));
inputs.Add(CreateInput(
description: "Equality operators -> left to right",
scalarExpression: "1 = 2 != 3 = 4"));
inputs.Add(CreateInput(
description: "Bitwise AND > Bitwise XOR (exclusive or) > Bitwise OR (inclusive or)",
scalarExpression: "1 | 2 & 3 ^ 4"));
inputs.Add(CreateInput(
description: "Logical AND > Logical OR",
scalarExpression: "1 AND 2 OR 3 AND 4"));
inputs.Add(CreateInput(
description: "Conditional-expression Right to left",
scalarExpression: "1 ? 2 : 3 + 4"));
inputs.Add(CreateInput(
description: "Multiplicative > Additive",
scalarExpression: "1 + 2 * 3 - 4 / 5"));
inputs.Add(CreateInput(
description: "Additive > Relational",
scalarExpression: "1 + 2 < 2 + 3 <= 10 - 4 > 5 >= 3"));
inputs.Add(CreateInput(
description: "Relational > Equality",
scalarExpression: "1 > 2 = false AND 1 > 2 != true"));
inputs.Add(CreateInput(
description: "Equality > Bitwise AND",
scalarExpression: "1 = 2 & 3 != 4"));
inputs.Add(CreateInput(
description: "Bitwise AND > Bitwise Exclusive OR",
scalarExpression: "1 ^ 2 & 3 ^ 4"));
inputs.Add(CreateInput(
description: "Bitwise Exclusive OR > Bitwise Inclusive OR",
scalarExpression: "1 | 2 ^ 3 | 4"));
inputs.Add(CreateInput(
description: "Bitwise Inclusive OR > Logical AND",
scalarExpression: "1 AND 2 | 3 AND 4"));
inputs.Add(CreateInput(
description: "Logical AND > Logical OR",
scalarExpression: "1 OR 2 AND 3 OR 4"));
inputs.Add(CreateInput(
description: "Logical OR > String Concat",
scalarExpression: "1 || 2 OR 3 || 4"));
// Negative
inputs.Add(CreateInput(description: "Missing Right", scalarExpression: "42 +"));
inputs.Add(CreateInput(description: "Missing Left", scalarExpression: "AND 1337"));
inputs.Add(CreateInput(description: "Unknown Operator", scalarExpression: "42 # 1337"));
this.ExecuteTestSuite(inputs);
}
public override SqlObject Visit(SqlTopSpec sqlTopSpec)
{
return(SqlTopSpec.Create(SqlNumberLiteral.Create(0)));
}
public override SqlObject Visit(SqlNumberLiteral sqlNumberLiteral)
{
return(SqlNumberLiteral.Create(
Number64.ToDouble(
this.GetObfuscatedNumber(sqlNumberLiteral.Value))));
}
public void SqlUnaryScalarExpressionTest()
{
SqlLiteralScalarExpression five = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(5));
SqlLiteralScalarExpression trueBoolean = SqlLiteralScalarExpression.Create(SqlBooleanLiteral.True);
{
SqlUnaryScalarExpression bitwiseNot = SqlUnaryScalarExpression.Create(SqlUnaryScalarOperatorKind.BitwiseNot, five);
AssertEvaluation(CosmosNumber64.Create(~5), bitwiseNot);
}
{
SqlLiteralScalarExpression largeNumber = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(130679749712577953));
SqlUnaryScalarExpression bitwiseNot = SqlUnaryScalarExpression.Create(SqlUnaryScalarOperatorKind.BitwiseNot, largeNumber);
AssertEvaluation(CosmosNumber64.Create(-1022657953), bitwiseNot);
}
{
SqlUnaryScalarExpression not = SqlUnaryScalarExpression.Create(SqlUnaryScalarOperatorKind.Not, trueBoolean);
AssertEvaluation(CosmosBoolean.Create(!true), not);
}
{
SqlUnaryScalarExpression minus = SqlUnaryScalarExpression.Create(SqlUnaryScalarOperatorKind.Minus, five);
AssertEvaluation(CosmosNumber64.Create(-5), minus);
}
{
SqlUnaryScalarExpression plus = SqlUnaryScalarExpression.Create(SqlUnaryScalarOperatorKind.Plus, five);
AssertEvaluation(CosmosNumber64.Create(5), plus);
}
}
public void SqlLiteralScalarExpressionTest()
{
SqlLiteralScalarExpression numberLiteral = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(1));
AssertEvaluation(CosmosNumber64.Create(1), numberLiteral);
SqlLiteralScalarExpression stringLiteral = SqlLiteralScalarExpression.Create(SqlStringLiteral.Create("Hello"));
AssertEvaluation(CosmosString.Create("Hello"), stringLiteral);
SqlLiteralScalarExpression trueLiteral = SqlLiteralScalarExpression.Create(SqlBooleanLiteral.True);
AssertEvaluation(CosmosBoolean.Create(true), trueLiteral);
SqlLiteralScalarExpression falseLiteral = SqlLiteralScalarExpression.Create(SqlBooleanLiteral.False);
AssertEvaluation(CosmosBoolean.Create(false), falseLiteral);
SqlLiteralScalarExpression nullLiteral = SqlLiteralScalarExpression.Create(SqlNullLiteral.Singleton);
AssertEvaluation(CosmosNull.Create(), nullLiteral);
SqlLiteralScalarExpression undefinedLiteral = SqlLiteralScalarExpression.Create(SqlUndefinedLiteral.Create());
AssertEvaluation(Undefined, undefinedLiteral);
}
/// <summary>
/// Convert the entire query to a SQL Query.
/// </summary>
/// <returns>The corresponding SQL Query.</returns>
public SqlQuery GetSqlQuery()
{
SqlFromClause fromClause;
if (this.inputQuery != null)
{
#if SUPPORT_SUBQUERIES
fromClause = this.CreateSubqueryFromClause();
#else
throw new DocumentQueryException("SQL subqueries currently not supported");
#endif
}
else
{
fromClause = this.CreateFrom(inputCollectionExpression: null);
}
// Create a SqlSelectClause with the topSpec.
// If the query is flatten then selectClause may have a topSpec. It should be taken in that case.
// If the query doesn't have a selectClause, use SELECT v0 where v0 is the input param.
SqlSelectClause selectClause = this.selectClause;
if (selectClause == null)
{
string parameterName = this.fromParameters.GetInputParameter().Name;
SqlScalarExpression parameterExpression = SqlPropertyRefScalarExpression.Create(null, SqlIdentifier.Create(parameterName));
selectClause = this.selectClause = SqlSelectClause.Create(SqlSelectValueSpec.Create(parameterExpression));
}
selectClause = SqlSelectClause.Create(selectClause.SelectSpec, selectClause.TopSpec ?? this.topSpec, selectClause.HasDistinct);
SqlOffsetLimitClause offsetLimitClause = (this.offsetSpec != null) ?
SqlOffsetLimitClause.Create(this.offsetSpec, this.limitSpec ?? SqlLimitSpec.Create(SqlNumberLiteral.Create(int.MaxValue))) :
offsetLimitClause = default(SqlOffsetLimitClause);
SqlQuery result = SqlQuery.Create(selectClause, fromClause, this.whereClause, /*GroupBy*/ null, this.orderByClause, offsetLimitClause);
return(result);
}
public void SqlConditionalScalarExpressionTest()
{
SqlLiteralScalarExpression nullLiteral = SqlLiteralScalarExpression.Create(SqlNullLiteral.Singleton);
SqlLiteralScalarExpression undefinedLiteral = SqlLiteralScalarExpression.Create(SqlUndefinedLiteral.Create());
SqlLiteralScalarExpression five = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(5));
SqlLiteralScalarExpression three = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(3));
SqlConditionalScalarExpression nullConditionalThreeFive = SqlConditionalScalarExpression.Create(nullLiteral, three, five);
AssertEvaluation(CosmosNumber64.Create(5), nullConditionalThreeFive);
SqlConditionalScalarExpression undefinedCoalesceFive = SqlConditionalScalarExpression.Create(undefinedLiteral, three, five);
AssertEvaluation(CosmosNumber64.Create(5), undefinedCoalesceFive);
SqlLiteralScalarExpression trueBoolean = SqlLiteralScalarExpression.Create(SqlBooleanLiteral.True);
SqlConditionalScalarExpression trueConditionalThreeFive = SqlConditionalScalarExpression.Create(trueBoolean, three, five);
AssertEvaluation(CosmosNumber64.Create(3), trueConditionalThreeFive);
}
public void SqlBinaryScalarExpressionTest()
{
SqlLiteralScalarExpression five = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(5));
SqlLiteralScalarExpression three = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(3));
SqlLiteralScalarExpression hello = SqlLiteralScalarExpression.Create(SqlStringLiteral.Create("Hello"));
SqlLiteralScalarExpression world = SqlLiteralScalarExpression.Create(SqlStringLiteral.Create("World"));
SqlLiteralScalarExpression trueBoolean = SqlLiteralScalarExpression.Create(SqlBooleanLiteral.True);
SqlLiteralScalarExpression falseBoolean = SqlLiteralScalarExpression.Create(SqlBooleanLiteral.False);
SqlLiteralScalarExpression nullLiteral = SqlLiteralScalarExpression.Create(SqlNullLiteral.Singleton);
SqlLiteralScalarExpression undefinedLiteral = SqlLiteralScalarExpression.Create(SqlUndefinedLiteral.Create());
SqlArrayCreateScalarExpression arrayCreateScalarExpresion1 = SqlArrayCreateScalarExpression.Create();
SqlArrayCreateScalarExpression arrayCreateScalarExpresion2 = SqlArrayCreateScalarExpression.Create(five);
SqlObjectCreateScalarExpression objectCreateScalarExpression = SqlObjectCreateScalarExpression.Create();
SqlBinaryScalarExpression fivePlusThree = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Add, five, three);
AssertEvaluation(CosmosNumber64.Create(3 + 5), fivePlusThree);
SqlBinaryScalarExpression trueAndFalse = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.And, trueBoolean, falseBoolean);
AssertEvaluation(CosmosBoolean.Create(true && false), trueAndFalse);
SqlBinaryScalarExpression falseAndUndefined = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.And, falseBoolean, undefinedLiteral);
AssertEvaluation(CosmosBoolean.Create(false), falseAndUndefined);
SqlBinaryScalarExpression trueAndUndefined = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.And, trueBoolean, undefinedLiteral);
AssertEvaluation(Undefined, trueAndUndefined);
try
{
SqlBinaryScalarExpression threeBitwiseAndFive = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.BitwiseAnd, three, five);
AssertEvaluation(CosmosNumber64.Create(1), threeBitwiseAndFive);
}
catch (Exception)
{
}
try
{
SqlBinaryScalarExpression threeBitwiseOrFive = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.BitwiseOr, three, five);
AssertEvaluation(CosmosNumber64.Create(7), threeBitwiseOrFive);
}
catch (Exception)
{
}
try
{
SqlBinaryScalarExpression threeBitwiseXorFive = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.BitwiseXor, three, five);
AssertEvaluation(CosmosNumber64.Create(7), threeBitwiseXorFive);
}
catch (Exception)
{
}
SqlBinaryScalarExpression nullCoalesceFive = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Coalesce, nullLiteral, five);
AssertEvaluation(CosmosNull.Create(), nullCoalesceFive);
SqlBinaryScalarExpression fiveDivideFive = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Divide, five, five);
AssertEvaluation(CosmosNumber64.Create(5 / 5), fiveDivideFive);
SqlBinaryScalarExpression fiveEqualFive = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Equal, five, five);
AssertEvaluation(CosmosBoolean.Create(5 == 5), fiveEqualFive);
SqlBinaryScalarExpression threeEqualFive = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Equal, three, five);
AssertEvaluation(CosmosBoolean.Create(3 == 5), threeEqualFive);
AssertEvaluation(
CosmosBoolean.Create(true),
SqlBinaryScalarExpression.Create(
SqlBinaryScalarOperatorKind.Equal,
arrayCreateScalarExpresion1,
arrayCreateScalarExpresion1));
AssertEvaluation(
CosmosBoolean.Create(false),
SqlBinaryScalarExpression.Create(
SqlBinaryScalarOperatorKind.Equal,
arrayCreateScalarExpresion1,
arrayCreateScalarExpresion2));
AssertEvaluation(
CosmosBoolean.Create(false),
SqlBinaryScalarExpression.Create(
SqlBinaryScalarOperatorKind.Equal,
arrayCreateScalarExpresion1,
objectCreateScalarExpression));
SqlBinaryScalarExpression threeGreaterThanFive = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.GreaterThan, three, five);
AssertEvaluation(CosmosBoolean.Create(3 > 5), threeGreaterThanFive);
SqlBinaryScalarExpression fiveGreaterThanThree = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.GreaterThan, five, three);
AssertEvaluation(CosmosBoolean.Create(5 > 3), fiveGreaterThanThree);
SqlBinaryScalarExpression threeGreaterThanOrEqualFive = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.GreaterThanOrEqual, three, five);
AssertEvaluation(CosmosBoolean.Create(3 >= 5), threeGreaterThanOrEqualFive);
SqlBinaryScalarExpression fiveGreaterThanOrEqualThree = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.GreaterThanOrEqual, five, three);
AssertEvaluation(CosmosBoolean.Create(5 >= 3), fiveGreaterThanOrEqualThree);
SqlBinaryScalarExpression threeLessThanFive = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.LessThan, three, five);
AssertEvaluation(CosmosBoolean.Create(3 < 5), threeLessThanFive);
SqlBinaryScalarExpression fiveLessThanThree = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.LessThan, five, three);
AssertEvaluation(CosmosBoolean.Create(5 < 3), fiveLessThanThree);
SqlBinaryScalarExpression threeLessThanOrEqualFive = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.LessThanOrEqual, three, five);
AssertEvaluation(CosmosBoolean.Create(3 <= 5), threeLessThanOrEqualFive);
SqlBinaryScalarExpression fiveLessThanOrEqualThree = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.LessThanOrEqual, five, three);
AssertEvaluation(CosmosBoolean.Create(5 <= 3), fiveLessThanOrEqualThree);
SqlBinaryScalarExpression fiveModThree = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Modulo, five, three);
AssertEvaluation(CosmosNumber64.Create(5 % 3), fiveModThree);
SqlBinaryScalarExpression fiveMultiplyThree = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Multiply, five, three);
AssertEvaluation(CosmosNumber64.Create(5 * 3), fiveMultiplyThree);
SqlBinaryScalarExpression fiveNotEqualThree = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.NotEqual, five, three);
AssertEvaluation(CosmosBoolean.Create(5 != 3), fiveNotEqualThree);
SqlBinaryScalarExpression fiveNotEqualFive = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.NotEqual, five, five);
AssertEvaluation(CosmosBoolean.Create(5 != 5), fiveNotEqualFive);
SqlBinaryScalarExpression trueOrFalse = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Or, trueBoolean, falseBoolean);
AssertEvaluation(CosmosBoolean.Create(true || false), trueOrFalse);
SqlBinaryScalarExpression trueOrUndefined = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Or, trueBoolean, undefinedLiteral);
AssertEvaluation(CosmosBoolean.Create(true), trueOrUndefined);
SqlBinaryScalarExpression falseOrUndefined = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Or, falseBoolean, undefinedLiteral);
AssertEvaluation(Undefined, falseOrUndefined);
SqlBinaryScalarExpression helloConcatWorld = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.StringConcat, hello, world);
AssertEvaluation(CosmosString.Create("Hello" + "World"), helloConcatWorld);
SqlBinaryScalarExpression fiveSubtract3 = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Subtract, five, three);
AssertEvaluation(CosmosNumber64.Create(5 - 3), fiveSubtract3);
}
public void SqlSelectListSpecTest()
{
CosmosObject john = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["name"] = CosmosString.Create("John"),
["age"] = CosmosNumber64.Create(25)
});
CosmosObject johnWrapped = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["c"] = john
});
// { c.name, c.age }
SqlScalarExpression cDotName = TestUtils.CreatePathExpression("c", "name");
SqlScalarExpression cDotAge = TestUtils.CreatePathExpression("c", "age");
SqlSelectListSpec listSpec = SqlSelectListSpec.Create(
SqlSelectItem.Create(cDotName),
SqlSelectItem.Create(cDotAge));
AssertEvaluation(john, listSpec, johnWrapped);
// { c.name AS nameAlias }
CosmosObject johnAliased = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["nameAlias"] = CosmosString.Create("John"),
});
SqlSelectListSpec listSpecWithAlias = SqlSelectListSpec.Create(SqlSelectItem.Create(cDotName, SqlIdentifier.Create("nameAlias")));
AssertEvaluation(johnAliased, listSpecWithAlias, johnWrapped);
// { 3 + 5 }
CosmosObject johnNonPropertyName = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["$1"] = CosmosNumber64.Create(8)
});
SqlLiteralScalarExpression five = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(5));
SqlLiteralScalarExpression three = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(3));
SqlBinaryScalarExpression fivePlusThree = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Add, five, three);
SqlSelectListSpec listSpecNonMember = SqlSelectListSpec.Create(SqlSelectItem.Create(fivePlusThree));
AssertEvaluation(johnNonPropertyName, listSpecNonMember);
// { 3 + 5 AS Five Plus Three }
CosmosObject johnNonPropertyNameAliased = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["Five Plus Three"] = CosmosNumber64.Create(8)
});
SqlSelectListSpec listSpecNonMemberAliased = SqlSelectListSpec.Create(SqlSelectItem.Create(fivePlusThree, SqlIdentifier.Create("Five Plus Three")));
AssertEvaluation(johnNonPropertyNameAliased, listSpecNonMemberAliased);
// { c.blah[0] }
CosmosObject numberIndex = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["blah"] = CosmosArray.Create(
new List <CosmosElement>()
{
CosmosNumber64.Create(0),
CosmosNumber64.Create(1),
CosmosNumber64.Create(2)
})
});
CosmosObject numberIndexWrapped = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["c"] = numberIndex
});
CosmosObject numberIndexEval = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["$1"] = CosmosNumber64.Create(0)
});
SqlScalarExpression cDotBlah0 = TestUtils.CreatePathExpression("c", "blah", 0);
SqlSelectListSpec numberIndexSpec = SqlSelectListSpec.Create(SqlSelectItem.Create(cDotBlah0));
AssertEvaluation(numberIndexEval, numberIndexSpec, numberIndexWrapped);
}
public void ARRAY_CONTAINS()
{
// ARRAY_CONTAINS(["apples", "strawberries", "bananas"], "apples")
AssertEvaluation(
expected: CosmosBoolean.Create(new string[] { "apples", "strawberries", "bananas" }.Contains("apples")),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArrayContains,
JTokenToSqlScalarExpression.Convert(new JArray("apples", "strawberries", "bananas")),
SqlLiteralScalarExpression.Create(SqlStringLiteral.Create("apples"))));
// ARRAY_CONTAINS(["apples", "strawberries", "bananas"], "mangoes")
AssertEvaluation(
expected: CosmosBoolean.Create(new string[] { "apples", "strawberries", "bananas" }.Contains("mangoes")),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArrayContains,
JTokenToSqlScalarExpression.Convert(new JArray("apples", "strawberries", "bananas")),
SqlLiteralScalarExpression.Create(SqlStringLiteral.Create("mangoes"))));
// ARRAY_CONTAINS([{"name": "apples", "fresh": true}, {"name": "strawberries", "fresh": true}], {"name": "apples"}, true)
AssertEvaluation(
expected: CosmosBoolean.Create(true),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArrayContains,
JTokenToSqlScalarExpression.Convert(new JArray(
JObject.FromObject(new { name = "apples", fresh = true }),
JObject.FromObject(new { name = "strawberries", fresh = true }))),
JTokenToSqlScalarExpression.Convert(JObject.FromObject(new { name = "apples" })),
trueBoolean));
// ARRAY_CONTAINS([{"name": "apples", "fresh": true}, {"name": "strawberries", "fresh": true}], {"name": "apples"}, undefined)
AssertEvaluation(
expected: CosmosBoolean.Create(false),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArrayContains,
JTokenToSqlScalarExpression.Convert(new JArray(
JObject.FromObject(new { name = "apples", fresh = true }),
JObject.FromObject(new { name = "strawberries", fresh = true }))),
JTokenToSqlScalarExpression.Convert(JObject.FromObject(new { name = "apples" })),
SqlLiteralScalarExpression.Create(SqlUndefinedLiteral.Create())));
// ARRAY_CONTAINS([{"name": "apples", "fresh": true}, {"name": "strawberries", "fresh": true}], {"name": "apples"})
AssertEvaluation(
expected: CosmosBoolean.Create(false),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArrayContains,
JTokenToSqlScalarExpression.Convert(new JArray(
JObject.FromObject(new { name = "apples", fresh = true }),
JObject.FromObject(new { name = "strawberries", fresh = true }))),
JTokenToSqlScalarExpression.Convert(JObject.FromObject(new { name = "apples" }))));
// ARRAY_CONTAINS([{"name": "apples", "fresh": true}, {"name": "strawberries", "fresh": true}], {"name": "mangoes"}, true)
AssertEvaluation(
expected: CosmosBoolean.Create(false),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArrayContains,
JTokenToSqlScalarExpression.Convert(new JArray(
JObject.FromObject(new { name = "apples", fresh = true }),
JObject.FromObject(new { name = "strawberries", fresh = true }))),
JTokenToSqlScalarExpression.Convert(JObject.FromObject(new { name = "mangoes" })),
trueBoolean));
// ARRAY_CONTAINS([SQUARE(2), POWER(2, 2)] 2)
AssertEvaluation(
expected: CosmosBoolean.Create(new double[] { 2 * 2, Math.Pow(2, 2) }.Contains(2)),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArrayContains,
SqlArrayCreateScalarExpression.Create(
SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.Square,
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(2))),
SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.Power,
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(2)),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(2)))),
JTokenToSqlScalarExpression.Convert(2)));
}
public void ARRAY_SLICE()
{
// ARRAY_SLICE(["apples", "strawberries", "bananas"], 1)
AssertEvaluation(
expected: CosmosArray.Create(CosmosString.Create("strawberries"), CosmosString.Create("bananas")),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArraySlice,
JTokenToSqlScalarExpression.Convert(new JArray("apples", "strawberries", "bananas")),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(1))));
// ARRAY_SLICE(["apples", "strawberries", "bananas"], 1, 1)
AssertEvaluation(
expected: CosmosArray.Create(CosmosString.Create("strawberries")),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArraySlice,
JTokenToSqlScalarExpression.Convert(new JArray("apples", "strawberries", "bananas")),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(1)),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(1))));
// ARRAY_SLICE(["apples", "strawberries", "bananas"], -2, 1)
AssertEvaluation(
expected: CosmosArray.Create(CosmosString.Create("strawberries")),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArraySlice,
JTokenToSqlScalarExpression.Convert(new JArray("apples", "strawberries", "bananas")),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(-2)),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(1))));
// ARRAY_SLICE(["apples", "strawberries", "bananas"], -2, 2)
AssertEvaluation(
expected: CosmosArray.Create(CosmosString.Create("strawberries"), CosmosString.Create("bananas")),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArraySlice,
JTokenToSqlScalarExpression.Convert(new JArray("apples", "strawberries", "bananas")),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(-2)),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(2))));
// ARRAY_SLICE(["apples", "strawberries", "bananas"], 1, 0)
AssertEvaluation(
expected: CosmosArray.Create(),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArraySlice,
JTokenToSqlScalarExpression.Convert(new JArray("apples", "strawberries", "bananas")),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(1)),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(0))));
// ARRAY_SLICE(["apples", "strawberries", "bananas"], 1, 0)
AssertEvaluation(
expected: CosmosArray.Create(CosmosString.Create("strawberries"), CosmosString.Create("bananas")),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArraySlice,
JTokenToSqlScalarExpression.Convert(new JArray("apples", "strawberries", "bananas")),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(1)),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(1000))));
// ARRAY_SLICE(["apples", "strawberries", "bananas"], 1, 0)
AssertEvaluation(
expected: CosmosArray.Create(),
sqlScalarExpression: SqlFunctionCallScalarExpression.CreateBuiltin(
SqlFunctionCallScalarExpression.Identifiers.ArraySlice,
JTokenToSqlScalarExpression.Convert(new JArray("apples", "strawberries", "bananas")),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(1)),
SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(-100))));
}
/// <summary>
/// Converts a JToken to a semantically equivalent SqlScalarExpression.
/// </summary>
/// <param name="token">The JToken to convert.</param>
/// <returns>The semantically equivalent SqlScalarExpression.</returns>
public static SqlScalarExpression Convert(JToken token)
{
if (token == null)
{
return(Undefined);
}
switch (token.Type)
{
case JTokenType.Array:
{
List <SqlScalarExpression> items = new List <SqlScalarExpression>();
foreach (JToken element in token)
{
items.Add(JTokenToSqlScalarExpression.Convert(element));
}
return(SqlArrayCreateScalarExpression.Create(items.ToArray()));
}
case JTokenType.Boolean:
{
SqlBooleanLiteral literal = SqlBooleanLiteral.Create(token.ToObject <bool>());
return(SqlLiteralScalarExpression.Create(literal));
}
case JTokenType.Null:
{
SqlNullLiteral literal = SqlNullLiteral.Singleton;
return(SqlLiteralScalarExpression.Create(literal));
}
case JTokenType.Integer:
case JTokenType.Float:
{
SqlNumberLiteral literal = SqlNumberLiteral.Create(token.ToObject <double>());
return(SqlLiteralScalarExpression.Create(literal));
}
case JTokenType.Object:
{
List <SqlObjectProperty> properties = new List <SqlObjectProperty>();
foreach (JProperty prop in (JToken)token)
{
SqlPropertyName name = SqlPropertyName.Create(prop.Name);
JToken value = prop.Value;
SqlScalarExpression expression = JTokenToSqlScalarExpression.Convert(value);
SqlObjectProperty property = SqlObjectProperty.Create(name, expression);
properties.Add(property);
}
return(SqlObjectCreateScalarExpression.Create(properties.ToArray()));
}
case JTokenType.String:
{
SqlStringLiteral literal = SqlStringLiteral.Create(token.ToObject <string>());
return(SqlLiteralScalarExpression.Create(literal));
}
default:
throw new ArgumentException(string.Format(CultureInfo.CurrentUICulture, "Unsupported JsonType {0}", token.Type));
}
}
