def highest_precedence_type(exprs): # Return the highest precedence type from the passed expressions. Also # verifies that there are valid implicit casts between any of the types and # the selected highest precedence type if not exprs: raise ValueError('Must pass at least one expression') expr_dtypes = {expr.type() for expr in exprs} return dt.highest_precedence(expr_dtypes)
def output_dtype(self): value_type = self.arg.type().value_type default_type = self.default.type() if not dt.same_kind(default_type, value_type): raise com.IbisTypeError( "Default value\n{}\nof type {} cannot be cast to map's value " "type {}".format(self.default, default_type, value_type)) return dt.highest_precedence((default_type, value_type))
def _promote_numeric_binop(exprs, op): bounds, dtypes = [], [] for arg in exprs: dtypes.append(arg.type()) if hasattr(arg.op(), 'value'): # arg.op() is a literal bounds.append([arg.op().value]) else: bounds.append(arg.type().bounds) # In some cases, the bounding type might be int8, even though neither # of the types are that small. We want to ensure the containing type is # _at least_ as large as the smallest type in the expression. values = starmap(op, product(*bounds)) dtypes += [dt.infer(value, allow_overflow=True) for value in values] return dt.highest_precedence(dtypes)
def highest_precedence_dtype(exprs): """Return the highest precedence type from the passed expressions Also verifies that there are valid implicit casts between any of the types and the selected highest precedence type. This is a thin wrapper around datatypes highest precedence check. Parameters ---------- exprs : Iterable[ir.ValueExpr] A sequence of Expressions Returns ------- dtype: DataType The highest precedence datatype """ if not exprs: raise ValueError('Must pass at least one expression') return dt.highest_precedence(expr.type() for expr in exprs)