Removal of arithmetic operations for temporal values to binary.rs

[berkaysynnada]

Which issue does this PR close?

Closes #5704.

#5764 (comment)
#5764 (comment)

Rationale for this change

Before moving the temporal arithmetic to arrow-rs, it is more convenient to deploy them in binary.rs.

What changes are included in this PR?

the macros and arithmetic functions in datetime.rs are moved to binary.rs.

Are these changes tested?

yes, with existing tests.

Are there any user-facing changes?

[alamb]

Thank you @berkaysynnada

[alamb]

What I am hoping we can do is to move the temporal logic into kernels such as

pub fn add_dyn(lhs: ArrayRef, rhs: ArrayRef) -> Result<ArrayRef> {
  match(lhs.data_type(), rhs.data_type()) {
    (DataType::Timestamp, DataType::Interval) => {
    // call timestamp + interval code
    },
    // handle other temporal types
    _ => {
      // fall back to kernels in arrow-rs
      arrow::compute::add_dyn(...)
    }
}

With this pattern, once the arrow kernel supports interval arithmetic, we can remove the shim datafusion.

We followed this pattern initially when implementing much of the decimal arithmetic, and it worked well I think

https://github.com/apache/arrow-datafusion/blob/main/datafusion/physical-expr/src/expressions/binary/kernels_arrow.rs

Is this something you can help with @berkaysynnada ?

[berkaysynnada]

What I am hoping we can do is to move the temporal logic into kernels such as

pub fn add_dyn(lhs: ArrayRef, rhs: ArrayRef) -> Result<ArrayRef> {
  match(lhs.data_type(), rhs.data_type()) {
    (DataType::Timestamp, DataType::Interval) => {
    // call timestamp + interval code
    },
    // handle other temporal types
    _ => {
      // fall back to kernels in arrow-rs
      arrow::compute::add_dyn(...)
    }
}

With this pattern, once the arrow kernel supports interval arithmetic, we can remove the shim datafusion.

We followed this pattern initially when implementing much of the decimal arithmetic, and it worked well I think

https://github.com/apache/arrow-datafusion/blob/main/datafusion/physical-expr/src/expressions/binary/kernels_arrow.rs

Is this something you can help with @berkaysynnada ?

I have other commitments currently. I would be happy to help when I have more time, but anyone interested in this issue can contact me when needed.

[berkaysynnada]

What I am hoping we can do is to move the temporal logic into kernels such as

pub fn add_dyn(lhs: ArrayRef, rhs: ArrayRef) -> Result<ArrayRef> {
  match(lhs.data_type(), rhs.data_type()) {
    (DataType::Timestamp, DataType::Interval) => {
    // call timestamp + interval code
    },
    // handle other temporal types
    _ => {
      // fall back to kernels in arrow-rs
      arrow::compute::add_dyn(...)
    }
}

With this pattern, once the arrow kernel supports interval arithmetic, we can remove the shim datafusion.

We followed this pattern initially when implementing much of the decimal arithmetic, and it worked well I think

https://github.com/apache/arrow-datafusion/blob/main/datafusion/physical-expr/src/expressions/binary/kernels_arrow.rs

Is this something you can help with @berkaysynnada ?

@alamb would you mind taking a look at this PR when you have time? I tried to implement the changes you suggested. Since the only evaluation of array vs array operations are merged yet (array vs scalar implementation PR will be opened soon), I worked on them. The same approach can be applied to array vs scalar part after it is merged. Thanks for your feedback

[alamb]

I plan to review this PR today