// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

include "../../format/Schema.fbs";
include "Literal.fbs";

namespace org.apache.arrow.computeir.flatbuf;

/// Access a value for a given map key
table MapKey {
  /// Any expression can be a map key.
  key: Expression (required);
}

/// Struct field access
table StructField {
  /// The position of the field in the struct schema
  position: uint32;
}

/// Zero-based array index
table ArraySubscript {
  position: uint32;
}

/// Zero-based range of elements in an array
table ArraySlice {
  /// The start of an array slice, inclusive
  start_inclusive: uint32;
  /// The end of an array slice, exclusive
  end_exclusive: uint32;
}

/// Field name in a relation, in ordinal position of the relation's schema.
table FieldIndex {
  position: uint32;
}

/// A union of possible dereference operations
union Deref {
  /// Access a value for a given map key
  MapKey,
  /// Access the value at a struct field
  StructField,
  /// Access the element at a given index in an array
  ArraySubscript,
  /// Access a range of elements in an array
  ArraySlice,
  /// Access a field of a relation
  FieldIndex,
}

/// Access the data of a field
table FieldRef {
  ref: Deref (required);
  /// For Expressions which might reference fields in multiple Relations,
  /// this index may be provided to indicate which Relation's fields
  /// `ref` points into. For example in the case of a join,
  /// 0 refers to the left relation and 1 to the right relation.
  relation_index: int = 0;
}

/// A function call expression
table Call {
  /// The function to call
  name: string (required);

  /// The arguments passed to `name`.
  arguments: [Expression] (required);

  /// Possible ordering of input. These are useful
  /// in aggregates where ordering in meaningful such as
  /// string concatenation
  orderings: [SortKey];
}

/// A single WHEN x THEN y fragment.
table CaseFragment {
  match: Expression (required);
  result: Expression (required);
}

/// Conditional case statement expression
table ConditionalCase {
  /// List of conditions to evaluate
  conditions: [CaseFragment] (required);
  /// The default value if no cases match. This is typically NULL in SQL
  /// implementations.
  ///
  /// Defaulting to NULL is a frontend choice, so producers must specify NULL
  /// if that's their desired behavior.
  else: Expression (required);
}

/// Switch-style case expression
table SimpleCase {
  /// The expression whose value will be matched
  expression: Expression (required);
  /// Matches for `expression`
  matches: [CaseFragment] (required);
  /// The default value if no cases match
  else: Expression (required);
}

/// Whether lesser values should precede greater or vice versa,
/// also whether nulls should preced or follow values
enum Ordering : uint8 {
  ASCENDING_THEN_NULLS,
  DESCENDING_THEN_NULLS,
  NULLS_THEN_ASCENDING,
  NULLS_THEN_DESCENDING,
}

/// An expression with an order
table SortKey {
  expression: Expression (required);
  ordering: Ordering = ASCENDING_THEN_NULLS;
}

/// An unbounded window bound
table Unbounded {}

/// A concrete bound, which can be an expression or unbounded
union ConcreteBoundImpl {
  Expression,
  Unbounded,
}

/// Boundary is preceding rows, determined by the contained expression
table Preceding {
  impl: ConcreteBoundImpl (required);
}

/// Boundary is following rows, determined by the contained expression
table Following {
  impl: ConcreteBoundImpl (required);
}

/// Boundary is the current row
table CurrentRow {}

union Bound {
  Preceding,
  Following,
  CurrentRow,
}

/// The kind of window function to be executed
enum Frame : uint8 {
  Rows,
  Range,
}

/// An expression representing a window function call.
table WindowCall {
  /// The expression to operate over
  expression: Expression (required);
  /// The kind of window frame
  kind: Frame;
  /// Partition keys
  partitions: [Expression] (required);
  /// Sort keys
  orderings: [SortKey] (required);
  /// Lower window bound
  lower_bound: Bound (required);
  /// Upper window bound
  upper_bound: Bound (required);
}

/// A cast expression
table Cast {
  /// The expression to cast
  operand: Expression (required);
  /// The type to cast to. This value is a `Field` to allow complete representation
  /// of arrow types.
  ///
  /// `Type` is unable to completely represent complex types like lists and
  /// maps.
  to: org.apache.arrow.flatbuf.Field (required);
}

/// Various expression types
///
/// WindowCall is a separate variant
/// due to special options for each that don't apply to generic
/// function calls. Again this is done to make it easier
/// for consumers to deal with the structure of the operation
union ExpressionImpl {
  Literal,
  FieldRef,
  Call,
  ConditionalCase,
  SimpleCase,
  WindowCall,
  Cast,
}

/// Expression types
///
/// Expressions have a concrete `impl` value, which is a specific operation.
///
/// This is a workaround for flatbuffers' lack of support for direct use of
/// union types.
table Expression {
  impl: ExpressionImpl (required);
}

root_type Expression;