/// <summary>
/// Take a Publisher and prepare to consume it on parallallism number of 'rails',
/// possibly ordered and round-robin fashion and use custom prefetch amount and queue
/// for dealing with the source Publisher's values.
/// </summary>
/// <typeparam name="T">The value type.</typeparam>
/// <param name="source">The source IFlux instance.</param>
/// <param name="parallelism">the number of parallel rails</param>
/// <param name="prefetch">the number of values to prefetch from the source</param>
/// <param name="ordered">if converted back to a IFlux, should the end result be ordered?</param>
/// <returns>the new IParallelPublisher instance</returns>
public static IParallelFlux <T> Parallel <T>(this IFlux <T> source, int parallelism, int prefetch, bool ordered = false)
{
if (ordered)
{
return(new ParallelOrderedFork <T>(source, parallelism, prefetch));
}
return(new ParallelUnorderedFork <T>(source, parallelism, prefetch));
}
internal PublisherOnBackpressureBuffer(IFlux <T> source, int capacityHint)
{
this.source = source;
this.capacityHint = capacityHint;
}
/// <summary>
/// 查询数据
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="flux">flux表达式</param>
/// <param name="org">组织</param>
/// <returns></returns>
public Task <TModel[]> QueryAsync <TModel>(IFlux flux, string?org = default) where TModel : new()
{
return(this.QueryAsync <TModel>(flux.ToString(), org));
}
/// <summary>
/// 保保留指定的查询列
/// </summary>
/// <param name="flux"></param>
/// <param name="columns"></param>
/// <returns></returns>
public static IFlux Keep(this IFlux flux, Columns columns)
{
return(flux.Pipe($"keep(columns: {columns})", SingleQuotesBehavior.NoReplace));
}
/// <summary>
/// 分组
/// </summary>
/// <param name="flux"></param>
/// <param name="columns"></param>
/// <param name="mode"></param>
/// <returns></returns>
public static IFlux Group(this IFlux flux, Columns columns, GroupMode mode = GroupMode.By)
{
return(flux.Pipe(@$ "group(columns: {columns}, mode: " "{mode.ToString().ToLower()}" ")", SingleQuotesBehavior.NoReplace));
}
/// <summary>
/// 时间范围
/// </summary>
/// <remarks>* start小于stop</remarks>
/// <param name="flux"></param>
/// <param name="start"></param>
/// <param name="stop"></param>
/// <returns></returns>
public static IFlux Range(this IFlux flux, string start, string stop)
{
return(flux.Pipe($"range(start: {start}, stop: {stop})", SingleQuotesBehavior.NoReplace));
}
/// <summary>
/// 将_field所有行的值转换为列
/// </summary>
/// <param name="flux"></param>
/// <returns></returns>
public static IFlux Pivot(this IFlux flux)
{
return(flux.Pivot(Columns.Time, Columns.Field));
}
/// <summary>
/// 取出不是null的第一条
/// </summary>
/// <param name="flux"></param>
/// <returns></returns>
public static IFlux First(this IFlux flux)
{
return(flux.Pipe($"first()", SingleQuotesBehavior.NoReplace));
}
/// <summary>
/// 排序
/// </summary>
/// <param name="flux"></param>
/// <param name="desc"></param>
/// <returns></returns>
public static IFlux Sort(this IFlux flux, bool desc = false)
{
return(flux.Sort(Columns.Value, desc));
}
/// <summary>
/// 合并两个查询
/// </summary>
/// <param name="flux"></param>
/// <returns></returns>
public static IFlux Union(this IFlux flux, IFlux other)
{
return(Flux.Parse($"union(tables:[{flux}, {other}])"));
}
/// <summary>
/// ake a Publisher and prepare to consume it on parallallism number of 'rails',
/// possibly ordered and round-robin fashion.
/// </summary>
/// <typeparam name="T">The value type.</typeparam>
/// <param name="source">The source IFlux instance.</param>
/// <param name="parallelism">the number of parallel rails</param>
/// <param name="ordered">if converted back to a IFlux, should the end result be ordered?</param>
/// <returns>the new IParallelPublisher instance</returns>
public static IParallelFlux <T> Parallel <T>(this IFlux <T> source, int parallelism, bool ordered = false)
{
return(Parallel(source, parallelism, Flux.BufferSize, ordered));
}
/// <summary>
/// Take a Publisher and prepare to consume it on multiple 'rails' (number
/// of CPUs) in a round-robin fashion.
/// </summary>
/// <typeparam name="T">The value type.</typeparam>
/// <param name="source">The source IFlux instance.</param>
/// <param name="ordered">if converted back to a IFlux, should the end result be ordered?</param>
/// <returns>the new IParallelPublisher instance</returns>
public static IParallelFlux <T> Parallel <T>(this IFlux <T> source, bool ordered = false)
{
return(Parallel(source, Environment.ProcessorCount, ordered));
}
/// <summary>
/// 使用指定值填写column为null值
/// </summary>
/// <param name="flux"></param>
/// <param name="value"></param>
/// <param name="column"></param>
/// <returns></returns>
public static IFlux Fill(this IFlux flux, object value, string column = Column.Value)
{
return(value is string
?flux.Pipe($"fill(column: '{column}', value: '{value}')")
: flux.Pipe($"fill(column: '{column}', value: {value})"));
}
/// <summary>
/// 前n条
/// </summary>
/// <param name="flux"></param>
/// <param name="n"></param>
/// <returns></returns>
public static IFlux Top(this IFlux flux, int n)
{
return(flux.Top(n, Columns.Value));
}
/// <summary>
/// 排序
/// </summary>
/// <param name="flux"></param>
/// <param name="columns"></param>
/// <param name="desc"></param>
/// <returns></returns>
public static IFlux Sort(this IFlux flux, Columns columns, bool desc = false)
{
return(flux.Pipe($"sort(columns:{columns}, desc:{desc.ToString().ToLower()})", SingleQuotesBehavior.NoReplace));
}
/// <summary>
/// 前n条
/// </summary>
/// <param name="flux"></param>
/// <param name="n"></param>
/// <param name="columns">排序列</param>
/// <returns></returns>
public static IFlux Top(this IFlux flux, int n, Columns columns)
{
return(flux.Pipe($"top(n: {n}, columns: {columns})", SingleQuotesBehavior.NoReplace));
}
/// <summary>
/// 选择时间小时范围
/// </summary>
/// <param name="flux"></param>
/// <param name="start"></param>
/// <param name="stop"></param>
/// <param name="timeColumn"></param>
/// <returns></returns>
public static IFlux HourSelection(this IFlux flux, int start, int stop, string timeColumn = Column.Time)
{
return(flux.Pipe($"hourSelection(start: {start}, stop: {stop}, timeColumn: '{timeColumn}')"));
}
/// <summary>
/// 最小
/// </summary>
/// <param name="flux"></param>
/// <param name="column"></param>
/// <returns></returns>
public static IFlux Min(this IFlux flux, string column = Column.Value)
{
return(flux.Pipe($"min(column: '{column}')"));
}
/// <summary>
/// 总条数
/// </summary>
/// <param name="flux"></param>
/// <param name="column"></param>
/// <returns></returns>
public static IFlux Count(this IFlux flux, string column = Column.Value)
{
return(flux.Pipe($"count(column: '{column}')"));
}
/// <summary>
/// 行转列
/// </summary>
/// <param name="flux"></param>
/// <param name="rawKey"></param>
/// <param name="columnKey"></param>
/// <param name="valueColumn"></param>
/// <returns></returns>
public static IFlux Pivot(this IFlux flux, Columns rawKey, Columns columnKey, string valueColumn = Column.Value)
{
return(flux.Pipe(@$ "pivot(rowKey: {rawKey}, columnKey: {columnKey}, valueColumn: " "{valueColumn}" ")", SingleQuotesBehavior.NoReplace));
}
/// <summary>
/// limit
/// </summary>
/// <param name="flux"></param>
/// <returns></returns>
public static IFlux Limit(this IFlux flux, int n, int offset = 0)
{
return(flux.Pipe($"limit(n: {n}, offset: {offset})", SingleQuotesBehavior.NoReplace));
}
/// <summary>
/// 时间范围
/// </summary>
/// <remarks>* start小于stop</remarks>
/// <param name="flux"></param>
/// <param name="start"></param>
/// <param name="stop"></param>
/// <returns></returns>
public static IFlux Range(this IFlux flux, DateTimeOffset start, DateTimeOffset stop)
{
return(flux.Pipe($"range(start: {start:O}, stop: {stop:O})", SingleQuotesBehavior.NoReplace));
}
/// <summary>
/// 唯一值
/// </summary>
/// <param name="flux"></param>
/// <param name="column"></param>
/// <returns></returns>
public static IFlux Unique(this IFlux flux, string column = Column.Value)
{
return(flux.Pipe($"unique(column: '{column}')"));
}
/// <summary>
/// 复制列为新的列
/// </summary>
/// <param name="flux"></param>
/// <param name="column"></param>
/// <param name="aliasAs"></param>
/// <returns></returns>
public static IFlux Duplicate(this IFlux flux, string column, string aliasAs)
{
return(flux.Pipe($"duplicate(column: '{column}', as: '{aliasAs}')"));
}
/// <summary>
/// 消除重复
/// </summary>
/// <param name="flux"></param>
/// <param name="column">Column on which to track unique values</param>
/// <returns></returns>
public static IFlux Distinct(this IFlux flux, string column = Column.Value)
{
return(flux.Pipe($"distinct(column: '{column}')"));
}
/// <summary>
/// 时间区间聚合
/// </summary>
/// <param name="flux"></param>
/// <param name="every">时间区间 1h等</param>
/// <param name="fn">聚合函数</param>
/// <param name="column">要聚合的列</param>
/// <param name="timeSrc"></param>
/// <param name="timeDst"></param>
/// <param name="createEmpty"></param>
/// <returns></returns>
public static IFlux AggregateWindow(this IFlux flux, string every, string fn, string column = Column.Value, string timeSrc = Column.Stop, string timeDst = Column.Time, bool createEmpty = true)
{
return(flux.Pipe($"aggregateWindow(every: {every}, fn: {fn}, column: '{column}', timeSrc: '{timeSrc}', timeDst: '{timeDst}', createEmpty: {createEmpty.ToString().ToLower()})"));
}
/// <summary>
/// 保留最后n条
/// </summary>
/// <param name="flux"></param>
/// <param name="n"></param>
/// <returns></returns>
public static IFlux Bottom(this IFlux flux, int n)
{
return(flux.Bottom(n, Columns.Value));
}
/// <summary>
/// 查询
/// </summary>
/// <param name="flux"></param>
/// <param name="org"></param>
/// <returns></returns>
public Task <IDataTableCollection> QueryAsync(IFlux flux, string?org = null)
{
return(this.QueryAsync(flux.ToString(), org));
}
/// <summary>
/// 过滤结果
/// </summary>
/// <param name="flux"></param>
/// <param name="fnBody">过滤函数的body</param>
/// <param name="behavior"></param>
/// <returns></returns>
public static IFlux Filter(this IFlux flux, FnBody fnBody, SingleQuotesBehavior behavior = SingleQuotesBehavior.Replace)
{
return(flux.Pipe($"filter(fn: ({fnBody.ParamName}) => {fnBody})", behavior));
}
