predicates.go

// 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.

package iceberg

// IsNull is a convenience wrapper for calling UnaryPredicate(OpIsNull, t)
//
// Will panic if t is nil
func IsNull(t UnboundTerm) UnboundPredicate {
	return UnaryPredicate(OpIsNull, t)
}

// NotNull is a convenience wrapper for calling UnaryPredicate(OpNotNull, t)
//
// Will panic if t is nil
func NotNull(t UnboundTerm) UnboundPredicate {
	return UnaryPredicate(OpNotNull, t)
}

// IsNaN is a convenience wrapper for calling UnaryPredicate(OpIsNan, t)
//
// Will panic if t is nil
func IsNaN(t UnboundTerm) UnboundPredicate {
	return UnaryPredicate(OpIsNan, t)
}

// NotNaN is a convenience wrapper for calling UnaryPredicate(OpNotNan, t)
//
// Will panic if t is nil
func NotNaN(t UnboundTerm) UnboundPredicate {
	return UnaryPredicate(OpNotNan, t)
}

// IsIn is a convenience wrapper for constructing an unbound set predicate for
// OpIn. It returns a BooleanExpression instead of an UnboundPredicate because
// depending on the arguments, it can automatically reduce to AlwaysFalse or
// AlwaysTrue (if given no values for examples). It may also reduce to EqualTo
// if only one value is provided.
//
// Will panic if t is nil
func IsIn[T LiteralType](t UnboundTerm, vals ...T) BooleanExpression {
	lits := make([]Literal, 0, len(vals))
	for _, v := range vals {
		lits = append(lits, NewLiteral(v))
	}

	return SetPredicate(OpIn, t, lits)
}

// NotIn is a convenience wrapper for constructing an unbound set predicate for
// OpNotIn. It returns a BooleanExpression instead of an UnboundPredicate because
// depending on the arguments, it can automatically reduce to AlwaysFalse or
// AlwaysTrue (if given no values for examples). It may also reduce to NotEqualTo
// if only one value is provided.
//
// Will panic if t is nil
func NotIn[T LiteralType](t UnboundTerm, vals ...T) BooleanExpression {
	lits := make([]Literal, 0, len(vals))
	for _, v := range vals {
		lits = append(lits, NewLiteral(v))
	}

	return SetPredicate(OpNotIn, t, lits)
}

// EqualTo is a convenience wrapper for calling LiteralPredicate(OpEQ, t, NewLiteral(v))
//
// Will panic if t is nil
func EqualTo[T LiteralType](t UnboundTerm, v T) UnboundPredicate {
	return LiteralPredicate(OpEQ, t, NewLiteral(v))
}

// NotEqualTo is a convenience wrapper for calling LiteralPredicate(OpNEQ, t, NewLiteral(v))
//
// Will panic if t is nil
func NotEqualTo[T LiteralType](t UnboundTerm, v T) UnboundPredicate {
	return LiteralPredicate(OpNEQ, t, NewLiteral(v))
}

// GreaterThanEqual is a convenience wrapper for calling LiteralPredicate(OpGTEQ,
// t, NewLiteral(v))
//
// Will panic if t is nil
func GreaterThanEqual[T LiteralType](t UnboundTerm, v T) UnboundPredicate {
	return LiteralPredicate(OpGTEQ, t, NewLiteral(v))
}

// GreaterThan is a convenience wrapper for calling LiteralPredicate(OpGT,
// t, NewLiteral(v))
//
// Will panic if t is nil
func GreaterThan[T LiteralType](t UnboundTerm, v T) UnboundPredicate {
	return LiteralPredicate(OpGT, t, NewLiteral(v))
}

// LessThanEqual is a convenience wrapper for calling LiteralPredicate(OpLTEQ,
// t, NewLiteral(v))
//
// Will panic if t is nil
func LessThanEqual[T LiteralType](t UnboundTerm, v T) UnboundPredicate {
	return LiteralPredicate(OpLTEQ, t, NewLiteral(v))
}

// LessThan is a convenience wrapper for calling LiteralPredicate(OpLT,
// t, NewLiteral(v))
//
// Will panic if t is nil
func LessThan[T LiteralType](t UnboundTerm, v T) UnboundPredicate {
	return LiteralPredicate(OpLT, t, NewLiteral(v))
}

// StartsWith is a convenience wrapper for calling LiteralPredicate(OpStartsWith,
// t, NewLiteral(v))
//
// Will panic if t is nil
func StartsWith(t UnboundTerm, v string) UnboundPredicate {
	return LiteralPredicate(OpStartsWith, t, NewLiteral(v))
}

// NotStartsWith is a convenience wrapper for calling LiteralPredicate(OpNotStartsWith,
// t, NewLiteral(v))
//
// Will panic if t is nil
func NotStartsWith(t UnboundTerm, v string) UnboundPredicate {
	return LiteralPredicate(OpNotStartsWith, t, NewLiteral(v))
}