public ResultRecord Read(IDataResults reader)
{
var records = reader.GetNextEnumerable <ResultRecord>().ToDictionary(r => r.Id);
reader.GetNextEnumerable <PartialRecordValue>().MapOnto(p => records[p.Id], (p, r) => r.Value = p.Value);
return(records.Values.Single());
}
/// <summary>
/// Return the raw result reader, wrapped to provide better error messages. Error messages
/// come with some performance penalty, so consider using this for situations where
/// performance is not a critical concern.
/// </summary>
/// <param name="results"></param>
/// <returns></returns>
public static IDataReader AsRawReaderWithBetterErrorMessages(this IDataResults results)
{
Argument.NotNull(results, nameof(results));
var reader = results.AsRawReader();
return(new DataReaderWithBetterErrorMessages(reader));
}
public ResultRecord Read(IDataResults reader)
{
return(reader
.AsEnumerable <ResultRecord>(b => b
.For <ResultRecord>(c => c.UseFactoryMethod(() => null))
)
.FirstOrDefault());
}
public TestObject Read(IDataResults result)
{
var obj1 = result.AsEnumerable <TestObject>().First();
var obj2 = result.GetNextEnumerable <TestObject>().First();
obj1.TestString = obj2.TestString;
return(obj1);
}
public IEnumerable <TestObjectTwoConstructors> Read(IDataResults result)
{
var constructor = typeof(TestObjectTwoConstructors).GetConstructor(new[] { typeof(int), typeof(string) });
return(result
.AsEnumerable <TestObjectTwoConstructors>(b => b
.For <TestObjectTwoConstructors>(c => c.UseConstructor(constructor))
)
.ToList());
}
public IReadOnlyList <TestNumber> Read(IDataResults result)
{
return(result
.AsEnumerable <TestNumber>(b => b
.For <TestNumber>(c => c
.UseType <TestSmallNumber>()
.UseSubtype <TestBigNumber>(r => r.GetInt32(0) > 3)
)
)
.ToList());
}
public Result Read(IDataResults result)
{
var results = result.AsEnumerable <string>();
var firstResult = results.First();
var paramValue = result.GetOutputParameter <string>("value");
return(new Result
{
OutputParameterValue = paramValue,
ResultSetValue = firstResult
});
}
public object[] Read(IDataResults result)
{
return(result.AsEnumerable <object[]>().FirstOrDefault());
}
public static bool AreAggregatesEqual(double?[][] aggregates, IDataResults results)
{
return(AreAggregatesEqual(aggregates, 0, results));
}
public static bool AreAggregatesEqual(double?[][] aggregates, int aggregateIndex, IDataResults results)
{
var flatRowGroups = results.Root.RowGroup.Flatten().ToList();
var flatColumnGroups = results.Root.ColumnGroup.Flatten().ToList();
for (int i = 0; i < flatRowGroups.Count(); i++)
{
for (int j = 0; j < flatColumnGroups.Count(); j++)
{
var expectedValue = aggregates[i][j];
var rowGroup = flatRowGroups[i];
var columnGroup = flatColumnGroups[j];
var aggregateValue = results.GetAggregateResult(aggregateIndex, rowGroup, columnGroup);
if (aggregateValue == null)
{
if (expectedValue != null)
{
return(false);
}
}
else
{
var actualValue = aggregateValue.GetValue();
if (!actualValue.Equals(expectedValue))
{
return(false);
}
}
}
}
return(true);
}
public QueryValues Read(IDataResults result)
{
return(result.AsEnumerable <QueryValues>().Single());
}
public string[] Read(IDataResults result)
{
return(result.AsEnumerable <string[]>().FirstOrDefault());
}
public T Read(IDataResults result)
{
result.CacheMappings(_cacheMappings);
return(_materializer.Read(result));
}
public TestObject1 Read(IDataResults result)
{
return(result.AsEnumerable <TestObject1>().FirstOrDefault());
}
public ParameterResult Read(IDataResults result)
{
return(result.GetOutputParameters <ParameterResult>());
}
public string Read(IDataResults result)
{
return(result.AsEnumerable <string>().First());
}
// We can't instruct the compiler to cache mappings here, because we don't know what the // query is. Different queries might have columns in different orders but use the same // materialization routine, which would be a different map. public T Read(IDataResults result) => _materialize(result);
public IReadOnlyList <TfIdfResult> Read(IDataResults result)
{
return(result.AsEnumerable <TfIdfResult>().ToList());
}
public string ReadOutputs(IDataResults result)
{
return(result.GetOutputParameter <string>("@param"));
}
public IReadOnlyList <JaccardMatch> Read(IDataResults result)
{
return(result.AsEnumerable <JaccardMatch>().ToList());
}
public string ReadOutputs(IDataResults result)
{
return(result.GetOutputParameterValue("@param").ToString());
}
public ProductGroup Read(IDataResults result)
{
var productGroup = result.AsEnumerable <ProductGroup>().Single();
return(productGroup);
}
public int ReadOutputs(IDataResults result)
{
return(result.RowsAffected);
}
public T Read(IDataResults result)
{
return(result.AsEnumerable <T>().FirstOrDefault());
}
public List <int> Read(IDataResults result)
{
return(result.AsEnumerable <int>().ToList());
}
