/// <summary>
/// Add a filter for the given field path.
/// </summary>
/// <remarks>
/// This call adds additional filters to any previously-specified ones.
/// </remarks>
/// <param name="fieldPath">The field path to filter on. Must not be null.</param>
/// <param name="op">The filter operator.</param>
/// <param name="value">The value to compare in the filter.</param>
/// <returns>A new query based on the current one, but with the additional specified filter applied.</returns>
public Query Where(FieldPath fieldPath, QueryOperator op, object value)
{
FieldOp queryOp = GetOperator(op);
var unaryOperator = GetUnaryOperator(value);
Filter filter;
if (unaryOperator != UnaryFilter.Types.Operator.Unspecified)
{
if (queryOp == FieldOp.Equal)
{
filter = new Filter {
UnaryFilter = new UnaryFilter {
Field = fieldPath.ToFieldReference(), Op = unaryOperator
}
};
}
else
{
throw new ArgumentException(nameof(value), "null and NaN values can only be used with the Equal operator");
}
}
else
{
var convertedValue = ValueSerializer.Serialize(value);
filter = new Filter {
FieldFilter = new FieldFilter {
Field = fieldPath.ToFieldReference(), Op = queryOp, Value = convertedValue
}
};
}
return(WithFilter(filter));
}
internal static InternalFilter Create(FieldPath fieldPath, FieldOp op, object value)
{
GaxPreconditions.CheckNotNull(fieldPath, nameof(fieldPath));
var unaryOperator = GetUnaryOperator(value);
if (unaryOperator != UnaryOp.Unspecified)
{
if (op == FieldOp.Equal)
{
return(new InternalFilter(fieldPath, (int)unaryOperator, null));
}
else
{
throw new ArgumentException(nameof(value), "null and NaN values can only be used with the Equal operator");
}
}
else
{
var convertedValue = ValueSerializer.Serialize(value);
if (SentinelValue.GetKind(convertedValue) != SentinelValue.SentinelKind.None)
{
throw new ArgumentException(nameof(value), "Sentinel values cannot be specified in filters");
}
return(new InternalFilter(fieldPath, (int)op, convertedValue));
}
}
internal static InternalFilter Create(FieldPath fieldPath, QueryOperator op, object value)
{
GaxPreconditions.CheckNotNull(fieldPath, nameof(fieldPath));
FieldOp queryOp = GetOperator(op);
var unaryOperator = GetUnaryOperator(value);
if (unaryOperator != UnaryOp.Unspecified)
{
if (queryOp == FieldOp.Equal)
{
return(new InternalFilter(fieldPath, (int)unaryOperator, null));
}
else
{
throw new ArgumentException(nameof(value), "null and NaN values can only be used with the Equal operator");
}
}
else
{
var convertedValue = ValueSerializer.Serialize(value);
if (convertedValue.IsDeleteSentinel() || convertedValue.IsServerTimestampSentinel())
{
throw new ArgumentException(nameof(value), "Sentinel values cannot be specified in filters");
}
return(new InternalFilter(fieldPath, (int)queryOp, convertedValue));
}
}
/// <summary>
/// Add a filter for the given field path.
/// </summary>
/// <remarks>
/// This call adds additional filters to any previously-specified ones.
/// </remarks>
/// <param name="fieldPath">The field path to filter on. Must not be null.</param>
/// <param name="op">The filter operator.</param>
/// <param name="value">The value to compare in the filter. Must not be a sentinel value.</param>
/// <returns>A new query based on the current one, but with the additional specified filter applied.</returns>
private Query Where(FieldPath fieldPath, FieldOp op, object value)
{
InternalFilter filter = InternalFilter.Create(fieldPath, op, value);
var newFilters = _filters == null ? new List <InternalFilter>() : new List <InternalFilter>(_filters);
newFilters.Add(filter);
return(new Query(Collection, _offset, _limit, _orderings, newFilters, _projections, _startAt, _endAt));
}
// Note: the two general Where methods were originally public, accepting a public QueryOperator enum.
// If we ever want to make them public again, we should reinstate the QueryOperator enum to avoid an API
// dependency on the proto enum.
/// <summary>
/// Add a filter for the given field path.
/// </summary>
/// <remarks>
/// This call adds additional filters to any previously-specified ones.
/// </remarks>
/// <param name="fieldPath">The dot-separated field path to filter on. Must not be null or empty.</param>
/// <param name="op">The filter operator. Must not be null.</param>
/// <param name="value">The value to compare in the filter.</param>
/// <returns>A new query based on the current one, but with the additional specified filter applied.</returns>
private Query Where(string fieldPath, FieldOp op, object value)
{
GaxPreconditions.CheckNotNullOrEmpty(fieldPath, nameof(fieldPath));
return(Where(FieldPath.FromDotSeparatedString(fieldPath), op, value));
}
