/// <summary>
/// Create a FROM clause from a set of FROM parameter bindings.
/// </summary>
/// <returns>The created FROM clause.</returns>
private SqlFromClause CreateFrom()
{
SqlCollectionExpression input = null;
foreach (var paramDef in this.fromParameters.GetBindings())
{
var parameter = paramDef.Parameter;
var paramBinding = paramDef.ParameterDefinition;
var ident = new SqlIdentifier(parameter.Name);
SqlCollectionExpression collExpr;
if (!paramDef.IsInCollection)
{
var newInput = new SqlInputPathCollection(ident, null);
collExpr = new SqlAliasedCollectionExpression(newInput, null);
}
else
{
collExpr = new SqlArrayIteratorCollectionExpression(ident, paramBinding);
}
if (input != null)
{
input = new SqlJoinCollectionExpression(input, collExpr);
}
else
{
input = collExpr;
}
}
var fromClause = new SqlFromClause(input);
return(fromClause);
}
public override void Visit(SqlAliasedCollectionExpression sqlAliasedCollectionExpression)
{
sqlAliasedCollectionExpression.Collection.Accept(this);
if (sqlAliasedCollectionExpression.Alias != null)
{
this.writer.Write(" AS ");
sqlAliasedCollectionExpression.Alias.Accept(this);
}
}
/// <summary>
/// Visits a SqlAliasedCollectionExpression and transforms the documents accordingly.
/// </summary>
/// <param name="collectionExpression">The collection expression to visit.</param>
/// <param name="documents">The documents to transform.</param>
/// <returns>The transformed documents according to the collection expression.</returns>
public override IEnumerable <CosmosElement> Visit(SqlAliasedCollectionExpression collectionExpression, IEnumerable <CosmosElement> documents)
{
//If the query was:
//SELECT *
//FROM c
//and the document was:
//{
// "name" : "John"
//}
//Then this function would return:
//{
// "c" : { "name" : "John" }
//}
//which is just wrapping the original document in the identifier.
// Get the sub collection
CollectionEvaluationResult collectionEvaluationResult = collectionExpression.Collection.Accept(
SqlInterpreterCollectionVisitor.Singleton,
documents);
string identifer = collectionEvaluationResult.Identifer;
// Figure out what the alias should be
int aliasCounter = 0;
string alias;
if (collectionExpression.Alias != null)
{
alias = collectionExpression.Alias.Value;
}
else if (identifer != null)
{
alias = identifer;
}
else
{
alias = $"#{aliasCounter++}";
}
// Wrap the collection in the alias so it's easier to bind later
foreach (Tuple <CosmosElement, string> subDocumentAndRid in collectionEvaluationResult.SubDocumentsAndRids)
{
Dictionary <string, CosmosElement> wrappedDocument = new Dictionary <string, CosmosElement>
{
[alias] = subDocumentAndRid.Item1,
//// Add the _rid so that we can break ties for sort later
["_rid"] = CosmosString.Create(subDocumentAndRid.Item2)
};
yield return(CosmosObject.Create(wrappedDocument));
}
}
private SqlFromClause CreateSubqueryFromClause()
{
SqlQuery subquery = this.inputQuery.GetSqlQuery();
SqlSubqueryCollection collection = SqlSubqueryCollection.Create(subquery);
ParameterExpression inputParam = this.inputQuery.Alias;
SqlIdentifier identifier = SqlIdentifier.Create(inputParam.Name);
SqlAliasedCollectionExpression colExp = SqlAliasedCollectionExpression.Create(collection, identifier);
SqlFromClause fromClause = this.CreateFrom(colExp);
return(fromClause);
}
public override int Visit(SqlAliasedCollectionExpression sqlAliasedCollectionExpression)
{
int hashCode = SqlAliasedCollectionExpressionHashCode;
hashCode = CombineHashes(hashCode, sqlAliasedCollectionExpression.Collection.Accept(this));
if (sqlAliasedCollectionExpression.Alias != null)
{
hashCode = CombineHashes(hashCode, sqlAliasedCollectionExpression.Alias.Accept(this));
}
return(hashCode);
}
/// <summary>
/// Create a FROM clause from a set of FROM parameter bindings.
/// </summary>
/// <returns>The created FROM clause.</returns>
private SqlFromClause CreateFrom(SqlCollectionExpression inputCollectionExpression)
{
bool first = true;
foreach (Binding paramDef in this.fromParameters.GetBindings())
{
// If input collection expression is provided, the first binding,
// which is the input paramter name, should be omitted.
if (first)
{
first = false;
if (inputCollectionExpression != null)
{
continue;
}
}
ParameterExpression parameter = paramDef.Parameter;
SqlCollection paramBinding = paramDef.ParameterDefinition;
SqlIdentifier identifier = SqlIdentifier.Create(parameter.Name);
SqlCollectionExpression collExpr;
if (!paramDef.IsInCollection)
{
SqlCollection collection = paramBinding ?? SqlInputPathCollection.Create(identifier, null);
SqlIdentifier alias = paramBinding == null ? null : identifier;
collExpr = SqlAliasedCollectionExpression.Create(collection, alias);
}
else
{
collExpr = SqlArrayIteratorCollectionExpression.Create(identifier, paramBinding);
}
if (inputCollectionExpression != null)
{
inputCollectionExpression = SqlJoinCollectionExpression.Create(inputCollectionExpression, collExpr);
}
else
{
inputCollectionExpression = collExpr;
}
}
SqlFromClause fromClause = SqlFromClause.Create(inputCollectionExpression);
return(fromClause);
}
public override SqlObject VisitAliasedCollectionExpression([NotNull] sqlParser.AliasedCollectionExpressionContext context)
{
Contract.Requires(context != null);
SqlCollection sqlCollection = (SqlCollection)this.Visit(context.collection());
SqlIdentifier alias;
if (context.IDENTIFIER() != null)
{
alias = SqlIdentifier.Create(context.IDENTIFIER().GetText());
}
else
{
alias = default;
}
return(SqlAliasedCollectionExpression.Create(sqlCollection, alias));
}
public override bool Visit(SqlAliasedCollectionExpression first, SqlObject secondAsObject)
{
if (!(secondAsObject is SqlAliasedCollectionExpression second))
{
return(false);
}
if (!first.Alias.Accept(this, second.Alias))
{
return(false);
}
if (!first.Collection.Accept(this, second.Collection))
{
return(false);
}
return(true);
}
public abstract void Visit(SqlAliasedCollectionExpression sqlObject);
public override SqlObject Visit(SqlAliasedCollectionExpression sqlAliasedCollectionExpression)
{
return(SqlAliasedCollectionExpression.Create(
sqlAliasedCollectionExpression.Collection.Accept(this) as SqlCollection,
sqlAliasedCollectionExpression.Alias.Accept(this) as SqlIdentifier));
}
public abstract TResult Visit(SqlAliasedCollectionExpression collectionExpression, TArg input);
public abstract void Visit(SqlAliasedCollectionExpression collectionExpression);
public abstract TResult Visit(SqlAliasedCollectionExpression sqlObject);
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 void JoinCollectionExpressionTest()
{
// FROM f
// JOIN c IN f.children
// JOIN p in c.pets
SqlAliasedCollectionExpression fromf = SqlAliasedCollectionExpression.Create(
SqlInputPathCollection.Create(
SqlIdentifier.Create("f"),
relativePath: null),
alias: null);
SqlArrayIteratorCollectionExpression cInFDotChildren = SqlArrayIteratorCollectionExpression.Create(
SqlIdentifier.Create("c"),
SqlInputPathCollection.Create(
SqlIdentifier.Create("f"),
SqlStringPathExpression.Create(
null,
SqlStringLiteral.Create("children"))));
SqlJoinCollectionExpression joinFC = SqlJoinCollectionExpression.Create(
fromf,
cInFDotChildren);
CosmosElement andersenChild1 = CosmosElement.Parse(@"
{
""f"": {
""id"": ""AndersenFamily"",
""lastName"": ""Andersen"",
""parents"": [
{ ""firstName"": ""Thomas"" },
{ ""firstName"": ""Mary Kay""}
],
""children"": [
{
""firstName"": ""Henriette Thaulow"",
""gender"": ""female"",
""grade"": 5,
""pets"": [{ ""givenName"": ""Fluffy"" }]
}
],
""address"": { ""state"": ""WA"", ""county"": ""King"", ""city"": ""seattle"" },
""creationDate"": 1431620472,
""isRegistered"": true,
""_rid"": ""0fomAIxnukU1AQAAAAAAAA==""
},
""c"": {
""firstName"": ""Henriette Thaulow"",
""gender"": ""female"",
""grade"": 5,
""pets"": [{ ""givenName"": ""Fluffy"" }]
}, ""_rid"": ""0fomAIxnukU1AQAAAAAAAA==""
}");
CosmosElement wakeFieldChild1 = CosmosElement.Parse(@"
{
""f"": {
""id"": ""WakefieldFamily"",
""parents"": [
{ ""familyName"": ""Wakefield"", ""givenName"": ""Robin"" },
{ ""familyName"": ""Miller"", ""givenName"": ""Ben"" }
],
""children"": [
{
""familyName"": ""Merriam"",
""givenName"": ""Jesse"",
""gender"": ""female"", ""grade"": 1,
""pets"": [
{ ""givenName"": ""Goofy"" },
{ ""givenName"": ""Shadow"" }
]
},
{
""familyName"": ""Miller"",
""givenName"": ""Lisa"",
""gender"": ""female"",
""grade"": 8 }
],
""address"": { ""state"": ""NY"", ""county"": ""Manhattan"", ""city"": ""NY"" },
""creationDate"": 1431620462,
""isRegistered"": false,
""_rid"": ""0fomAIxnukU1AQAAAAAAAB==""
},
""c"": {
""familyName"": ""Merriam"",
""givenName"": ""Jesse"",
""gender"": ""female"", ""grade"": 1,
""pets"": [
{ ""givenName"": ""Goofy"" },
{ ""givenName"": ""Shadow"" }
]
}, ""_rid"": ""0fomAIxnukU1AQAAAAAAAB==""
}");
CosmosElement wakeFieldChild2 = CosmosElement.Parse(@"
{
""f"": {
""id"": ""WakefieldFamily"",
""parents"": [
{ ""familyName"": ""Wakefield"", ""givenName"": ""Robin"" },
{ ""familyName"": ""Miller"", ""givenName"": ""Ben"" }
],
""children"": [
{
""familyName"": ""Merriam"",
""givenName"": ""Jesse"",
""gender"": ""female"", ""grade"": 1,
""pets"": [
{ ""givenName"": ""Goofy"" },
{ ""givenName"": ""Shadow"" }
]
},
{
""familyName"": ""Miller"",
""givenName"": ""Lisa"",
""gender"": ""female"",
""grade"": 8 }
],
""address"": { ""state"": ""NY"", ""county"": ""Manhattan"", ""city"": ""NY"" },
""creationDate"": 1431620462,
""isRegistered"": false,
""_rid"": ""0fomAIxnukU1AQAAAAAAAB==""
},
""c"": {
""familyName"": ""Miller"",
""givenName"": ""Lisa"",
""gender"": ""female"",
""grade"": 8 }, ""_rid"": ""0fomAIxnukU1AQAAAAAAAB==""
}");
AssertEvaluation(new CosmosElement[] { andersenChild1, wakeFieldChild1, wakeFieldChild2 }, joinFC, DataSource);
SqlArrayIteratorCollectionExpression pInCDotPets = SqlArrayIteratorCollectionExpression.Create(
SqlIdentifier.Create("p"),
SqlInputPathCollection.Create(
SqlIdentifier.Create("c"),
SqlStringPathExpression.Create(
null,
SqlStringLiteral.Create("pets"))));
SqlJoinCollectionExpression joinFCP = SqlJoinCollectionExpression.Create(
SqlJoinCollectionExpression.Create(fromf, cInFDotChildren),
pInCDotPets);
CosmosElement andersenChild1Pet1 = CosmosElement.Parse(@"
{
""f"": {
""id"": ""AndersenFamily"",
""lastName"": ""Andersen"",
""parents"": [
{ ""firstName"": ""Thomas"" },
{ ""firstName"": ""Mary Kay""}
],
""children"": [
{
""firstName"": ""Henriette Thaulow"",
""gender"": ""female"",
""grade"": 5,
""pets"": [{ ""givenName"": ""Fluffy"" }]
}
],
""address"": { ""state"": ""WA"", ""county"": ""King"", ""city"": ""seattle"" },
""creationDate"": 1431620472,
""isRegistered"": true,
""_rid"": ""0fomAIxnukU1AQAAAAAAAA==""
},
""c"": {
""firstName"": ""Henriette Thaulow"",
""gender"": ""female"",
""grade"": 5,
""pets"": [{ ""givenName"": ""Fluffy"" }]
},
""p"": { ""givenName"": ""Fluffy"" },
""_rid"": ""0fomAIxnukU1AQAAAAAAAA==""
}");
CosmosElement wakeFieldChild1Pet1 = CosmosElement.Parse(@"
{
""f"": {
""id"": ""WakefieldFamily"",
""parents"": [
{ ""familyName"": ""Wakefield"", ""givenName"": ""Robin"" },
{ ""familyName"": ""Miller"", ""givenName"": ""Ben"" }
],
""children"": [
{
""familyName"": ""Merriam"",
""givenName"": ""Jesse"",
""gender"": ""female"", ""grade"": 1,
""pets"": [
{ ""givenName"": ""Goofy"" },
{ ""givenName"": ""Shadow"" }
]
},
{
""familyName"": ""Miller"",
""givenName"": ""Lisa"",
""gender"": ""female"",
""grade"": 8 }
],
""address"": { ""state"": ""NY"", ""county"": ""Manhattan"", ""city"": ""NY"" },
""creationDate"": 1431620462,
""isRegistered"": false,
""_rid"": ""0fomAIxnukU1AQAAAAAAAB==""
},
""c"": {
""familyName"": ""Merriam"",
""givenName"": ""Jesse"",
""gender"": ""female"", ""grade"": 1,
""pets"": [
{ ""givenName"": ""Goofy"" },
{ ""givenName"": ""Shadow"" }
]
},
""p"": { ""givenName"": ""Goofy"" },
""_rid"": ""0fomAIxnukU1AQAAAAAAAB==""
}");
CosmosElement wakeFieldChild1Pet2 = CosmosElement.Parse(@"
{
""f"": {
""id"": ""WakefieldFamily"",
""parents"": [
{ ""familyName"": ""Wakefield"", ""givenName"": ""Robin"" },
{ ""familyName"": ""Miller"", ""givenName"": ""Ben"" }
],
""children"": [
{
""familyName"": ""Merriam"",
""givenName"": ""Jesse"",
""gender"": ""female"", ""grade"": 1,
""pets"": [
{ ""givenName"": ""Goofy"" },
{ ""givenName"": ""Shadow"" }
]
},
{
""familyName"": ""Miller"",
""givenName"": ""Lisa"",
""gender"": ""female"",
""grade"": 8 }
],
""address"": { ""state"": ""NY"", ""county"": ""Manhattan"", ""city"": ""NY"" },
""creationDate"": 1431620462,
""isRegistered"": false,
""_rid"": ""0fomAIxnukU1AQAAAAAAAB==""
},
""c"": {
""familyName"": ""Merriam"",
""givenName"": ""Jesse"",
""gender"": ""female"", ""grade"": 1,
""pets"": [
{ ""givenName"": ""Goofy"" },
{ ""givenName"": ""Shadow"" }
]
},
""p"": { ""givenName"": ""Shadow"" },
""_rid"": ""0fomAIxnukU1AQAAAAAAAB==""
}");
AssertEvaluation(new CosmosElement[] { andersenChild1Pet1, wakeFieldChild1Pet1, wakeFieldChild1Pet2 }, joinFCP, DataSource);
// SELECT c.id
// FROM c
// JOIN c.nonExistent
SqlAliasedCollectionExpression c = SqlAliasedCollectionExpression.Create(
SqlInputPathCollection.Create(
SqlIdentifier.Create("c"),
relativePath: null),
alias: null);
SqlAliasedCollectionExpression cDotNonExistent = SqlAliasedCollectionExpression.Create(
SqlInputPathCollection.Create(
SqlIdentifier.Create("c"),
SqlStringPathExpression.Create(
null,
SqlStringLiteral.Create("nonExistent"))),
alias: null);
SqlJoinCollectionExpression joinCAndCDotNonExistent = SqlJoinCollectionExpression.Create(
c,
cDotNonExistent);
AssertEvaluation(new CosmosElement[] { }, joinCAndCDotNonExistent, DataSource);
}
public abstract TOutput Visit(SqlAliasedCollectionExpression sqlObject, TArg input);
