/// <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})")); }