public void ExecuteInMemory () { IStreamedData input = new StreamedSequence (new[] { 1, 2, 3 }, new StreamedSequenceInfo (typeof (int[]), Expression.Constant (0))); var result = _resultOperator.ExecuteInMemory (input); Assert.That (result, Is.SameAs (input)); }
public void SetUp () { _stringExpression = Expression.Constant (0); _stringSequence = new[] { "a", "b", "c" }; _dataWithCovariantSequence = new StreamedSequence (_stringSequence, new StreamedSequenceInfo (typeof (object[]), _stringExpression)); }
public void ExecuteInMemory () { var input = new StreamedSequence (new[] { 1, 2, 3 }, new StreamedSequenceInfo (typeof (int[]), Expression.Constant (0))); var result = _resultOperator.ExecuteInMemory<int> (input); Assert.That (result.Value, Is.EqualTo (3)); }
public void ExecuteInMemory () { var items = new[] { 1, 2, 3 }; var input = new StreamedSequence (items, new StreamedSequenceInfo (typeof (int[]), Expression.Constant (0))); var result = _resultOperator.ExecuteInMemory<int> (input); Assert.That (result.GetTypedSequence<int>().ToArray(), Is.EquivalentTo (new[] { 1, 2, 3 })); }
public void ExecuteInMemory_WithDefaultValue () { IEnumerable items = new int[0]; var input = new StreamedSequence (items, new StreamedSequenceInfo (typeof (int[]), Expression.Constant (0))); var result = _resultOperatorWithDefaultValue.ExecuteInMemory<int> (input); Assert.That (result.GetTypedSequence<int>().ToArray(), Is.EqualTo (new[] { 100 })); }
public void ExecuteInMemory_Empty_Default () { IEnumerable items = new int[0]; var input = new StreamedSequence (items, new StreamedSequenceInfo (typeof (int[]), Expression.Constant (0))); var result = _resultOperatorWithDefault.ExecuteInMemory (input); Assert.That (result.Value, Is.EqualTo (0)); }
public void ExecuteInMemory () { IEnumerable items = new[] { 1, 2, 3, 4 }; var input = new StreamedSequence (items, new StreamedSequenceInfo (typeof (int[]), Expression.Constant (0))); var result = _resultOperator.ExecuteInMemory<int> (input); Assert.That (result.Value, Is.True); }
public void ExecuteInMemory () { var student1 = new Chef (); var student2 = new Chef (); IEnumerable items = new Cook[] { student1, student2 }; var itemExpression = Expression.Constant (student1, typeof (Cook)); var input = new StreamedSequence (items, new StreamedSequenceInfo (typeof (Cook[]), itemExpression)); var result = _resultOperator.ExecuteInMemory<Cook> (input); var sequence = result.GetTypedSequence<Chef>(); Assert.That (sequence.ToArray (), Is.EquivalentTo (new[] { student1, student2 })); Assert.That (result.DataInfo.ResultItemType, Is.EqualTo (typeof (Chef))); Assert.That (((UnaryExpression) result.DataInfo.ItemExpression).Operand, Is.SameAs (itemExpression)); }
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public override StreamedSequence ExecuteInMemory <T>(StreamedSequence input) => input;
public override StreamedSequence ExecuteInMemory <T>(StreamedSequence input) { return(input); // sequence is not changed by this operator }
public void ExecuteInMemory () { // group [i].ToString() by [j] % 3 // expected input: new AnonymousType ( a = [i], b = [j] ) var expectedInput = Expression.New ( typeof (AnonymousType).GetConstructor (new[] {typeof (int), typeof (int) }), new Expression[] { new QuerySourceReferenceExpression (_fromClause1), new QuerySourceReferenceExpression (_fromClause2) }, new MemberInfo[] { typeof (AnonymousType).GetProperty ("a"), typeof (AnonymousType).GetProperty ("b") }); var items = new[] { new AnonymousType (111, 1), new AnonymousType (222, 2), new AnonymousType (333, 3), new AnonymousType (444, 4), new AnonymousType (555, 5) }; var input = new StreamedSequence (items, new StreamedSequenceInfo (typeof (AnonymousType[]), expectedInput)); var result = _resultOperator.ExecuteInMemory<AnonymousType> (input); var sequence = result.GetTypedSequence<IGrouping<int, string>> (); var resultArray = sequence.ToArray (); Assert.That (resultArray.Length, Is.EqualTo (3)); Assert.That (resultArray[0].ToArray (), Is.EqualTo (new[] { "111", "444" })); Assert.That (resultArray[1].ToArray (), Is.EqualTo (new[] { "222", "555" })); Assert.That (resultArray[2].ToArray (), Is.EqualTo (new[] { "333" })); Assert.That (result.DataInfo.ItemExpression, Is.InstanceOf (typeof (QuerySourceReferenceExpression))); Assert.That (((QuerySourceReferenceExpression) result.DataInfo.ItemExpression).ReferencedQuerySource, Is.SameAs (_resultOperator)); }
public void SetUp() { _resultOperator = new TestResultOperator(); _executeInMemoryInput = new StreamedSequence(new[] { 1, 2, 3, 4, 3, 2, 1 }, new StreamedSequenceInfo(typeof(int[]), Expression.Constant(0))); }
public void ExecuteInMemory_UnsupportedType () { var input = new StreamedSequence (new[] { "1", "2", "3" }, new StreamedSequenceInfo (typeof (string[]), Expression.Constant ("0"))); _resultOperator.ExecuteInMemory<string> (input); }
public abstract StreamedSequence ExecuteInMemory <T> (StreamedSequence input);
public override StreamedSequence ExecuteInMemory <T>([NotNull] StreamedSequence input) { Check.NotNull(input, "input"); return(input); }
public override StreamedValue ExecuteInMemory <T>(StreamedSequence input) { throw new NotImplementedException("Cannot explain N1QL queries in memory"); }
public abstract AsyncStreamedValue ExecuteInMemory <T>(StreamedSequence sequence);
/// <summary> /// Run the operation in memory. /// WARNING: This is not supported, and will bomb. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="sequence"></param> /// <returns></returns> public override StreamedValue ExecuteInMemory <T>(StreamedSequence sequence) { throw new NotImplementedException("The result operator AsCSV can't be executed in memory currently."); }
public void ExecuteInMemory_TooManyItems () { IEnumerable items = new[] { 1, 2 }; var input = new StreamedSequence (items, new StreamedSequenceInfo (typeof (int[]), Expression.Constant (0))); _resultOperatorWithDefault.ExecuteInMemory (input); }
public override StreamedValue ExecuteInMemory <T> (StreamedSequence sequence) { return(new StreamedValue(sequence.GetTypedSequence <T> ().First(), GetOutputDataInfo(sequence.DataInfo))); }
public void SetUp () { _resultOperator = new TestResultOperator (); _executeInMemoryInput = new StreamedSequence (new[] { 1, 2, 3, 4, 3, 2, 1 }, new StreamedSequenceInfo (typeof (int[]), Expression.Constant (0))); }
/// <inheritdoc cref="ResultOperatorBase.ExecuteInMemory" /> public override StreamedValue ExecuteInMemory <TInput>(StreamedSequence input) { var closedExecuteMethod = s_executeMethod.MakeGenericMethod(typeof(TInput), Seed.Type, GetResultType()); return((StreamedValue)InvokeExecuteMethod(closedExecuteMethod, input)); }
public void ExecuteInMemory_Empty_NoDefault () { IEnumerable items = new int[0]; var input = new StreamedSequence (items, new StreamedSequenceInfo (typeof (int[]), Expression.Constant (0))); _resultOperatorNoDefault.ExecuteInMemory (input); }
public override StreamedSequence ExecuteInMemory <T> (StreamedSequence input) { var sequenceInfo = input.GetTypedSequence <T> (); return(new StreamedSequence(sequenceInfo.Distinct().AsQueryable(), (StreamedSequenceInfo)GetOutputDataInfo(input.DataInfo))); }
public void ExecuteInMemory_UnsupportedType() { var input = new StreamedSequence(new[] { "1", "2", "3" }, new StreamedSequenceInfo(typeof(string[]), Expression.Constant("0"))); _resultOperator.ExecuteInMemory <string> (input); }
public override StreamedValue ExecuteInMemory <T>(StreamedSequence sequence) { throw new NotSupportedException("UpdateAll is not supported for in-memory sequences."); }
public void ExecuteInMemory_WithoutResultSelector () { IEnumerable items = new[] { 1, 2, 3, 4 }; var input = new StreamedSequence (items, new StreamedSequenceInfo (typeof (int[]), _sourceExpression)); var result = _resultOperatorWithoutResultSelector.ExecuteInMemory<int> (input); Assert.That (result.Value, Is.EqualTo (22)); }
public override StreamedSequence ExecuteInMemory <T> (StreamedSequence input) { ArgumentUtility.CheckNotNull("input", input); return(input); }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> public override StreamedSequence ExecuteInMemory <T>(StreamedSequence input) { return(input); }
public override StreamedSequence ExecuteInMemory <TInput>(StreamedSequence input) { var closedExecuteMethod = s_executeMethod.MakeGenericMethod(typeof(TInput), KeySelector.Type, ElementSelector.Type); return((StreamedSequence)InvokeExecuteMethod(closedExecuteMethod, input)); }