public override int Visit(SqlSelectValueSpec sqlSelectValueSpec)
{
int hashCode = SqlSelectValueSpecHashCode;
hashCode = CombineHashes(hashCode, sqlSelectValueSpec.Expression.Accept(this));
return(hashCode);
}
/// <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(int.MaxValue)) :
offsetLimitClause = default(SqlOffsetLimitClause);
SqlQuery result = SqlQuery.Create(selectClause, fromClause, this.whereClause, this.orderByClause, offsetLimitClause);
return(result);
}
public override void Visit(SqlSelectValueSpec selectSpec)
{
if (!selectSpec.Expression.Accept(this.groupByProjectionScalarExpressionVisitor))
{
throw new ArgumentException($"{nameof(SqlSelectClause)} has an expression that is neither a group by expression or aggregate.");
}
}
private SqlWhereClause Substitute(SqlSelectSpec spec, SqlIdentifier inputParam, SqlWhereClause whereClause)
{
if (whereClause == null)
{
return(null);
}
if (spec is SqlSelectStarSpec)
{
return(whereClause);
}
else
{
SqlSelectValueSpec selValue = spec as SqlSelectValueSpec;
if (selValue != null)
{
SqlScalarExpression replaced = selValue.Expression;
SqlScalarExpression original = whereClause.FilterExpression;
SqlScalarExpression substituted = SqlExpressionManipulation.Substitute(replaced, inputParam, original);
SqlWhereClause result = SqlWhereClause.Create(substituted);
return(result);
}
}
throw new DocumentQueryException("Unexpected SQL select clause type: " + spec.Kind);
}
private SqlOrderbyClause Substitute(SqlSelectSpec spec, SqlIdentifier inputParam, SqlOrderbyClause orderByClause)
{
if (orderByClause == null)
{
return(null);
}
if (spec is SqlSelectStarSpec)
{
return(orderByClause);
}
SqlSelectValueSpec selValue = spec as SqlSelectValueSpec;
if (selValue != null)
{
SqlScalarExpression replaced = selValue.Expression;
SqlOrderByItem[] substitutedItems = new SqlOrderByItem[orderByClause.OrderbyItems.Count];
for (int i = 0; i < substitutedItems.Length; ++i)
{
SqlScalarExpression substituted = SqlExpressionManipulation.Substitute(replaced, inputParam, orderByClause.OrderbyItems[i].Expression);
substitutedItems[i] = SqlOrderByItem.Create(substituted, orderByClause.OrderbyItems[i].IsDescending);
}
SqlOrderbyClause result = SqlOrderbyClause.Create(substitutedItems);
return(result);
}
throw new DocumentQueryException("Unexpected SQL select clause type: " + spec.Kind);
}
public override CosmosElement Visit(SqlSelectValueSpec selectSpec, CosmosElement document)
{
if (selectSpec == null)
{
throw new ArgumentNullException(nameof(selectSpec));
}
return(selectSpec.Expression.Accept(ScalarExpressionEvaluator.Singleton, document));
}
public override SqlObject VisitSelect_value_spec([NotNull] sqlParser.Select_value_specContext context)
{
Contract.Requires(context != null);
SqlScalarExpression scalarExpression = (SqlScalarExpression)this.Visit(context.scalar_expression());
SqlSelectValueSpec sqlSelectValueSpec = SqlSelectValueSpec.Create(scalarExpression);
return(sqlSelectValueSpec);
}
public override bool Visit(SqlSelectValueSpec first, SqlObject secondAsObject)
{
if (!(secondAsObject is SqlSelectValueSpec second))
{
return(false);
}
if (!Equals(first.Expression, second.Expression))
{
return(false);
}
return(true);
}
public void SqlArrayScalarExpressionTest()
{
CosmosObject tag = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["name"] = CosmosString.Create("asdf")
});
CosmosObject tags = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["tags"] = CosmosArray.Create(new List <CosmosElement>()
{
tag
}),
["_rid"] = CosmosString.Create("AYIMAMmFOw8YAAAAAAAAAA==")
});
CosmosObject tagsWrapped = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["c"] = tags,
["_rid"] = CosmosString.Create("AYIMAMmFOw8YAAAAAAAAAA==")
});
// ARRAY(SELECT VALUE t.name FROM t in c.tags)
SqlArrayScalarExpression arrayScalarExpression = SqlArrayScalarExpression.Create(
SqlQuery.Create(
SqlSelectClause.Create(
SqlSelectValueSpec.Create(
TestUtils.CreatePathExpression("t", "name"))),
SqlFromClause.Create(
SqlArrayIteratorCollectionExpression.Create(
SqlIdentifier.Create("t"),
SqlInputPathCollection.Create(
SqlIdentifier.Create("c"),
SqlStringPathExpression.Create(
null,
SqlStringLiteral.Create("tags"))))),
whereClause: null,
groupByClause: null,
orderByClause: null,
offsetLimitClause: null));
CosmosArray tagNames = CosmosArray.Create(new List <CosmosElement>()
{
CosmosString.Create("asdf")
});
AssertEvaluation(tagNames, arrayScalarExpression, tagsWrapped);
}
public void SqlSelectValueSpecTest()
{
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
});
SqlScalarExpression cDotName = TestUtils.CreatePathExpression("c", "name");
SqlSelectValueSpec valueSpec = SqlSelectValueSpec.Create(cDotName);
AssertEvaluation(CosmosString.Create("John"), valueSpec, johnWrapped);
}
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);
}
private SqlSelectClause Substitute(SqlSelectClause inputSelectClause, SqlTopSpec topSpec, SqlIdentifier inputParam, SqlSelectClause selectClause)
{
SqlSelectSpec selectSpec = inputSelectClause.SelectSpec;
if (selectClause == null)
{
return(selectSpec != null?SqlSelectClause.Create(selectSpec, topSpec, inputSelectClause.HasDistinct) : null);
}
if (selectSpec is SqlSelectStarSpec)
{
return(SqlSelectClause.Create(selectSpec, topSpec, inputSelectClause.HasDistinct));
}
SqlSelectValueSpec selValue = selectSpec as SqlSelectValueSpec;
if (selValue != null)
{
SqlSelectSpec intoSpec = selectClause.SelectSpec;
if (intoSpec is SqlSelectStarSpec)
{
return(SqlSelectClause.Create(selectSpec, topSpec, selectClause.HasDistinct || inputSelectClause.HasDistinct));
}
SqlSelectValueSpec intoSelValue = intoSpec as SqlSelectValueSpec;
if (intoSelValue != null)
{
SqlScalarExpression replacement = SqlExpressionManipulation.Substitute(selValue.Expression, inputParam, intoSelValue.Expression);
SqlSelectValueSpec selValueReplacement = SqlSelectValueSpec.Create(replacement);
return(SqlSelectClause.Create(selValueReplacement, topSpec, selectClause.HasDistinct || inputSelectClause.HasDistinct));
}
throw new DocumentQueryException("Unexpected SQL select clause type: " + intoSpec.Kind);
}
throw new DocumentQueryException("Unexpected SQL select clause type: " + selectSpec.Kind);
}
/// <summary>
/// Flatten subqueries into a single query by substituting their expressions in the current query.
/// </summary>
/// <returns>A flattened query.</returns>
private QueryUnderConstruction Flatten()
{
// SELECT fo(y) FROM y IN (SELECT fi(x) FROM x WHERE gi(x)) WHERE go(y)
// is translated by substituting fi(x) for y in the outer query
// producing
// SELECT fo(fi(x)) FROM x WHERE gi(x) AND (go(fi(x))
if (this.inputQuery == null)
{
// we are flat already
if (this.selectClause == null)
{
// If selectClause doesn't exists, use SELECT v0 where v0 is the input parameter, instead of SELECT *.
string parameterName = this.fromParameters.GetInputParameter().Name;
SqlScalarExpression parameterExpression = SqlPropertyRefScalarExpression.Create(null, SqlIdentifier.Create(parameterName));
this.selectClause = SqlSelectClause.Create(SqlSelectValueSpec.Create(parameterExpression));
}
else
{
this.selectClause = SqlSelectClause.Create(this.selectClause.SelectSpec, this.topSpec, this.selectClause.HasDistinct);
}
return(this);
}
QueryUnderConstruction flatInput = this.inputQuery.Flatten();
SqlSelectClause inputSelect = flatInput.selectClause;
SqlWhereClause inputwhere = flatInput.whereClause;
// Determine the paramName to be replaced in the current query
// It should be the top input parameter name which is not binded in this collection.
// That is because if it has been binded before, it has global scope and should not be replaced.
string paramName = null;
HashSet <string> inputQueryParams = new HashSet <string>();
foreach (Binding binding in this.inputQuery.fromParameters.GetBindings())
{
inputQueryParams.Add(binding.Parameter.Name);
}
foreach (Binding binding in this.fromParameters.GetBindings())
{
if (binding.ParameterDefinition == null || inputQueryParams.Contains(binding.Parameter.Name))
{
paramName = binding.Parameter.Name;
}
}
SqlIdentifier replacement = SqlIdentifier.Create(paramName);
SqlSelectClause composedSelect = Substitute(inputSelect, inputSelect.TopSpec ?? this.topSpec, replacement, this.selectClause);
SqlWhereClause composedWhere = Substitute(inputSelect.SelectSpec, replacement, this.whereClause);
SqlOrderbyClause composedOrderBy = Substitute(inputSelect.SelectSpec, replacement, this.orderByClause);
SqlWhereClause and = QueryUnderConstruction.CombineWithConjunction(inputwhere, composedWhere);
FromParameterBindings fromParams = QueryUnderConstruction.CombineInputParameters(flatInput.fromParameters, this.fromParameters);
SqlOffsetSpec offsetSpec;
SqlLimitSpec limitSpec;
if (flatInput.offsetSpec != null)
{
offsetSpec = flatInput.offsetSpec;
limitSpec = flatInput.limitSpec;
}
else
{
offsetSpec = this.offsetSpec;
limitSpec = this.limitSpec;
}
QueryUnderConstruction result = new QueryUnderConstruction(this.aliasCreatorFunc)
{
selectClause = composedSelect,
whereClause = and,
inputQuery = null,
fromParameters = flatInput.fromParameters,
orderByClause = composedOrderBy ?? this.inputQuery.orderByClause,
offsetSpec = offsetSpec,
limitSpec = limitSpec,
alias = new Lazy <ParameterExpression>(() => this.Alias)
};
return(result);
}
public void AliasedCollectionExpressionTest()
{
// FROM c
SqlAliasedCollectionExpression fromC = SqlAliasedCollectionExpression.Create(
SqlInputPathCollection.Create(
SqlIdentifier.Create("c"),
relativePath: null),
alias: null);
CosmosObject andersenWrapped = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["c"] = AndersenFamily,
["_rid"] = AndersenFamily["_rid"]
});
CosmosObject wakeFieldWrapped = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["c"] = WakefieldFamily,
["_rid"] = WakefieldFamily["_rid"]
});
AssertEvaluation(new CosmosElement[] { andersenWrapped, wakeFieldWrapped }, fromC, DataSource);
// FROM c.id
SqlAliasedCollectionExpression fromCDotId = SqlAliasedCollectionExpression.Create(
SqlInputPathCollection.Create(
SqlIdentifier.Create("c"),
SqlIdentifierPathExpression.Create(
null,
SqlIdentifier.Create("id"))),
alias: null);
CosmosObject andersenId = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["id"] = CosmosString.Create("AndersenFamily"),
["_rid"] = AndersenFamily["_rid"]
});
CosmosObject wakefieldId = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["id"] = CosmosString.Create("WakefieldFamily"),
["_rid"] = WakefieldFamily["_rid"]
});
AssertEvaluation(new CosmosElement[] { andersenId, wakefieldId }, fromCDotId, DataSource);
// FROM c.id AS familyId
SqlAliasedCollectionExpression fromCDotIdAsFamilyId = SqlAliasedCollectionExpression.Create(
SqlInputPathCollection.Create(
SqlIdentifier.Create("c"),
SqlIdentifierPathExpression.Create(
null,
SqlIdentifier.Create("id"))),
SqlIdentifier.Create("familyId"));
CosmosObject andersenIdAsFamilyId = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["familyId"] = CosmosString.Create("AndersenFamily"),
["_rid"] = AndersenFamily["_rid"]
});
CosmosObject wakefieldIdAsFamilyId = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["familyId"] = CosmosString.Create("WakefieldFamily"),
["_rid"] = WakefieldFamily["_rid"]
});
AssertEvaluation(new CosmosElement[] { andersenIdAsFamilyId, wakefieldIdAsFamilyId }, fromCDotIdAsFamilyId, DataSource);
// FROM (SELECT VALUE child["grade"] FROM child IN c.children) grade
SqlAliasedCollectionExpression fromSubqueryGrades = SqlAliasedCollectionExpression.Create(
SqlSubqueryCollection.Create(
SqlQuery.Create(
SqlSelectClause.Create(
SqlSelectValueSpec.Create(
TestUtils.CreatePathExpression("child", "grade"))),
SqlFromClause.Create(
SqlArrayIteratorCollectionExpression.Create(
SqlIdentifier.Create("child"),
SqlInputPathCollection.Create(
SqlIdentifier.Create("c"),
SqlStringPathExpression.Create(
null,
SqlStringLiteral.Create("children"))))),
whereClause: null,
groupByClause: null,
orderByClause: null,
offsetLimitClause: null)),
SqlIdentifier.Create("grade"));
CosmosObject henrietteWrapped = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["grade"] = CosmosNumber64.Create(5),
["_rid"] = AndersenFamily["_rid"]
});
CosmosObject jesseWrapped = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["grade"] = CosmosNumber64.Create(1),
["_rid"] = WakefieldFamily["_rid"]
});
CosmosObject lisaWrapped = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["grade"] = CosmosNumber64.Create(8),
["_rid"] = WakefieldFamily["_rid"]
});
AssertEvaluation(
new CosmosElement[]
{
henrietteWrapped,
jesseWrapped,
lisaWrapped
},
fromSubqueryGrades,
DataSource);
}
public override void Visit(SqlSelectValueSpec sqlSelectValueSpec)
{
this.writer.Write("VALUE ");
sqlSelectValueSpec.Expression.Accept(this);
}
public override SqlObject Visit(SqlSelectValueSpec sqlSelectValueSpec)
{
return(SqlSelectValueSpec.Create(sqlSelectValueSpec.Expression.Accept(this) as SqlScalarExpression));
}
public void SqlExistsScalarExpressionTest()
{
CosmosObject tag = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["name"] = CosmosString.Create("asdf")
});
CosmosObject tags = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["tags"] = CosmosArray.Create(new List <CosmosElement>()
{
tag
}),
["_rid"] = CosmosString.Create("AYIMAMmFOw8YAAAAAAAAAA==")
});
CosmosObject tagsWrapped = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["c"] = tags,
["_rid"] = CosmosString.Create("AYIMAMmFOw8YAAAAAAAAAA==")
});
// EXISTS(SELECT VALUE t.name FROM t in c.tags where t.name = "asdf")
SqlExistsScalarExpression existsScalarExpressionMatched = SqlExistsScalarExpression.Create(
SqlQuery.Create(
SqlSelectClause.Create(
SqlSelectValueSpec.Create(
TestUtils.CreatePathExpression("t", "name"))),
SqlFromClause.Create(
SqlArrayIteratorCollectionExpression.Create(
SqlIdentifier.Create("t"),
SqlInputPathCollection.Create(
SqlIdentifier.Create("c"),
SqlStringPathExpression.Create(
null,
SqlStringLiteral.Create("tags"))))),
SqlWhereClause.Create(
SqlBinaryScalarExpression.Create(
SqlBinaryScalarOperatorKind.Equal,
TestUtils.CreatePathExpression("t", "name"),
SqlLiteralScalarExpression.Create(SqlStringLiteral.Create("asdf")))),
groupByClause: null,
orderByClause: null,
offsetLimitClause: null));
AssertEvaluation(CosmosBoolean.Create(true), existsScalarExpressionMatched, tagsWrapped);
SqlExistsScalarExpression existsScalarExpressionNotMatched = SqlExistsScalarExpression.Create(
SqlQuery.Create(
SqlSelectClause.Create(
SqlSelectValueSpec.Create(
TestUtils.CreatePathExpression("t", "name"))),
SqlFromClause.Create(
SqlArrayIteratorCollectionExpression.Create(
SqlIdentifier.Create("t"),
SqlInputPathCollection.Create(
SqlIdentifier.Create("c"),
SqlStringPathExpression.Create(
null,
SqlStringLiteral.Create("tags"))))),
SqlWhereClause.Create(
SqlBinaryScalarExpression.Create(
SqlBinaryScalarOperatorKind.NotEqual,
TestUtils.CreatePathExpression("t", "name"),
SqlLiteralScalarExpression.Create(SqlStringLiteral.Create("asdf")))),
groupByClause: null,
orderByClause: null,
offsetLimitClause: null));
AssertEvaluation(CosmosBoolean.Create(false), existsScalarExpressionNotMatched, tagsWrapped);
}
public abstract TOutput Visit(SqlSelectValueSpec selectSpec, TArg input);
public abstract TResult Visit(SqlSelectValueSpec selectSpec);
public abstract TResult Visit(SqlSelectValueSpec sqlObject);
public abstract TOutput Visit(SqlSelectValueSpec sqlObject, TArg input);
public abstract void Visit(SqlSelectValueSpec selectSpec);
public override bool Visit(SqlSelectValueSpec selectSpec)
{
return(selectSpec.Expression.Accept(AggregateScalarExpressionDetector.Singleton));
}
public abstract void Visit(SqlSelectValueSpec sqlObject);
public override SqlSelectSpec Visit(SqlSelectValueSpec selectSpec)
{
return(SqlSelectValueSpec.Create(selectSpec.Expression.Accept(this.scalarExpressionTransformer)));
}
