public override int Visit(SqlObjectProperty sqlObjectProperty)
{
int hashCode = SqlObjectPropertyHashCode;
hashCode = CombineHashes(hashCode, sqlObjectProperty.Name.Accept(this));
hashCode = CombineHashes(hashCode, sqlObjectProperty.Value.Accept(this));
return(hashCode);
}
public void SqlObjectCreateScalarExpressionTest()
{
CosmosObject expected = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["name"] = CosmosString.Create("John")
});
SqlObjectCreateScalarExpression john = SqlObjectCreateScalarExpression.Create(
SqlObjectProperty.Create(SqlPropertyName.Create("name"),
SqlLiteralScalarExpression.Create(SqlStringLiteral.Create("John"))));
AssertEvaluation(expected, john);
}
public override SqlObject VisitObject_property([NotNull] sqlParser.Object_propertyContext context)
{
Contract.Requires(context != null);
Contract.Requires(context.STRING_LITERAL() != null);
Contract.Requires(context.scalar_expression() != null);
string name = CstToAstVisitor.GetStringValueFromNode(context.STRING_LITERAL());
SqlScalarExpression value = (SqlScalarExpression)this.Visit(context.scalar_expression());
SqlObjectProperty property = SqlObjectProperty.Create(
SqlPropertyName.Create(name),
value);
return(property);
}
public override bool Visit(SqlObjectProperty first, SqlObject secondAsObject)
{
if (!(secondAsObject is SqlObjectProperty second))
{
return(false);
}
if (!Equals(first.Name, second.Name))
{
return(false);
}
if (!Equals(first.Value, second.Value))
{
return(false);
}
return(true);
}
public override SqlObject VisitObjectCreateScalarExpression([NotNull] sqlParser.ObjectCreateScalarExpressionContext context)
{
Contract.Requires(context != null);
// '{' object_propertty_list? '}'
List <SqlObjectProperty> properties = new List <SqlObjectProperty>();
if (context.object_property_list() != null)
{
sqlParser.Object_propertyContext[] propertyContexts = context.object_property_list().object_property();
foreach (sqlParser.Object_propertyContext objectPropertyContext in propertyContexts)
{
SqlObjectProperty property = (SqlObjectProperty)this.Visit(objectPropertyContext);
properties.Add(property);
}
}
return(SqlObjectCreateScalarExpression.Create(properties.ToImmutableArray()));
}
/// <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 override SqlObject VisitObjectCreateScalarExpression([NotNull] sqlParser.ObjectCreateScalarExpressionContext context)
{
Contract.Requires(context != null);
// '{' object_propertty_list? '}'
List <SqlObjectProperty> properties = new List <SqlObjectProperty>();
if (context.object_propertty_list() != null)
{
sqlParser.Object_propertyContext[] propertyContexts = context.object_propertty_list().object_property();
foreach (sqlParser.Object_propertyContext objectPropertyContext in propertyContexts)
{
string name = CstToAstVisitor.GetStringValueFromNode(objectPropertyContext.STRING_LITERAL());
SqlScalarExpression value = (SqlScalarExpression)this.Visit(objectPropertyContext.scalar_expression());
SqlObjectProperty property = SqlObjectProperty.Create(
SqlPropertyName.Create(name),
value);
properties.Add(property);
}
}
return(SqlObjectCreateScalarExpression.Create(properties));
}
public abstract void Visit(SqlObjectProperty sqlObject);
public override void Visit(SqlObjectProperty sqlObjectProperty)
{
sqlObjectProperty.Name.Accept(this);
this.writer.Write(": ");
sqlObjectProperty.Value.Accept(this);
}
public override SqlObject Visit(SqlObjectProperty sqlObjectProperty)
{
return(SqlObjectProperty.Create(
sqlObjectProperty.Name.Accept(this) as SqlPropertyName,
sqlObjectProperty.Value.Accept(this) as SqlScalarExpression));
}
public static SqlScalarExpression Substitute(SqlScalarExpression replacement, SqlIdentifier toReplace, SqlScalarExpression into)
{
if (into == null)
{
return(null);
}
if (replacement == null)
{
throw new ArgumentNullException("replacement");
}
switch (into.Kind)
{
case SqlObjectKind.ArrayCreateScalarExpression:
{
SqlArrayCreateScalarExpression arrayExp = into as SqlArrayCreateScalarExpression;
if (arrayExp == null)
{
throw new DocumentQueryException("Expected a SqlArrayCreateScalarExpression, got a " + into.GetType());
}
SqlScalarExpression[] items = new SqlScalarExpression[arrayExp.Items.Count];
for (int i = 0; i < items.Length; i++)
{
SqlScalarExpression item = arrayExp.Items[i];
SqlScalarExpression replitem = Substitute(replacement, toReplace, item);
items[i] = replitem;
}
return(SqlArrayCreateScalarExpression.Create(items));
}
case SqlObjectKind.BinaryScalarExpression:
{
SqlBinaryScalarExpression binaryExp = into as SqlBinaryScalarExpression;
if (binaryExp == null)
{
throw new DocumentQueryException("Expected a BinaryScalarExpression, got a " + into.GetType());
}
SqlScalarExpression replleft = Substitute(replacement, toReplace, binaryExp.LeftExpression);
SqlScalarExpression replright = Substitute(replacement, toReplace, binaryExp.RightExpression);
return(SqlBinaryScalarExpression.Create(binaryExp.OperatorKind, replleft, replright));
}
case SqlObjectKind.UnaryScalarExpression:
{
SqlUnaryScalarExpression unaryExp = into as SqlUnaryScalarExpression;
if (unaryExp == null)
{
throw new DocumentQueryException("Expected a SqlUnaryScalarExpression, got a " + into.GetType());
}
SqlScalarExpression repl = Substitute(replacement, toReplace, unaryExp.Expression);
return(SqlUnaryScalarExpression.Create(unaryExp.OperatorKind, repl));
}
case SqlObjectKind.LiteralScalarExpression:
{
return(into);
}
case SqlObjectKind.FunctionCallScalarExpression:
{
SqlFunctionCallScalarExpression funcExp = into as SqlFunctionCallScalarExpression;
if (funcExp == null)
{
throw new DocumentQueryException("Expected a SqlFunctionCallScalarExpression, got a " + into.GetType());
}
SqlScalarExpression[] items = new SqlScalarExpression[funcExp.Arguments.Count];
for (int i = 0; i < items.Length; i++)
{
SqlScalarExpression item = funcExp.Arguments[i];
SqlScalarExpression replitem = Substitute(replacement, toReplace, item);
items[i] = replitem;
}
return(SqlFunctionCallScalarExpression.Create(funcExp.Name, funcExp.IsUdf, items));
}
case SqlObjectKind.ObjectCreateScalarExpression:
{
SqlObjectCreateScalarExpression objExp = into as SqlObjectCreateScalarExpression;
if (objExp == null)
{
throw new DocumentQueryException("Expected a SqlObjectCreateScalarExpression, got a " + into.GetType());
}
return(SqlObjectCreateScalarExpression.Create(
objExp
.Properties
.Select(prop => SqlObjectProperty.Create(prop.Name, Substitute(replacement, toReplace, prop.Expression)))));
}
case SqlObjectKind.MemberIndexerScalarExpression:
{
SqlMemberIndexerScalarExpression memberExp = into as SqlMemberIndexerScalarExpression;
if (memberExp == null)
{
throw new DocumentQueryException("Expected a SqlMemberIndexerScalarExpression, got a " + into.GetType());
}
SqlScalarExpression replMember = Substitute(replacement, toReplace, memberExp.MemberExpression);
SqlScalarExpression replIndex = Substitute(replacement, toReplace, memberExp.IndexExpression);
return(SqlMemberIndexerScalarExpression.Create(replMember, replIndex));
}
case SqlObjectKind.PropertyRefScalarExpression:
{
// This is the leaf of the recursion
SqlPropertyRefScalarExpression propExp = into as SqlPropertyRefScalarExpression;
if (propExp == null)
{
throw new DocumentQueryException("Expected a SqlPropertyRefScalarExpression, got a " + into.GetType());
}
if (propExp.MemberExpression == null)
{
if (propExp.PropertyIdentifier.Value == toReplace.Value)
{
return(replacement);
}
else
{
return(propExp);
}
}
else
{
SqlScalarExpression replMember = Substitute(replacement, toReplace, propExp.MemberExpression);
return(SqlPropertyRefScalarExpression.Create(replMember, propExp.PropertyIdentifier));
}
}
case SqlObjectKind.ConditionalScalarExpression:
{
SqlConditionalScalarExpression conditionalExpression = (SqlConditionalScalarExpression)into;
if (conditionalExpression == null)
{
throw new ArgumentException();
}
SqlScalarExpression condition = Substitute(replacement, toReplace, conditionalExpression.ConditionExpression);
SqlScalarExpression first = Substitute(replacement, toReplace, conditionalExpression.FirstExpression);
SqlScalarExpression second = Substitute(replacement, toReplace, conditionalExpression.SecondExpression);
return(SqlConditionalScalarExpression.Create(condition, first, second));
}
case SqlObjectKind.InScalarExpression:
{
SqlInScalarExpression inExpression = (SqlInScalarExpression)into;
if (inExpression == null)
{
throw new ArgumentException();
}
SqlScalarExpression expression = Substitute(replacement, toReplace, inExpression.Expression);
SqlScalarExpression[] items = new SqlScalarExpression[inExpression.Items.Count];
for (int i = 0; i < items.Length; i++)
{
items[i] = Substitute(replacement, toReplace, inExpression.Items[i]);
}
return(SqlInScalarExpression.Create(expression, inExpression.Not, items));
}
default:
throw new ArgumentOutOfRangeException("Unexpected Sql Scalar expression kind " + into.Kind);
}
}
public abstract TResult Visit(SqlObjectProperty sqlObject);
public abstract TOutput Visit(SqlObjectProperty sqlObject, TArg input);
/// <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));
}
}
public static SqlScalarExpression Substitute(SqlScalarExpression replacement, SqlIdentifier toReplace, SqlScalarExpression into)
{
if (into == null)
{
return(null);
}
if (replacement == null)
{
throw new ArgumentNullException("replacement");
}
switch (into)
{
case SqlArrayCreateScalarExpression arrayExp:
{
SqlScalarExpression[] items = new SqlScalarExpression[arrayExp.Items.Length];
for (int i = 0; i < items.Length; i++)
{
SqlScalarExpression item = arrayExp.Items[i];
SqlScalarExpression replitem = Substitute(replacement, toReplace, item);
items[i] = replitem;
}
return(SqlArrayCreateScalarExpression.Create(items));
}
case SqlBinaryScalarExpression binaryExp:
{
SqlScalarExpression replleft = Substitute(replacement, toReplace, binaryExp.LeftExpression);
SqlScalarExpression replright = Substitute(replacement, toReplace, binaryExp.RightExpression);
return(SqlBinaryScalarExpression.Create(binaryExp.OperatorKind, replleft, replright));
}
case SqlUnaryScalarExpression unaryExp:
{
SqlScalarExpression repl = Substitute(replacement, toReplace, unaryExp.Expression);
return(SqlUnaryScalarExpression.Create(unaryExp.OperatorKind, repl));
}
case SqlLiteralScalarExpression literalScalarExpression:
{
return(into);
}
case SqlFunctionCallScalarExpression funcExp:
{
SqlScalarExpression[] items = new SqlScalarExpression[funcExp.Arguments.Length];
for (int i = 0; i < items.Length; i++)
{
SqlScalarExpression item = funcExp.Arguments[i];
SqlScalarExpression replitem = Substitute(replacement, toReplace, item);
items[i] = replitem;
}
return(SqlFunctionCallScalarExpression.Create(funcExp.Name, funcExp.IsUdf, items));
}
case SqlObjectCreateScalarExpression objExp:
{
return(SqlObjectCreateScalarExpression.Create(
objExp
.Properties
.Select(prop => SqlObjectProperty.Create(prop.Name, Substitute(replacement, toReplace, prop.Value)))
.ToImmutableArray()));
}
case SqlMemberIndexerScalarExpression memberExp:
{
SqlScalarExpression replMember = Substitute(replacement, toReplace, memberExp.Member);
SqlScalarExpression replIndex = Substitute(replacement, toReplace, memberExp.Indexer);
return(SqlMemberIndexerScalarExpression.Create(replMember, replIndex));
}
case SqlPropertyRefScalarExpression propExp:
{
// This is the leaf of the recursion
if (propExp.Member == null)
{
if (propExp.Identifier.Value == toReplace.Value)
{
return(replacement);
}
else
{
return(propExp);
}
}
else
{
SqlScalarExpression replMember = Substitute(replacement, toReplace, propExp.Member);
return(SqlPropertyRefScalarExpression.Create(replMember, propExp.Identifier));
}
}
case SqlConditionalScalarExpression conditionalExpression:
{
SqlScalarExpression condition = Substitute(replacement, toReplace, conditionalExpression.Condition);
SqlScalarExpression first = Substitute(replacement, toReplace, conditionalExpression.Consequent);
SqlScalarExpression second = Substitute(replacement, toReplace, conditionalExpression.Alternative);
return(SqlConditionalScalarExpression.Create(condition, first, second));
}
case SqlInScalarExpression inExpression:
{
SqlScalarExpression expression = Substitute(replacement, toReplace, inExpression.Needle);
SqlScalarExpression[] items = new SqlScalarExpression[inExpression.Haystack.Length];
for (int i = 0; i < items.Length; i++)
{
items[i] = Substitute(replacement, toReplace, inExpression.Haystack[i]);
}
return(SqlInScalarExpression.Create(expression, inExpression.Not, items));
}
default:
throw new ArgumentOutOfRangeException("Unexpected Sql Scalar expression kind " + into.GetType());
}
}
