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()); }