refactor(api): refactor the implementation of windowing

[chloeh13q]

Description of changes

Some design considerations:

• Removed the original implementation of windowing to avoid confusion.
• I thought about creating a window class to hold all the relevant windowing info like window type, window size, window slide, etc. The API would be slightly cleaner that way but I worry that it would be confused with the existing ibis.window().
• Tumble and hop are the most basic types of windows that we should support across the board. Session windows and cumulate windows are not supported in every backend and the API is slightly different.

The new API:

>>> import ibis
>>> from ibis import _
>>> t = ibis.table(
...     ibis.schema(
...         {
...             "createTime": "timestamp(3)",
...             "orderId": "int64",
...             "payAmount": "float64",
...             "payPlatform": "int32",
...             "provinceId": "int32",
...         }
...     ),
...     name="payment_msg",
... )
>>> expr = (
...         t.window_by(time_col="createTime")
...         .tumble(size=ibis.interval(seconds=30))
...         .agg(by=["provinceId"], avgPayAmount=_.payAmount.mean())
...     )
>>> expr
r0 := UnboundTable: payment_msg
  createTime  timestamp(3)
  orderId     int64
  payAmount   float64
  payPlatform int32
  provinceId  int32

WindowAggregate[r0]
  window_type:
    tumble
  time_col:
    r0.createTime
  groups:
    provinceId: r0.provinceId
  metrics:
    avgPayAmount: Mean(r0.payAmount)
  window_size:
    30 s
  schema:
    window_start timestamp
    window_end   timestamp
    provinceId   int32
    avgPayAmount float64

Issues closed

#8847

[cpcloud]

@chloeh13q This LGTM! Just to clarify, are there any user-facing API changes, or is it only internals that have changed?

[chloeh13q]

@cpcloud Thanks for reviewing!

are there any user-facing API changes, or is it only internals that have changed?

There are user-facing API changes, although the changes are pretty subtle. We're changing:

expr = (
    t.window_by(time_col="i")
    .tumble(window_size=ibis.interval(minutes=15))
    .group_by(["window_start", "window_end", "g"])
    .aggregate(mean=_.d.mean())
)

to something like

expr = (
    t.window_by(time_col="i")
    .tumble(window_size=ibis.interval(minutes=15))
    .group_by(["g"])
    .aggregate(mean=_.d.mean())
)

The big difference is that we're trying to hide columns like "window_start" "window_end" from the user (as well as providing more alternative syntax in a more Ibis-like manner, e.g., you can use both .agg and .aggregate, and you can put the groupby into aggregate as well now).

[ps: only implemented windowed aggregations so far to see if we like this new API and IR changes. Planning to implement window top-n, window join, and cascading windows (aka chained window aggregations) (note that we didn't have alternative syntax for these previously, but you could do them with underlying ops like row number, so these are going to be new APIs) in subsequent PRs]

With changes merged from another PR, I was able to add tests for window aggregations in the Spark backend too.