[ 
https://issues.apache.org/jira/browse/GROOVY-12724?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=18143933#comment-18143933
 ] 

ASF GitHub Bot commented on GROOVY-12724:
-----------------------------------------

blackdrag commented on code in PR #3259:
URL: https://github.com/apache/groovy/pull/3259#discussion_r4545640842


##########
subprojects/groovy-ginq/src/main/groovy/org/apache/groovy/ginq/provider/collection/runtime/QueryableCollection.java:
##########
@@ -684,12 +690,128 @@ public long size() {
     }
 
     /**
-     * Returns a reusable stream over the current elements.
+     * Returns a new stream over the current elements. Creating the stream 
does not
+     * pull. An iterable source is read again by every stream. A one-shot 
stream is
+     * pulled into a buffer as it is consumed, and a later call replays that 
buffer
+     * instead of returning the stream that was already handed out.
      *
-     * @return the element stream
+     * @return a stream that has not been consumed
      */
     @Override
     public Stream<T> stream() {
+        writeLock.lock();
+        try {
+            if (sourceIterable != null) {
+                Stream<T> fresh = toStream(sourceIterable);
+                if (!fresh.isParallel() && isParallel()) {
+                    fresh = fresh.parallel();
+                }
+                return fresh;
+            }
+            bindUpstream();
+            return StreamSupport.stream(ReplaySpliterator::new, 
upstreamCharacteristics, false);
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    /**
+     * Binds the one-shot source. The size is recorded before any element is 
pulled,
+     * so a later {@code count} can use it without running projections.
+     */
+    private void bindUpstream() {
+        if (upstreamBound) {
+            return;
+        }
+        upstreamBound = true;
+        upstream = openStream().spliterator();
+        long exact = upstream.getExactSizeIfKnown();
+        upstreamExactSize = exact;
+        upstreamCharacteristics = Spliterator.ORDERED;
+        if (exact >= 0) {
+            upstreamCharacteristics |= Spliterator.SIZED | 
Spliterator.SUBSIZED;
+        }
+    }
+
+    /**
+     * One cursor over a one-shot source. Elements are appended to {@link 
#replay}
+     * as they are pulled, so another stream can read them from the start.
+     * A sized source reports that size, and {@code Stream.count} then does 
not pull.
+     */
+    private final class ReplaySpliterator implements Spliterator<T> {
+        private int cursor;
+
+        @Override
+        public boolean tryAdvance(Consumer<? super T> action) {
+            writeLock.lock();

Review Comment:
   that will potentially mean a lot of lock calls





> GINQ: support static compilation and a fluent query API
> -------------------------------------------------------
>
>                 Key: GROOVY-12724
>                 URL: https://issues.apache.org/jira/browse/GROOVY-12724
>             Project: Groovy
>          Issue Type: Improvement
>          Components: GINQ
>            Reporter: Daniel Sun
>            Assignee: Daniel Sun
>            Priority: Major
>
> Under @CompileStatic / @TypeChecked, GQ, GQL, and @GQ currently rely on 
> dynamic lowering. This improvement makes those entry points usable from a 
> statically checked scope while keeping the SQL-like syntax lowered to the 
> in-memory collection runtime.
> h3. Goals
> * Allow GQ / GQL / @GQ from @CompileStatic and @TypeChecked without forcing 
> the lowered tree through static checking at the expression site.
> * Defer pipeline construction with LazyQueryable until a terminal read 
> (toList, count, etc.), copying locals at the expression site (same binding as 
> dynamic GQ).
> * Add Ginq.from(...) as a deferred, generic fluent chain on the same runtime, 
> with @ClosureParams so where/select/join/aggregate closures can infer element 
> types where inference is sound.
> * Preserve default lazy/deferred evaluation and dynamic GQ behavior for map 
> rows and other intentionally dynamic cases.
> h3. Non-goals / known limits
> * Stored untyped Closure variables still need a SAM target type for parameter 
> inference (same as Java/C#).
> * Raw Query parameters/fields cannot recover a safe element type.
> * Names bound by from inside GQ / GQL / @GQ stay dynamic by design; callers 
> that need checked element types use Ginq.from.
> h3. Related work
> GitHub PR: https://github.com/apache/groovy/pull/3259
> Stacked on GEP-26 SQL window work (PR #3167 / gep26-sql-window).



--
This message was sent by Atlassian Jira
(v10.3.26#10030026)

Reply via email to