/// <summary>
/// As traversers propagate through the traversal, it is possible to only allow a certain number of them
/// to pass through with range()-step (filter). When the low-end of the range is not met, objects are continued
/// to be iterated. When within the low (inclusive) and high (exclusive) range, traversers are emitted.
/// When above the high range, the traversal breaks out of iteration.
/// Finally, the use of -1 on the high range will emit remaining traversers after the low range begins
/// </summary>
/// <param name="builder"></param>
/// <param name="start"></param>
/// <param name="end"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="GremlinQueryBuilderException"></exception>
public static GremlinQueryBuilder Range(this GremlinQueryBuilder builder, IGremlinParameter start, IGremlinParameter end)
{
if (start == null)
{
throw new ArgumentNullException(nameof(start));
}
if (end == null)
{
throw new ArgumentNullException(nameof(end));
}
if (!start.IsNumber(true))
{
throw new GremlinQueryBuilderException(
$"{nameof(Range)} only supports numeric parameters and scope and '{start.TrueValue}' does not appear to conform to this");
}
if (!end.IsNumber(true))
{
throw new GremlinQueryBuilderException(
$"{nameof(Range)} only supports numeric parameters and scope and '{end.TrueValue}' does not appear to conform to this");
}
builder.AddArgument(start as GremlinArgument);
builder.AddArgument(end as GremlinArgument);
return(builder.Add($"range({start.QueryStringValue},{end.QueryStringValue})"));
}
/// <summary>
/// String predicate that tests incoming string to see if it does not end with specified argument string value
/// </summary>
/// <param name="builder"></param>
/// <param name="parameter"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static GremlinQueryBuilder NotEndingWith(this GremlinQueryBuilder builder, IGremlinParameter parameter)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (!(parameter.TrueValue is string))
{
throw new GremlinQueryBuilderException($"{nameof(NotEndingWith)} requires {nameof(parameter)} to " +
$"be a string and {parameter.TrueValue} does not appear to be");
}
builder.AddArgument(parameter as GremlinArgument);
return(builder.Add($"notEndingWith({parameter.QueryStringValue})"));
}
public static GremlinQueryBuilder Aggregate(this GremlinQueryBuilder builder, IGremlinParameter parameter)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
builder.AddArgument(parameter as GremlinArgument);
return(builder.Add($"aggregate({parameter.Value})"));
}
/// <summary>
/// The limit()-step is analogous to <seealso cref="RangeFunction.Range(CosmosDB.Gremlin.Fluent.GremlinQueryBuilder,CosmosDB.Gremlin.Fluent.IGremlinParameter,CosmosDB.Gremlin.Fluent.IGremlinParameter)"/> save that the lower end range is set to 0.
/// It can also be applied with local scope, in which case it operates on the incoming collection
/// </summary>
/// <param name="builder"></param>
/// <param name="scope"></param>
/// <param name="parameter"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="GremlinQueryBuilderException"></exception>
public static GremlinQueryBuilder Limit(this GremlinQueryBuilder builder, GremlinScope scope, IGremlinParameter parameter)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (!parameter.IsNumber(true))
{
throw new GremlinQueryBuilderException(
$"{nameof(Limit)} only supports numeric parameters and scope and " +
$"'{parameter.TrueValue}' does not appear to conform to this");
}
builder.AddArgument(parameter as GremlinArgument);
return(builder.Add($"limit({scope.QueryStringValue},{parameter.QueryStringValue})"));
}
/// <summary>
/// Special constructor for initialising builder from a single parameter.
/// Useful for complex chaining, e.g. has('price', between(10, 99)) etc.
/// </summary>
/// <param name="parameter">Gremlin parameter to initialise the builder with</param>
public GremlinQueryBuilder(IGremlinParameter parameter)
{
AddArgument(parameter as GremlinArgument);
Add(parameter.QueryStringValue);
}
/// <summary>
/// Predicate testing that the incoming string does not contain the provided string argument value
/// </summary>
/// <param name="builder"></param>
/// <param name="parameter"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static GremlinQueryBuilder NotContaining(this GremlinQueryBuilder builder, IGremlinParameter parameter)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (!(parameter.TrueValue is string))
{
throw new GremlinQueryBuilderException(
$"{nameof(NotContaining)} only accepts parameters that resolve to string and {parameter.TrueValue} does not appear to");
}
builder.AddArgument(parameter as GremlinArgument);
return(builder.Add($"notContaining({parameter.QueryStringValue})"));
}
/// <summary>
/// There are two general ways to use select()-step.
/// Select labeled steps within a path (as defined by as() in a traversal).
/// Select objects out of a Map<String,Object> flow (i.e. a sub-map).
/// When the set of keys or values (i.e. columns) of a path or map are needed, use select(keys)
/// and select(values), respectively. select() can also accept a traversal that emits a key
/// </summary>
/// <param name="builder"></param>
/// <param name="pop"></param>
/// <param name="label"></param>
/// <returns></returns>
public static GremlinQueryBuilder Select(this GremlinQueryBuilder builder, GremlinPopModifier pop, IGremlinParameter label)
{
if (pop == null)
{
throw new ArgumentNullException(nameof(pop));
}
if (label == null)
{
throw new ArgumentNullException(nameof(label));
}
if (!(label.TrueValue is string))
{
throw new GremlinQueryBuilderException($"{nameof(Select)} only allows strings in " +
$"{nameof(label)} parameter and {label.TrueValue} " +
$"does not appear to be");
}
builder.AddArgument(label as GremlinArgument);
return(builder.Add($"select({pop.QueryStringValue},{label.QueryStringValue})"));
}
/// <summary>
/// The sample()-step is useful for sampling some number of traversers previous in the traversal
/// </summary>
/// <param name="builder"></param>
/// <param name="scope"></param>
/// <param name="parameter"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="GremlinQueryBuilderException"></exception>
public static GremlinQueryBuilder Sample(this GremlinQueryBuilder builder, GremlinScope scope, IGremlinParameter parameter)
{
// this function can only take true or false
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (!(parameter.TrueValue is int || parameter.TrueValue is uint))
{
throw new GremlinQueryBuilderException(
$"{nameof(Sample)} only supports integer parameters and scope and '{parameter.TrueValue}' does not appear to conform to this");
}
builder.AddArgument(parameter as GremlinArgument);
return(builder.Add($"sample({scope.QueryStringValue},{parameter.QueryStringValue})"));
}
