flink-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Ivan Mushketyk (JIRA)" <j...@apache.org>
Subject [jira] [Commented] (FLINK-3414) Add Scala API for CEP's pattern definition
Date Tue, 02 Aug 2016 21:36:20 GMT

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

Ivan Mushketyk commented on FLINK-3414:
---------------------------------------


I would like to describe my proposal on the case-by-case basis. Feel free to point on any
gaps and inconsistencies in this design.
Also, I am not sure what is the best medium for this kind of discussion. I will start it here,
but if you find it inconvenient or sub-optimal, I can move it to some other place.

Let's start with a simplest pattern that expects a single event:

{code:java}
Pattern.begin("start").where(evt -> evt.getId() == 42)
{code}

This can be replaced with a much shorter Scala version

{code:java}
pattern "start" _.getId() == 42
{code}

A single function call *pattern* can replace *Pattern.begin* call and *where* condition can
be added as an argument to this function call.

A pattern that is expecting a specific type like this one:

{code:java}
Pattern.begin("start").where(evt -> evt.getId() == 42)
       .subtype(SubEvent.class)
{code}

Can be replaced with the following Scala code:

{code:java}
pattern[SubEvent] "start" _.id == 42
{code}

The type of an object that is expected can be added as a type parameter to the "pattern" function.

The *next* function can be replaced with the *->* operator:

{code:java}
Pattern.begin("start").where(evt -> evt.getId() == 42)
       .subtype(SubEvent.class)
       .next("next").where(evt -> evt.getId() > 42)
       .subtype(SubEvent.class)
{code}

as in this code snippet:

{code:java}
pattern[SubEvent] "start" _.id == 42 ->[SubEvent] _.getId() > 42
{code}

or with a function call:

{code:java}
pattern[SubEvent] "start" _.id == 42 next[SubEvent] _.getId() > 42
{code}

A followedBy can be replaced with a *->>* operator:

{code:java}
Pattern.begin("start").where(evt -> evt.getId() == 42)
    .next("middle").subtype(SubEvent.class).where(subEvt -> subEvt.getVolume() >= 10.0)
    .followedBy("end").where(evt -> evt.getName().equals("end"));
{code}

as in the following example:

{code:java}
pattern "start" _.getId() == 42
 ->[SubEvent] "middle" _.getVolume() >= 10.0
 ->> "end" _.getName() == "end"
{code}

A *within* function call can be replaced with *in* function that expects an instance of a
FinateDuration class that can provide a more readable code:

{code:java}
pattern "start" -> "middle" _.getName() == "error" ->> "end" _.getName() == "critical"
in 10 seconds
{code}

h3. Additional operators

As far as I understand *or* and *not* operators are not yet implemented, but here are few
examples for these operators

{code:java}
// Pattern that has an event that is not SubEvent
pattern "start" ! is[SubEvent]
{code}

This example also shows an alternative way of specifying a type of element with the *is* function.

{code:java}
// Pattern that has type SubEvent or has id 42
pattern "start" is[SubEvent] || is _.getId() == 42
{code}

> Add Scala API for CEP's pattern definition
> ------------------------------------------
>
>                 Key: FLINK-3414
>                 URL: https://issues.apache.org/jira/browse/FLINK-3414
>             Project: Flink
>          Issue Type: Improvement
>          Components: CEP
>    Affects Versions: 1.0.0
>            Reporter: Till Rohrmann
>            Assignee: Ivan Mushketyk
>            Priority: Minor
>
> Currently, the CEP library only supports a Java API to specify complex event patterns.
In order to make it a bit less verbose for Scala users, it would be nice to also add a Scala
API for the CEP library. 
> A Scala API would also allow to pass Scala's anonymous functions as filter conditions
or as a select function, for example, or to use partial functions to distinguish between different
events.
> Furthermore, the Scala API could be designed to feel a bit more like a DSL:
> {code}
> begin "start" where _.id >= 42 -> "middle_1" as classOf[Subclass] || "middle_2"
where _.name equals "foobar" -> "end" where x => x.id <= x.volume
> {code}



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)

Mime
View raw message