[
https://issues.apache.org/jira/browse/TINKERPOP-1312?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15301361#comment-15301361
]
ASF GitHub Bot commented on TINKERPOP-1312:
-------------------------------------------
Github user okram commented on the pull request:
https://github.com/apache/incubator-tinkerpop/pull/320#issuecomment-221764771
Can you add some more complex tests? For instance:
```
out().count().is(0).as("a")
```
Also, `RangeByIsCountStrategy` doesn't have `applyPrior()` of
`AdjacentToIncidentStrategy`. Does that matter? That is:
```
out().count().is(0) ->
outE().count().is(0) ->
not(outE())
```
We want `not(outE())` NOT `not(out())`. Can you verify that such
compilations happen?
Also, why do you make a distinction between computer and standard engines
for this strategy?
I think you should copy that pattern in the other strategy tests that
ensure proper `__()` compilations. We can go crazy on adding patterns to make
sure compilations are as expected. E.g.:
```
@Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> generateTestParameters() {
return Arrays.asList(new Traversal[][]{
{__.outE().count(), __.outE().count()},
{__.bothE("knows").count(), __.bothE("knows").count()},
{__.properties().count(), __.properties().count()},
{__.properties("name").count(),
__.properties("name").count()},
{__.out().count(), __.outE().count()},
{__.in().count(), __.inE().count()},
{__.both().count(), __.bothE().count()},
{__.out("knows").count(), __.outE("knows").count()},
{__.out("knows", "likes").count(), __.outE("knows",
"likes").count()},
{__.filter(__.out()), __.filter(__.outE())},
{__.where(__.not(__.out())), __.where(__.not(__.outE()))},
{__.where(__.out("knows")), __.where(__.outE("knows"))},
{__.values().count(), __.properties().count()},
{__.values("name").count(), __.properties("name").count()},
{__.where(__.values()), __.where(__.properties())},
{__.and(__.out(), __.in()), __.and(__.outE(), __.inE())},
{__.or(__.out(), __.in()), __.or(__.outE(), __.inE())},
{__.out().as("a").count(), __.outE().count()}, // TODO:
is this good?
{__.where(__.as("a").out("knows").as("b")),
__.where(__.as("a").out("knows").as("b"))}});
}
```
> .count().is(0) is not properly optimized
> ----------------------------------------
>
> Key: TINKERPOP-1312
> URL: https://issues.apache.org/jira/browse/TINKERPOP-1312
> Project: TinkerPop
> Issue Type: Improvement
> Affects Versions: 3.2.0-incubating, 3.1.2-incubating
> Reporter: Daniel Kuppitz
> Assignee: Daniel Kuppitz
> Fix For: 3.1.3, 3.2.1
>
>
> {{bla.count().is(0)}} gets optimized by {{RangeByIsCountStrategy}}, which
> replaces it with {{bla.limit(1).count().is(0)}}. That's good, but we can do
> even better by replacing it with {{__.not(bla)}}, which is a simple
> {{.hasNext()}} instead of a {{RangeStep}} followed by a
> {{ReducingBarrierStep}} ({{count()}}).
> Question is: should we do the replacement in {{RangeByIsCountStrategy}}? The
> strategy will recognize the pattern, no matter if we use it for the
> replacement or not; it's just that the strategy name is then no longer in
> line with the the actual replacement (for this particular {{.count().is(0)}}
> case) as it won't inject a {{RangeStep}}.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
