def translate(self, from_str: StringValue, to_str: StringValue) -> StringValue: """Replace `from_str` characters in `self` characters in `to_str`. To avoid unexpected behavior, `from_str` should be shorter than `to_str`. Parameters ---------- from_str Characters in `arg` to replace to_str Characters to use for replacement Examples -------- >>> import ibis >>> table = ibis.table([('string_col', 'string')]) >>> expr = table.string_col.translate('a', 'b') >>> expr = table.string_col.translate('a', 'bc') Returns ------- StringValue Translated string """ import ibis.expr.operations as ops return ops.Translate(self, from_str, to_str).to_expr()
def test_ops_smoke(): expr = ir.literal(3) ops.UnaryOp(expr) ops.Cast(expr, to='int64') ops.TypeOf(arg=2) ops.Negate(4) ops.Negate(4.0) ops.NullIfZero(0) ops.NullIfZero(1) ops.IsNull(ir.null()) ops.NotNull(ir.null()) ops.ZeroIfNull(ir.null()) ops.IfNull(1, ops.NullIfZero(0).to_expr()) ops.NullIf(ir.null(), ops.NullIfZero(0).to_expr()) ops.IsNan(np.nan) ops.IsInf(np.inf) ops.Ceil(4.5) ops.Floor(4.5) ops.Round(3.43456) ops.Round(3.43456, 2) ops.Round(3.43456, digits=1) ops.Clip(123, lower=30) ops.Clip(123, lower=30, upper=100) ops.BaseConvert('EEE', from_base=16, to_base=10) ops.Logarithm(100) ops.Log(100) ops.Log(100, base=2) ops.Ln(100) ops.Log2(100) ops.Log10(100) ops.Uppercase('asd') ops.Lowercase('asd') ops.Reverse('asd') ops.Strip('asd') ops.LStrip('asd') ops.RStrip('asd') ops.Capitalize('asd') ops.Substring('asd', start=1) ops.Substring('asd', 1) ops.Substring('asd', 1, length=2) ops.StrRight('asd', nchars=2) ops.Repeat('asd', times=4) ops.StringFind('asd', 'sd', start=1) ops.Translate('asd', from_str='bd', to_str='ce') ops.LPad('asd', length=2, pad='ss') ops.RPad('asd', length=2, pad='ss') ops.StringJoin(',', ['asd', 'bsdf']) ops.FuzzySearch('asd', pattern='n') ops.StringSQLLike('asd', pattern='as', escape='asd') ops.RegexExtract('asd', pattern='as', index=1) ops.RegexReplace('asd', 'as', 'a') ops.StringReplace('asd', 'as', 'a') ops.StringSplit('asd', 's') ops.StringConcat(['s', 'e']) ops.StartsWith('asd', 'as') ops.EndsWith('asd', 'xyz')
def _translate(self, from_str, to_str): """ Returns string with set of 'from' characters replaced by set of 'to' characters. from_str[x] is replaced by to_str[x]. To avoid unexpected behavior, from_str should be shorter than to_string. Parameters ---------- from_str : string to_str : string Examples -------- expr = table.strings.translate('a', 'b') expr = table.string.translate('a', 'bc') Returns ------- translated : string """ return _ops.Translate(self, from_str, to_str).to_expr()