Streaming temporal operator (join, cross...) syntax

classic Classic list List threaded Threaded
5 messages Options
Reply | Threaded
Open this post in threaded view
|

Streaming temporal operator (join, cross...) syntax

Gyula Fóra-2
Hey guys,

We have been discussing the possible syntaxes for doing temporal operators
on DataStreams(join, corss, cogroup etc) with Paris and we have come up
with two alternatives.

1.

ds1.join(ds2).onWindow(5, seconds).every(2, seconds).where(...).equalTo(...)

2.

ds1.connect(ds2).onWindow(5, seconds).every(2,
seconds).join().where(...).equalTo(...)



Basically the difference is that in the second case we produce a binary
stream of 2 types by the connect method and we create a window on that
before join/cross. While in the first case the join/cross/etc is the method
of the DataStream itself and we define the window after calling
join/cross/etc

We currently have the first one.

Which one do you think is the more intuitive? (Or propose an alternative)

Cheers,
Gyula & Paris
Reply | Threaded
Open this post in threaded view
|

Re: Streaming temporal operator (join, cross...) syntax

Szabó Péter
The first one looks great and more compact. I think, the second one is less
intuitive.

Cheers,
Peter

2015-01-05 10:46 GMT+01:00 Gyula Fóra <[hidden email]>:

> Hey guys,
>
> We have been discussing the possible syntaxes for doing temporal operators
> on DataStreams(join, corss, cogroup etc) with Paris and we have come up
> with two alternatives.
>
> 1.
>
> ds1.join(ds2).onWindow(5, seconds).every(2,
> seconds).where(...).equalTo(...)
>
> 2.
>
> ds1.connect(ds2).onWindow(5, seconds).every(2,
> seconds).join().where(...).equalTo(...)
>
>
>
> Basically the difference is that in the second case we produce a binary
> stream of 2 types by the connect method and we create a window on that
> before join/cross. While in the first case the join/cross/etc is the method
> of the DataStream itself and we define the window after calling
> join/cross/etc
>
> We currently have the first one.
>
> Which one do you think is the more intuitive? (Or propose an alternative)
>
> Cheers,
> Gyula & Paris
>
Reply | Threaded
Open this post in threaded view
|

Re: Streaming temporal operator (join, cross...) syntax

Stephan Ewen
I think the first one is more intuitive as well..

Greetings,
Stephan

On Mon, Jan 5, 2015 at 1:26 PM, Szabó Péter <[hidden email]>
wrote:

> The first one looks great and more compact. I think, the second one is less
> intuitive.
>
> Cheers,
> Peter
>
> 2015-01-05 10:46 GMT+01:00 Gyula Fóra <[hidden email]>:
>
> > Hey guys,
> >
> > We have been discussing the possible syntaxes for doing temporal
> operators
> > on DataStreams(join, corss, cogroup etc) with Paris and we have come up
> > with two alternatives.
> >
> > 1.
> >
> > ds1.join(ds2).onWindow(5, seconds).every(2,
> > seconds).where(...).equalTo(...)
> >
> > 2.
> >
> > ds1.connect(ds2).onWindow(5, seconds).every(2,
> > seconds).join().where(...).equalTo(...)
> >
> >
> >
> > Basically the difference is that in the second case we produce a binary
> > stream of 2 types by the connect method and we create a window on that
> > before join/cross. While in the first case the join/cross/etc is the
> method
> > of the DataStream itself and we define the window after calling
> > join/cross/etc
> >
> > We currently have the first one.
> >
> > Which one do you think is the more intuitive? (Or propose an alternative)
> >
> > Cheers,
> > Gyula & Paris
> >
>
Reply | Threaded
Open this post in threaded view
|

Re: Streaming temporal operator (join, cross...) syntax

Till Rohrmann
I also prefer the first alternative.

Greets,
Till

On Mon, Jan 5, 2015 at 2:01 PM, Stephan Ewen <[hidden email]> wrote:

> I think the first one is more intuitive as well..
>
> Greetings,
> Stephan
>
> On Mon, Jan 5, 2015 at 1:26 PM, Szabó Péter <[hidden email]>
> wrote:
>
> > The first one looks great and more compact. I think, the second one is
> less
> > intuitive.
> >
> > Cheers,
> > Peter
> >
> > 2015-01-05 10:46 GMT+01:00 Gyula Fóra <[hidden email]>:
> >
> > > Hey guys,
> > >
> > > We have been discussing the possible syntaxes for doing temporal
> > operators
> > > on DataStreams(join, corss, cogroup etc) with Paris and we have come up
> > > with two alternatives.
> > >
> > > 1.
> > >
> > > ds1.join(ds2).onWindow(5, seconds).every(2,
> > > seconds).where(...).equalTo(...)
> > >
> > > 2.
> > >
> > > ds1.connect(ds2).onWindow(5, seconds).every(2,
> > > seconds).join().where(...).equalTo(...)
> > >
> > >
> > >
> > > Basically the difference is that in the second case we produce a binary
> > > stream of 2 types by the connect method and we create a window on that
> > > before join/cross. While in the first case the join/cross/etc is the
> > method
> > > of the DataStream itself and we define the window after calling
> > > join/cross/etc
> > >
> > > We currently have the first one.
> > >
> > > Which one do you think is the more intuitive? (Or propose an
> alternative)
> > >
> > > Cheers,
> > > Gyula & Paris
> > >
> >
>
Reply | Threaded
Open this post in threaded view
|

Re: Streaming temporal operator (join, cross...) syntax

Chiwan Park
I also think that the first one is more intuitive.


Chiwan Park (Sent with iPhone)


> On Jan 5, 2015, at 10:51 PM, Till Rohrmann <[hidden email]> wrote:
>
> I also prefer the first alternative.
>
> Greets,
> Till
>
> On Mon, Jan 5, 2015 at 2:01 PM, Stephan Ewen <[hidden email]> wrote:
>
>> I think the first one is more intuitive as well..
>>
>> Greetings,
>> Stephan
>>
>> On Mon, Jan 5, 2015 at 1:26 PM, Szabó Péter <[hidden email]>
>> wrote:
>>
>>> The first one looks great and more compact. I think, the second one is
>> less
>>> intuitive.
>>>
>>> Cheers,
>>> Peter
>>>
>>> 2015-01-05 10:46 GMT+01:00 Gyula Fóra <[hidden email]>:
>>>
>>>> Hey guys,
>>>>
>>>> We have been discussing the possible syntaxes for doing temporal
>>> operators
>>>> on DataStreams(join, corss, cogroup etc) with Paris and we have come up
>>>> with two alternatives.
>>>>
>>>> 1.
>>>>
>>>> ds1.join(ds2).onWindow(5, seconds).every(2,
>>>> seconds).where(...).equalTo(...)
>>>>
>>>> 2.
>>>>
>>>> ds1.connect(ds2).onWindow(5, seconds).every(2,
>>>> seconds).join().where(...).equalTo(...)
>>>>
>>>>
>>>>
>>>> Basically the difference is that in the second case we produce a binary
>>>> stream of 2 types by the connect method and we create a window on that
>>>> before join/cross. While in the first case the join/cross/etc is the
>>> method
>>>> of the DataStream itself and we define the window after calling
>>>> join/cross/etc
>>>>
>>>> We currently have the first one.
>>>>
>>>> Which one do you think is the more intuitive? (Or propose an
>> alternative)
>>>>
>>>> Cheers,
>>>> Gyula & Paris
>>>>
>>>
>>