/// <summary>
/// When more than one provider is available, uses command prompt for
/// user to choose which provider should be used for a test.
/// </summary>
/// <param name="providers">List of IRecordProvider instances</param>
/// <returns>Selected IRecordProvider</returns>
public static IRecordProvider SelectProvider(List <IRecordProvider> providers)
{
IRecordProvider selectedProvider = null;
if (providers.Count != 1)
{
if (providers.Count == 0)
{
Console.WriteLine("There are no record providers identified");
}
else
{
Console.WriteLine("There are {0} providers, please choose one: ", providers.Count);
foreach (IRecordProvider provider in providers)
{
Console.WriteLine("{0} - {1}", providers.IndexOf(provider), provider.GetType().FullName);
}
Console.Write("Selection : ");
String selection = Console.ReadLine();
int sel = int.Parse(selection);
selectedProvider = providers[sel];
}
}
else
{
selectedProvider = providers.First();
}
return(selectedProvider);
}
public ThreadRecordSupplier(ThroughputConfiguration configuration,
IRecordProvider context,
OnStatusUpdate onStatus = null)
{
this.Configuration = configuration;
this.Provider = context;
this.OnStatus = onStatus;
PopulateRecordList();
}
public CountRecordProvider(string groupBy, string aggregatedField, IRecordProvider provider)
: base(groupBy, aggregatedField, provider)
{
MetaData.ColumnDescriptors[$"count_of_{aggregatedField}"] = new ColumnData
{
Width = sizeof (int),
Offset = provider.MetaData.ColumnDescriptors[groupBy].Width,
Type = ColumnType.Int
};
}
public UngroupedAverageProvider(string field, IRecordProvider provider) : base(provider)
{
this.field = field;
if (!provider.MetaData.ColumnDescriptors.ContainsKey(field))
{
throw new MalformedQueryException($"Could not find field named {field}");
}
MetaData = new RecordMetaData();
MetaData.AddField($"avg_of_{field}", ColumnType.Float);
}
public ComputedFieldProvider(string fieldName, ColumnType type,
Func<RecordMetaData, byte[], dynamic> computation, IRecordProvider provider) : base(provider)
{
this.fieldName = fieldName;
this.type = type;
this.computation = computation;
MetaData = new RecordMetaData();
foreach (var columnDescriptor in provider.MetaData.ColumnDescriptors)
{
MetaData.ColumnDescriptors.Add(columnDescriptor.Key, columnDescriptor.Value);
}
MetaData.AddField(fieldName, type);
}
public JobManager(
IRecordProvider recordProvider,
ThroughputConfiguration context,
OnRecordCompleted jobComplete,
OnStatusUpdate update,
OnAllJobsCompleted allCompleted)
: this()
{
this.RecordProvider = recordProvider;
this.Context = context;
this.RecordCompleted += jobComplete;
this.StatusUpdate += update;
this.AllThreadsCompleted += allCompleted;
}
public JoinRecordProvider(IRecordProvider leftProvider, IRecordProvider rightProvider, string leftField,
string rightField)
{
this.leftProvider = leftProvider;
this.rightProvider = rightProvider;
this.leftField = leftField;
this.rightField = rightField;
if (!leftProvider.MetaData.ColumnDescriptors.ContainsKey(leftField))
{
throw new MalformedQueryException($"No field named {leftField} found.");
}
if (!rightProvider.MetaData.ColumnDescriptors.ContainsKey(rightField))
{
throw new MalformedQueryException($"No field named {rightField} found.");
}
var leftDescriptor = leftProvider.MetaData.ColumnDescriptors[leftField];
var rightDescriptor = rightProvider.MetaData.ColumnDescriptors[rightField];
if (leftDescriptor.Type !=
rightDescriptor.Type)
{
throw new MalformedQueryException($"Field types {leftDescriptor.Type} and {rightDescriptor.Type} dont't match.");
}
var allKeys =
leftProvider.MetaData.ColumnDescriptors.Keys.Union(rightProvider.MetaData.ColumnDescriptors.Keys);
MetaData = new RecordMetaData();
foreach (var key in allKeys)
{
if (leftProvider.MetaData.ColumnDescriptors.Keys.Contains(key))
{
MetaData.AddField(
key,
leftProvider.MetaData.ColumnDescriptors[key].Type,
leftProvider.MetaData.ColumnDescriptors[key].Width
);
}
else
{
MetaData.AddField(
key,
rightProvider.MetaData.ColumnDescriptors[key].Type,
rightProvider.MetaData.ColumnDescriptors[key].Width
);
}
}
}
public SelectionRecordProvider(IEnumerable<string> fields, IRecordProvider provider) : base(provider)
{
this.fields = fields;
MetaData = new RecordMetaData();
foreach (string field in fields)
{
try
{
var underlyingColumn = provider.MetaData.ColumnDescriptors[field];
MetaData.AddField(field, underlyingColumn.Type, underlyingColumn.Width);
}
catch (Exception e)
{
throw new MalformedQueryException($"No field named {field} found.");
}
}
}
protected AggregateRecordProvider(string groupBy, string aggregatedField, IRecordProvider provider)
: base(provider)
{
this.groupBy = groupBy;
this.aggregatedField = aggregatedField;
if (!provider.MetaData.ColumnDescriptors.ContainsKey(groupBy))
{
throw new MalformedQueryException($"Aggregated table does not contain a field '{groupBy}'");
}
if (!provider.MetaData.ColumnDescriptors.ContainsKey(aggregatedField))
{
throw new MalformedQueryException($"Aggregated table does not contain a field '{aggregatedField}'");
}
MetaData = new RecordMetaData();
MetaData.AddField(groupBy, ColumnType.String, provider.MetaData.ColumnDescriptors[groupBy].Width);
if (provider.MetaData.ColumnDescriptors.Count > 2)
{
this.provider = new SelectionRecordProvider(new List<string> {groupBy, aggregatedField}, provider);
}
}
public RecordParser(IRecordProvider provider)
{
this.provider = provider;
}
public WhereRecordProvider(IRecordProvider provider, IEnumerable<IWhereQueryConstraint> constraints)
: base(provider)
{
this.constraints = constraints.ToList();
}
public SumRecordProvider(string groupBy, string aggregatedField, IRecordProvider provider)
: base(groupBy, aggregatedField, provider)
{
MetaData.AddField(aggregatedField, provider.MetaData.ColumnDescriptors[aggregatedField].Type);
}
public RecordProviderBase(IRecordProvider provider)
{
this.provider = provider;
}
public ConsoleApplication(IRecordProvider recordProvider)
{
_recordProvider = recordProvider;
}
public RecordsController(IRecordProvider recordProvider, ILogger logger)
{
_recordProvider = recordProvider;
_logger = logger;
}
public Tracker(IFlowTable <TFlowKey, TFlowRecord> table, IKeyProvider <TFlowKey, TPacket> keyProvider, IRecordProvider <TPacket, TFlowRecord> recordProvider)
{
m_flowTable = table;
m_keyProvider = keyProvider;
m_recordProvider = recordProvider;
}
public SearchController(ILogger logger, IRecordProvider recordProvider)
{
_logger = logger;
_recordProvider = recordProvider;
}
public LimitRecordProvider(int limit, IRecordProvider provider) : base(provider)
{
this.limit = limit;
}
