/// <summary> /// Executes this operation, sending the input of this operation /// to all its child operations /// </summary> /// <param name="rows">The rows.</param> /// <param name="cancellationToken">A CancellationToken to stop execution</param> /// <returns></returns> public override IAsyncEnumerable <Row> Execute(IAsyncEnumerable <Row> rows, CancellationToken cancellationToken = default) { return(new AsyncEnumerable <Row>(async yield => { var copiedRows = new CachingEnumerable <Row>(rows, cancellationToken); foreach (IOperation operation in Operations) { var cloned = copiedRows.Select(r => r.Clone()); IAsyncEnumerable <Row> enumerable = operation.Execute(cloned, cancellationToken); if (enumerable == null) { continue; } IAsyncEnumerator <Row> enumerator = enumerable.GetAsyncEnumerator(cancellationToken); #pragma warning disable 642 while (await enumerator.MoveNextAsync()) { ; } #pragma warning restore 642 } yield.Break(); })); }
/// <summary> /// Executes this operation, sending the input of this operation /// to all its child operations /// </summary> /// <param name="rows">The rows.</param> /// <returns></returns> public override IEnumerable <Row> Execute(IEnumerable <Row> rows) { var copiedRows = new CachingEnumerable <Row>(rows); foreach (var operation in Operations) { var cloned = copiedRows.Select(r => r.Clone()); var enumerable = operation.Execute(cloned); if (enumerable == null) { continue; } var enumerator = enumerable.GetEnumerator(); #pragma warning disable 642 while (enumerator.MoveNext()) { ; } #pragma warning restore 642 } yield break; }
/// <summary> /// Executes this operation /// </summary> /// <param name="rows">Rows in pipeline. These are only used if a left part of the join was not specified.</param> /// <returns></returns> public override IEnumerable <Row> Execute(IEnumerable <Row> rows) { PrepareForJoin(); Dictionary <Row, object> matchedRightRows = new Dictionary <Row, object>(); CachingEnumerable <Row> rightEnumerable = new CachingEnumerable <Row>( new EventRaisingEnumerator(right, right.Execute(null)) ); IEnumerable <Row> execute = left.Execute(leftRegistered ? null : rows); foreach (Row leftRow in new EventRaisingEnumerator(left, execute)) { bool leftNeedOuterJoin = true; currentLeftRow = leftRow; foreach (Row rightRow in rightEnumerable) { currentRightRow = rightRow; if (MatchJoinCondition(leftRow, rightRow)) { leftNeedOuterJoin = false; matchedRightRows[rightRow] = null; yield return(MergeRows(leftRow, rightRow)); } } if (leftNeedOuterJoin) { Row emptyRow = new Row(); emptyRow[IsEmptyRowMarker] = IsEmptyRowMarker; currentRightRow = emptyRow; if (MatchJoinCondition(leftRow, emptyRow)) { yield return(MergeRows(leftRow, emptyRow)); } else { LeftOrphanRow(leftRow); } } } foreach (Row rightRow in rightEnumerable) { if (matchedRightRows.ContainsKey(rightRow)) { continue; } currentRightRow = rightRow; Row emptyRow = new Row(); emptyRow[IsEmptyRowMarker] = IsEmptyRowMarker; currentLeftRow = emptyRow; if (MatchJoinCondition(emptyRow, rightRow)) { yield return(MergeRows(emptyRow, rightRow)); } else { RightOrphanRow(rightRow); } } }
/// <summary> /// Executes this operation /// </summary> /// <param name="ignored">Ignored rows</param> /// <returns></returns> public override IEnumerable<Row> Execute(IEnumerable<Row> ignored) { Initialize(); Guard.Against(left == null, "Left branch of a join cannot be null"); Guard.Against(right == null, "Right branch of a join cannot be null"); Dictionary<Row, object> matchedRightRows = new Dictionary<Row, object>(); CachingEnumerable<Row> rightEnumerable = new CachingEnumerable<Row>( new EventRaisingEnumerator(right, right.Execute(null)) ); IEnumerable<Row> execute = left.Execute(null); foreach (Row leftRow in new EventRaisingEnumerator(left, execute)) { bool leftNeedOuterJoin = true; currentLeftRow = leftRow; foreach (Row rightRow in rightEnumerable) { currentRightRow = rightRow; if (MatchJoinCondition(leftRow, rightRow)) { leftNeedOuterJoin = false; matchedRightRows[rightRow] = null; yield return MergeRows(leftRow, rightRow); } } if (leftNeedOuterJoin) { Row emptyRow = new Row(); emptyRow[IsEmptyRowMarker] = IsEmptyRowMarker; currentRightRow = emptyRow; if (MatchJoinCondition(leftRow, emptyRow)) yield return MergeRows(leftRow, emptyRow); else LeftOrphanRow(leftRow); } } foreach (Row rightRow in rightEnumerable) { if (matchedRightRows.ContainsKey(rightRow)) continue; currentRightRow = rightRow; Row emptyRow = new Row(); emptyRow[IsEmptyRowMarker] = IsEmptyRowMarker; currentLeftRow = emptyRow; if (MatchJoinCondition(emptyRow, rightRow)) yield return MergeRows(emptyRow, rightRow); else RightOrphanRow(rightRow); } }
/// <summary> /// Executes this operation /// </summary> /// <param name="rows">Rows in pipeline. These are only used if a left part of the join was not specified.</param> /// <returns></returns> public override IEnumerable<Row> Execute(IEnumerable<Row> rows) { PrepareForJoin(); Dictionary<Row, object> matchedRightRows = new Dictionary<Row, object>(); CachingEnumerable<Row> rightEnumerable = new CachingEnumerable<Row>( new EventRaisingEnumerator(right, right.Execute(null)) ); IEnumerable<Row> execute = left.Execute(leftRegistered ? null : rows); foreach (Row leftRow in new EventRaisingEnumerator(left, execute)) { bool leftNeedOuterJoin = true; currentLeftRow = leftRow; foreach (Row rightRow in rightEnumerable) { currentRightRow = rightRow; if (MatchJoinCondition(leftRow, rightRow)) { leftNeedOuterJoin = false; matchedRightRows[rightRow] = null; yield return MergeRows(leftRow, rightRow); } } if (leftNeedOuterJoin) { Row emptyRow = new Row(); emptyRow[IsEmptyRowMarker] = IsEmptyRowMarker; currentRightRow = emptyRow; if (MatchJoinCondition(leftRow, emptyRow)) yield return MergeRows(leftRow, emptyRow); else LeftOrphanRow(leftRow); } } foreach (Row rightRow in rightEnumerable) { if (matchedRightRows.ContainsKey(rightRow)) continue; currentRightRow = rightRow; Row emptyRow = new Row(); emptyRow[IsEmptyRowMarker] = IsEmptyRowMarker; currentLeftRow = emptyRow; if (MatchJoinCondition(emptyRow, rightRow)) yield return MergeRows(emptyRow, rightRow); else RightOrphanRow(rightRow); } }
private IEnumerable <FdoRow> GetRightEnumerable() { IEnumerable <FdoRow> rightEnumerable = new CachingEnumerable <FdoRow>( new EventRaisingEnumerator(right, right.Execute(null)) ); foreach (FdoRow row in rightEnumerable) { ObjectArrayKeys key = row.CreateKey(rightColumns); List <FdoRow> rowsForKey; if (this.rightRowsByJoinKey.TryGetValue(key, out rowsForKey) == false) { this.rightRowsByJoinKey[key] = rowsForKey = new List <FdoRow>(); } rowsForKey.Add(row); } return(rightEnumerable); }
/// <summary> /// Executes this operation, sending the input of this operation /// to all its child operations /// </summary> /// <param name="rows">The rows.</param> /// <returns></returns> public override IEnumerable<Row> Execute(IEnumerable<Row> rows) { var copiedRows = new CachingEnumerable<Row>(rows); foreach (var operation in Operations) { var cloned = copiedRows.Select(r => r.Clone()); var enumerable = operation.Execute(cloned); if (enumerable == null) continue; var enumerator = enumerable.GetEnumerator(); #pragma warning disable 642 while (enumerator.MoveNext()) ; #pragma warning restore 642 } yield break; }
private async Task <IAsyncEnumerable <Row> > GetRightEnumerable(CancellationToken cancellationToken = default) { IAsyncEnumerable <Row> rightEnumerable = new CachingEnumerable <Row>(new EventRaisingEnumerator(right, right.Execute(null, cancellationToken)), cancellationToken); await rightEnumerable.ForEachAsync(row => { ObjectArrayKeys key = row.CreateKey(rightColumns); List <Row> rowsForKey; if (this.rightRowsByJoinKey.TryGetValue(key, out rowsForKey) == false) { this.rightRowsByJoinKey[key] = rowsForKey = new List <Row>(); } rowsForKey.Add(row); }, cancellationToken); return(rightEnumerable); }
private IEnumerable<Row> GetRightEnumerable() { IEnumerable<Row> rightEnumerable = new CachingEnumerable<Row>( new EventRaisingEnumerator(right, right.Execute(null)) ); foreach (var row in rightEnumerable) { var key = row.CreateKey(rightColumns); List<Row> rowsForKey; if (rightRowsByJoinKey.TryGetValue(key, out rowsForKey) == false) { rightRowsByJoinKey[key] = rowsForKey = new List<Row>(); } rowsForKey.Add(row); } return rightEnumerable; }
/// <summary> /// Executes this operation /// </summary> /// <param name="ignored">Ignored rows</param> /// <returns></returns> public override IEnumerable <Row> Execute(IEnumerable <Row> ignored) { Initialize(); Guard.Against(left == null, "Left branch of a join cannot be null"); Guard.Against(right == null, "Right branch of a join cannot be null"); Dictionary <Row, object> matchedRightRows = new Dictionary <Row, object>(); CachingEnumerable <Row> rightEnumerable = new CachingEnumerable <Row>( new EventRaisingEnumerator(right, right.Execute(null)) ); IEnumerable <Row> execute = left.Execute(null); foreach (Row leftRow in new EventRaisingEnumerator(left, execute)) { bool leftNeedOuterJoin = true; currentLeftRow = leftRow; foreach (Row rightRow in rightEnumerable) { currentRightRow = rightRow; if (MatchJoinCondition(leftRow, rightRow)) { leftNeedOuterJoin = false; matchedRightRows[rightRow] = null; yield return(MergeRows(leftRow, rightRow)); } } if (leftNeedOuterJoin) { Row emptyRow = new Row(); emptyRow[IsEmptyRowMarker] = IsEmptyRowMarker; currentRightRow = emptyRow; if (MatchJoinCondition(leftRow, emptyRow)) { yield return(MergeRows(leftRow, emptyRow)); } else { LeftOrphanRow(leftRow); } } } foreach (Row rightRow in rightEnumerable) { if (matchedRightRows.ContainsKey(rightRow)) { continue; } currentRightRow = rightRow; Row emptyRow = new Row(); emptyRow[IsEmptyRowMarker] = IsEmptyRowMarker; currentLeftRow = emptyRow; if (MatchJoinCondition(emptyRow, rightRow)) { yield return(MergeRows(emptyRow, rightRow)); } else { RightOrphanRow(rightRow); } } }
/// <summary> /// Executes this operation /// </summary> /// <param name="rows">Rows in pipeline. These are only used if a left part of the join was not specified.</param> /// <param name="cancellationToken">A CancellationToken to stop execution</param> /// <returns></returns> public override IAsyncEnumerable <Row> Execute(IAsyncEnumerable <Row> rows, CancellationToken cancellationToken = default) { return(new AsyncEnumerable <Row>(async yield => { PrepareForJoin(); Dictionary <Row, object> matchedRightRows = new Dictionary <Row, object>(); CachingEnumerable <Row> rightEnumerable = new CachingEnumerable <Row>( new EventRaisingEnumerator(right, right.Execute(null, cancellationToken)), cancellationToken); IAsyncEnumerable <Row> execute = left.Execute(leftRegistered ? null : rows, cancellationToken); await new EventRaisingEnumerator(left, execute) .ForEachAsync(async leftRow => { bool leftNeedOuterJoin = true; currentLeftRow = leftRow; await rightEnumerable.ForEachAsync(async rightRow => { currentRightRow = rightRow; if (MatchJoinCondition(leftRow, rightRow)) { leftNeedOuterJoin = false; matchedRightRows[rightRow] = null; await yield .ReturnAsync(MergeRows(leftRow, rightRow)); } }, cancellationToken); if (leftNeedOuterJoin) { Row emptyRow = new Row(); emptyRow[IsEmptyRowMarker] = IsEmptyRowMarker; currentRightRow = emptyRow; if (MatchJoinCondition(leftRow, emptyRow)) { await yield.ReturnAsync(MergeRows(leftRow, emptyRow)); } else { LeftOrphanRow(leftRow); } } }, cancellationToken); await rightEnumerable.ForEachAsync(async rightRow => { if (matchedRightRows.ContainsKey(rightRow)) { return; } currentRightRow = rightRow; Row emptyRow = new Row(); emptyRow[IsEmptyRowMarker] = IsEmptyRowMarker; currentLeftRow = emptyRow; if (MatchJoinCondition(emptyRow, rightRow)) { await yield.ReturnAsync(MergeRows(emptyRow, rightRow)); } else { RightOrphanRow(rightRow); } }, cancellationToken); })); }