[jira] [Updated] (SOLR-14481) Add drill Streaming Expression for efficient and accurate high cardinality aggregation
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Summary: Add drill Streaming Expression for efficient and accurate high
cardinality aggregation (was: Add drill Streaming Expression)
> Add drill Streaming Expression for efficient and accurate high cardinality
> aggregation
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
> Fix For: 8.6
>
> Attachments: SOLR-14481.patch, SOLR-14481.patch
>
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler on one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: The Streaming Expression sent to the /export handler to be executed.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl="a,b,c",
> sort="a desc, b desc",
> rollup(input(), over="a,b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Fix Version/s: 8.6
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
> Fix For: 8.6
>
> Attachments: SOLR-14481.patch, SOLR-14481.patch
>
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler on one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: The Streaming Expression sent to the /export handler to be executed.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl="a,b,c",
> sort="a desc, b desc",
> rollup(input(), over="a,b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Attachment: SOLR-14481.patch
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
> Attachments: SOLR-14481.patch, SOLR-14481.patch
>
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler on one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: The Streaming Expression sent to the /export handler to be executed.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl="a,b,c",
> sort="a desc, b desc",
> rollup(input(), over="a,b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler on one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: The Streaming Expression sent to the /export handler to be executed.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc", rollup(input(),
over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler on one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* bit: The "drill bit" is the Streaming Expression sent to the /export handler
to be executed.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
> Attachments: SOLR-14481.patch
>
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler on one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: The Streaming Expression sent to the /export handler to be executed.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl="a,b,c",
> sort="a desc, b desc",
> rollup(input(), over="a,b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Attachment: SOLR-14481.patch
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
> Attachments: SOLR-14481.patch
>
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler on one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * bit: The "drill bit" is the Streaming Expression sent to the /export
> handler to be executed.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> bit=rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl="a,b,c",
> sort="a desc, b desc",
> bit=rollup(input(), over="a,b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler on one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* bit: The "drill bit" is the Streaming Expression sent to export handler to
be executed.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* bit: The "drill bit" is the Streaming Expression sent to export handler to
be executed.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler on one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * bit: The "drill bit" is the Streaming Expression sent to export handler to
> be executed.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> bit=rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl="a,b,c",
> sort="a desc, b desc",
> bit=rollup(input(), over="a,b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler on one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* bit: The "drill bit" is the Streaming Expression sent to the /export handler
to be executed.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler on one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* bit: The "drill bit" is the Streaming Expression sent to export handler to
be executed.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler on one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * bit: The "drill bit" is the Streaming Expression sent to the /export
> handler to be executed.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> bit=rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl="a,b,c",
> sort="a desc, b desc",
> bit=rollup(input(), over="a,b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* bit: The "drill bit" is the Streaming Expression sent to export handler to
be executed.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler in one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * bit: The "drill bit" is the Streaming Expression sent to export handler to
> be executed.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> bit=rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl="a,b,c",
> sort="a desc, b desc",
> bit=rollup(input(), over="a,b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
bit=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set before the tuples hit the
network. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler in one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> bit=rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl="a,b,c",
> sort="a desc, b desc",
> bit=rollup(input(), over="a,b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail:
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set before the tuples hit the
network. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler in one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set before the tuples hit the
> network. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> expr=rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl="a,b,c",
> sort="a desc, b desc",
> expr=rollup(input(), over="a,b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail:
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr=rollup(input(), over="a, b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler in one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> expr=rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl=a,b,c, sort="a desc, b desc",
> expr=rollup(input(), over="a,b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail:
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl="a,b,c",
sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler in one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> expr=rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl="a,b,c",
> sort="a desc, b desc",
> expr=rollup(input(), over="a,b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr=rollup(input(), over="a, b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
exp=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr=rollup(input(), over="a, b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler in one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> expr=rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl=a,b,c, sort="a desc, b desc",
> expr=rollup(input(), over="a, b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail:
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
exp=rollup(input(), over="a,b", sum(c))) {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr=rollup(input(), over="a, b", sum(c))),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr="rollup(input(), over="a,b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler in one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> exp=rollup(input(), over="a,b", sum(c))) {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl=a,b,c, sort="a desc, b desc",
> expr=rollup(input(), over="a, b", sum(c))),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail:
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr="rollup(input(), over="a,b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality by
pushing down the first level of aggregation into the /export handler.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr="rollup(input(), over="a,b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler in one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> expr="rollup(input(), over="a,b", sum(c))") {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))"),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality by
> pushing down the first level of aggregation into the /export handler.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr="rollup(input(), over="a,b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler in one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> expr="rollup(input(), over="a,b", sum(c))") {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))"),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler in one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl="a,b,c", sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))") {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))"),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in one replica
in each shard of a collection and pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in a replica
for each in a collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler in one
> replica in each shard of a collection and pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))") {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))"),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that is described in
SOLR-14470. The idea is for drill to contact the /export handler in a replica
for each in a collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that described in SOLR-14470.
The idea is for drill to contact the /export handler in a replica for each in a
collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Assignee: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that is described in
> SOLR-14470. The idea is for drill to contact the /export handler in a replica
> for each in a collection pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))") {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))"),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that described in SOLR-14470.
The idea is for drill to contact the /export handler in a replica for each in a
collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provides fast aggregation over fields with infinite cardinality.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that described in SOLR-14470.
The idea is for drill to contact the /export handler in a replica for each in a
collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provide fast aggregation over fields with infinite cardinality.
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that described in
> SOLR-14470. The idea is for drill to contact the /export handler in a replica
> for each in a collection pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))") {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))"),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
> This provides fast aggregation over fields with infinite cardinality.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that described in SOLR-14470.
The idea is for drill to contact the /export handler in a replica for each in a
collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
This provide fast aggregation over fields with infinite cardinality.
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that described in SOLR-14470.
The idea is for drill to contact the /export handler in a replica for each in a
collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that described in
> SOLR-14470. The idea is for drill to contact the /export handler in a replica
> for each in a collection pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))") {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))"),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
>
> This provide fast aggregation over fields with infinite cardinality.
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that described in SOLR-14470.
The idea is for drill to contact the /export handler in a replica for each in a
collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that described in SOLR-14470.
The idea is for drill to contact the /export handler in a replica for each in a
collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that described in
> SOLR-14470. The idea is for drill to contact the /export handler in a replica
> for each in a collection pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))") {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))"),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
>
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that described in SOLR-14470.
The idea is for drill to contact the /export handler in a replica for each in a
collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1,
q="*:*",
fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that described in SOLR-14470.
The idea is for drill to contact the /export handler in a replica for each in a
collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
In order to finish the aggregation other expressions can be used:
{code:java}
rollup(
select(
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))"),
a,
b,
sum(c) as sums),
over="a, b",
sum(sums))
{code}
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that described in
> SOLR-14470. The idea is for drill to contact the /export handler in a replica
> for each in a collection pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))") {code}
> In order to finish the aggregation other expressions can be used:
> {code:java}
> rollup(
> select(
>drill(collection1,
> q="*:*",
> fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))"),
>a,
>b,
>sum(c) as sums),
> over="a, b",
> sum(sums))
>
> {code}
>
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that described in SOLR-14470.
The idea is for drill to contact the /export handler in a replica for each in a
collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
was:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that described in SOLR-14470.
The idea is for drill to contact the /export handler in a replica for each in a
collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that described in
> SOLR-14470. The idea is for drill to contact the /export handler in a replica
> for each in a collection pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))") {code}
>
>
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
[jira] [Updated] (SOLR-14481) Add drill Streaming Expression
[
https://issues.apache.org/jira/browse/SOLR-14481?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Joel Bernstein updated SOLR-14481:
--
Description:
This ticket will add the *drill* Streaming Expression. The drill Streaming
Expression is a wrapper around the functionality that described in SOLR-14470.
The idea is for drill to contact the /export handler in a replica for each in a
collection pass four parameters:
* q: query
* fl: field list
* sort: sort spec
* expr: Streaming Expressions.
The export handler will pass the result set through the streaming expression
performing an aggregation on the sorted result set and return the aggregated
tuples. The drill expression will simply maintain the sort order of the tuples
and emit them so that a wrapper expression can perform operations on the sorted
aggregate tuples.
Sample syntax:
{code:java}
drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
expr="rollup(input(), over="a, b", sum(c))") {code}
> Add drill Streaming Expression
> --
>
> Key: SOLR-14481
> URL: https://issues.apache.org/jira/browse/SOLR-14481
> Project: Solr
> Issue Type: New Feature
> Security Level: Public(Default Security Level. Issues are Public)
> Components: streaming expressions
>Reporter: Joel Bernstein
>Priority: Major
>
> This ticket will add the *drill* Streaming Expression. The drill Streaming
> Expression is a wrapper around the functionality that described in
> SOLR-14470. The idea is for drill to contact the /export handler in a replica
> for each in a collection pass four parameters:
> * q: query
> * fl: field list
> * sort: sort spec
> * expr: Streaming Expressions.
> The export handler will pass the result set through the streaming expression
> performing an aggregation on the sorted result set and return the aggregated
> tuples. The drill expression will simply maintain the sort order of the
> tuples and emit them so that a wrapper expression can perform operations on
> the sorted aggregate tuples.
> Sample syntax:
> {code:java}
> drill(collection1, q="*:*", fl=a,b,c, sort="a desc, b desc",
> expr="rollup(input(), over="a, b", sum(c))") {code}
>
>
>
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
-
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
