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);
}
public override int Visit(SqlWhereClause sqlWhereClause)
{
int hashCode = SqlWhereClauseHashCode;
hashCode = CombineHashes(hashCode, sqlWhereClause.FilterExpression.Accept(this));
return(hashCode);
}
public virtual void Visiting(SqlWhereClause whereClause)
{
if (whereClause.HasChild())
{
sqlBuilder.Append(" Where ");
}
}
public override SqlObject VisitWhere_clause([NotNull] sqlParser.Where_clauseContext context)
{
Contract.Requires(context != null);
SqlScalarExpression sqlScalarExpression = (SqlScalarExpression)this.Visit(context.scalar_expression());
return(SqlWhereClause.Create(sqlScalarExpression));
}
public void SqlStringTest()
{
ISqlObject source = new SqlServerSource("Table");
SqlWhereClause target = new SqlWhereClause();
target.Condition = new SqlServerField(source, "ID", null).GreaterThan(new SqlStringExpression("1000"));
Assert.AreEqual <string>(string.Format("{0} {1}", target.Keyword, target.Condition.SqlString), target.SqlString);
}
public void ExecuteWhereClause(SqlWhereClause whereClause)
{
foreach (var child in whereClause.Children)
{
var filter = HelperConditional.GetRowFilter(( SqlBooleanExpression )child, this);
RawRowList = RawRowList.Where(r => filter.IsValid(r)).ToList( );
}
}
public override void Visit(SqlWhereClause codeObject)
{
_stringBuilder.Append("WHERE");
using (_stringBuilder.CreateIndentationContext())
{
_stringBuilder.AppendIndentedLine();
codeObject.Expression.Accept(this);
}
}
private void AddWhereParameter(MemoryDbDataReader.ResultBatchWithRawRows batch, RawData rawData,
List <RawTableRow> rows, SqlWhereClause whereClause)
{
var tableColumn = Helper.FindTableAndColumn(null, _PartitionField, rawData.TableAliasList);
var value = new SelectDataFromColumn(tableColumn, _RawData).Select(new RawTableJoinRow(rows));
rawData.Parameters.Add(new MemoryDbParameter {
ParameterName = _PartitionField, Value = value
});
rawData.WhereClause = whereClause.Expression;
}
public SqlSelectQuery <T> Where(Expression <Func <T, bool> > predicate)
{
if (predicate == null)
{
return(this);
}
var clause = new SqlWhereClause(predicate);
Clauses.Add(clause);
return(this);
}
public void GetHashCodeTest()
{
const string cn = "columnName";
const string cv = "columnValue";
var swc1 = HelperObjectFactory.MakeSqlWhereClause();
var swc2 = HelperObjectFactory.MakeSqlWhereClause(Conjunction.Between, cn, Operator.NotEqual, cv);
var swc3 = new SqlWhereClause(swc1);
Assert.AreEqual(swc1.GetHashCode(), swc1.GetHashCode());
Assert.AreEqual(swc1.GetHashCode(), swc3.GetHashCode());
Assert.AreNotEqual(swc1.GetHashCode(), swc2.GetHashCode());
}
public SqlQuery(
SqlSelectClause selectClause,
SqlFromClause fromClause,
SqlWhereClause whereClause,
SqlOrderbyClause orderbyClause)
: base(SqlObjectKind.Query)
{
this.SelectClause = selectClause;
this.FromClause = fromClause;
this.WhereClause = whereClause;
this.OrderbyClause = orderbyClause;
}
public SqlSelectQuery <T> Where(string predicate)
{
if (predicate == null)
{
return(this);
}
var exp = Expression.Constant(predicate);
var clause = new SqlWhereClause(exp as Expression);
Clauses.Add(clause);
return(this);
}
private static IEnumerable <CosmosElement> ExecuteWhereClause(
IEnumerable <CosmosElement> dataSource,
SqlWhereClause sqlWhereClause)
{
return(dataSource
.Where(element =>
{
CosmosElement evaluation = sqlWhereClause.FilterExpression.Accept(
ScalarExpressionEvaluator.Singleton,
element);
return evaluation is CosmosBoolean cosmosBoolean && cosmosBoolean.Value;
}));
}
/// <summary>
/// Add a Where clause to a query; may need to create a new query.
/// </summary>
/// <param name="whereClause">Clause to add.</param>
/// <param name="context">The translation context.</param>
/// <returns>A new query containing the specified Where clause.</returns>
public QueryUnderConstruction AddWhereClause(SqlWhereClause whereClause, TranslationContext context)
{
QueryUnderConstruction result = context.PackageCurrentQueryIfNeccessary();
whereClause = QueryUnderConstruction.CombineWithConjunction(result.whereClause, whereClause);
result.whereClause = whereClause;
foreach (Binding binding in context.CurrentSubqueryBinding.TakeBindings())
{
result.AddBinding(binding);
}
return(result);
}
public override bool Visit(SqlWhereClause first, SqlObject secondAsObject)
{
if (!(secondAsObject is SqlWhereClause second))
{
return(false);
}
if (!Equals(first.FilterExpression, second.FilterExpression))
{
return(false);
}
return(true);
}
/// <summary>
/// Add a Where clause to a query; may need to create a new query.
/// </summary>
/// <param name="whereClause">Clause to add.</param>
/// <param name="elementType">Type of element in input collection.</param>
/// <param name="inScope">Set of parameter names in scope.</param>
/// <returns>A new query containing the specified Where clause.</returns>
public QueryUnderConstruction AddWhereClause(SqlWhereClause whereClause, Type elementType, HashSet <ParameterExpression> inScope)
{
QueryUnderConstruction.ValidateNonSubquerySupport(this);
QueryUnderConstruction result = this;
if (this.selectClause != null)
{
result = this.PackageQuery(inScope);
}
whereClause = QueryUnderConstruction.CombineWithConjunction(result.whereClause, whereClause);
result.whereClause = whereClause;
return(result);
}
public void EqualsTest()
{
const string cn = "columnName";
const string cv = "columnValue";
var swc1 = HelperObjectFactory.MakeSqlWhereClause();
var swc2 = HelperObjectFactory.MakeSqlWhereClause(Conjunction.Between, cn, Operator.NotEqual, cv);
var swc3 = new SqlWhereClause(swc1);
Assert.IsFalse(swc1.Equals((object)null));
Assert.IsFalse(swc1.Equals(null));
Assert.IsTrue(swc1.Equals((object)swc1));
Assert.IsTrue(swc1.Equals(swc1));
Assert.IsFalse(swc1.Equals(swc2));
Assert.IsTrue(swc1.Equals(swc3));
}
public void ConstructorAndPropertiesTests()
{
const string cn = "columnName";
const string cv = "columnValue";
var swc = HelperObjectFactory.MakeSqlWhereClause(Conjunction.Between, cn, Operator.NotEqual, cv);
Assert.AreEqual(Conjunction.Between, swc.Conjunction);
Assert.AreEqual(cn, swc.ColumnName);
Assert.AreEqual(Operator.NotEqual, swc.Operator);
Assert.AreEqual(cv, swc.ColumnValue);
var swc2 = new SqlWhereClause(swc);
Assert.AreEqual(swc2.Conjunction, swc.Conjunction);
Assert.AreEqual(swc2.ColumnName, swc.ColumnName);
Assert.AreEqual(swc2.Operator, swc.Operator);
Assert.AreEqual(swc2.ColumnValue, swc.ColumnValue);
}
private static SqlWhereClause CombineWithConjunction(SqlWhereClause first, SqlWhereClause second)
{
if (first == null)
{
return(second);
}
if (second == null)
{
return(first);
}
var previousFilter = first.FilterExpression;
var currentFilter = second.FilterExpression;
var and = new SqlBinaryScalarExpression(SqlBinaryScalarOperatorKind.And, previousFilter, currentFilter);
var result = new SqlWhereClause(and);
return(result);
}
private static SqlWhereClause CombineWithConjunction(SqlWhereClause first, SqlWhereClause second)
{
if (first == null)
{
return(second);
}
if (second == null)
{
return(first);
}
SqlScalarExpression previousFilter = first.FilterExpression;
SqlScalarExpression currentFilter = second.FilterExpression;
SqlBinaryScalarExpression and = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.And, previousFilter, currentFilter);
SqlWhereClause result = SqlWhereClause.Create(and);
return(result);
}
/// <summary>
/// Add a Where clause to a query; may need to create a new query.
/// </summary>
/// <param name="whereClause">Clause to add.</param>
/// <param name="context">The translation context.</param>
/// <returns>A new query containing the specified Where clause.</returns>
public QueryUnderConstruction AddWhereClause(SqlWhereClause whereClause, TranslationContext context)
{
QueryUnderConstruction result = this;
if (this.ShouldBeOnNewQuery(LinqMethods.Where, 2))
{
result = this.PackageQuery(context.InScope, context.PeekCollection());
context.CurrentSubqueryBinding.ShouldBeOnNewQuery = false;
}
whereClause = QueryUnderConstruction.CombineWithConjunction(result.whereClause, whereClause);
result.whereClause = whereClause;
foreach (Binding binding in context.CurrentSubqueryBinding.TakeBindings())
{
result.AddBinding(binding);
}
return(result);
}
private void AddConditions(SqlWhereClause where, ISqlTableSource table)
{
var keys = table.GetKeys(true);
if (keys == null)
{
return;
}
foreach (var key in keys.OfType <SqlField>())
{
var maxValue = GetMaxValue(key.DataType);
if (maxValue == null)
{
continue;
}
var cond = new SqlSearchCondition();
cond = cond.Expr(key).IsNull.Or;
if (maxValue is string)
{
cond.Expr(key).GreaterOrEqual.Expr(new SqlValue(maxValue));
}
else
{
cond.Expr(key).LessOrEqual.Expr(new SqlValue(maxValue));
}
where.ConcatSearchCondition(cond);
// only one field is enough
break;
}
}
public abstract void Visit(SqlWhereClause sqlObject);
public abstract TOutput Visit(SqlWhereClause sqlObject, TArg input);
public virtual void Visited(SqlWhereClause whereClause)
{
}
/// <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 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 TResult Visit(SqlWhereClause sqlObject);
public override void Visit(SqlWhereClause sqlWhereClause)
{
this.writer.Write("WHERE ");
sqlWhereClause.FilterExpression.Accept(this);
}
public override SqlObject Visit(SqlWhereClause sqlWhereClause)
{
return(SqlWhereClause.Create(sqlWhereClause.FilterExpression.Accept(this) as SqlScalarExpression));
}
