def execute(self, limit='default', params=None, **kwargs):
"""
If this expression is based on physical tables in a database backend,
execute it against that backend.
Parameters
----------
limit : integer or None, default 'default'
Pass an integer to effect a specific row limit. limit=None means "no
limit". The default is whatever is in ibis.options.
Returns
-------
result : expression-dependent
Result of compiling expression and executing in backend
"""
from ibis.client import execute
return execute(self, limit=limit, params=params, **kwargs)
def execute(self, limit='default', params=None, **kwargs):
"""
If this expression is based on physical tables in a database backend,
execute it against that backend.
Parameters
----------
limit : integer or None, default 'default'
Pass an integer to effect a specific row limit. limit=None means "no
limit". The default is whatever is in ibis.options.
Returns
-------
result : expression-dependent
Result of compiling expression and executing in backend
"""
from ibis.client import execute
return execute(self, limit=limit, params=params, **kwargs)
def execute(
self,
limit='default',
timecontext: Optional[TimeContext] = None,
params=None,
**kwargs,
):
"""
If this expression is based on physical tables in a database backend,
execute it against that backend.
Parameters
----------
limit : integer or None, default 'default'
Pass an integer to effect a specific row limit. limit=None means "no
limit". The default is whatever is in ibis.options.
timecontext: Optional[TimeContext], default None.
Defines a time range of (begin, end). When defined, the execution
will only compute result for data inside the time range. The time
range is inclusive of both endpoints. This is conceptually same as
a time filter.
The time column must be named as 'time' and should preserve
across the expression. e.g. If that column is dropped then
execute will result in an error.
Returns
-------
result : expression-dependent
Result of compiling expression and executing in backend
"""
from ibis.client import execute
return execute(self,
limit=limit,
timecontext=timecontext,
params=params,
**kwargs)
class Expr(object):
"""
"""
def _type_display(self):
return type(self).__name__
def __init__(self, arg):
# TODO: all inputs must inherit from a common table API
self._arg = arg
def __repr__(self):
if config.options.interactive:
try:
result = self.execute()
return repr(result)
except com.TranslationError as e:
output = ('Translation to backend failed\n'
'Error message: {0}\n'
'Expression repr follows:\n{1}'
.format(e.args[0], self._repr()))
return output
else:
return self._repr()
def __bool__(self):
raise ValueError("The truth value of an Ibis expression is not "
"defined")
def __nonzero__(self):
return self.__bool__()
def _repr(self, memo=None):
from ibis.expr.format import ExprFormatter
return ExprFormatter(self, memo=memo).get_result()
def pipe(self, f, *args, **kwargs):
"""
Generic composition function to enable expression pipelining
>>> (expr
>>> .pipe(f, *args, **kwargs)
>>> .pipe(g, *args2, **kwargs2))
is equivalent to
>>> g(f(expr, *args, **kwargs), *args2, **kwargs2)
Parameters
----------
f : function or (function, arg_name) tuple
If the expression needs to be passed as anything other than the first
argument to the function, pass a tuple with the argument name. For
example, (f, 'data') if the function f expects a 'data' keyword
args : positional arguments
kwargs : keyword arguments
Examples
--------
>>> def foo(data, a=None, b=None):
... pass
>>> def bar(a, b, data=None):
... pass
>>> expr.pipe(foo, a=5, b=10)
>>> expr.pipe((bar, 'data'), 1, 2)
Returns
-------
result : result type of passed function
"""
if isinstance(f, tuple):
f, data_keyword = f
kwargs = kwargs.copy()
kwargs[data_keyword] = self
return f(*args, **kwargs)
else:
return f(self, *args, **kwargs)
__call__ = pipe
def op(self):
return self._arg
@property
def _factory(self):
def factory(arg, name=None):
return type(self)(arg, name=name)
return factory
def _can_implicit_cast(self, arg):
return False
def execute(self, limit='default', async=False):
"""
If this expression is based on physical tables in a database backend,
execute it against that backend.
Parameters
----------
limit : integer or None, default 'default'
Pass an integer to effect a specific row limit. limit=None means "no
limit". The default is whatever is in ibis.options.
Returns
-------
result : expression-dependent
Result of compiling expression and executing in backend
"""
from ibis.client import execute
return execute(self, limit=limit, async=async)
If this expression is based on physical tables in a database backend,
execute it against that backend.
Parameters
----------
limit : integer or None, default 'default'
Pass an integer to effect a specific row limit. limit=None means "no
limit". The default is whatever is in ibis.options.
Returns
-------
result : expression-dependent
Result of compiling expression and executing in backend
"""
from ibis.client import execute
return execute(self, limit=limit, async=async, params=params)
def compile(self, limit=None, params=None):
"""
Compile expression to whatever execution target, to verify
Returns
-------
compiled : value or list
query representation or list thereof
"""
from ibis.client import compile
return compile(self, limit=limit, params=params)
def verify(self):
"""
class Expr(object):
"""
Base expression class
"""
def _type_display(self):
return type(self).__name__
def __init__(self, arg):
# TODO: all inputs must inherit from a common table API
self._arg = arg
def __repr__(self):
if config.options.interactive:
try:
result = self.execute()
return repr(result)
except com.TranslationError as e:
output = ('Translation to backend failed\n'
'Error message: {0}\n'
'Expression repr follows:\n{1}'.format(
e.args[0], self._repr()))
return output
else:
return self._repr()
def __bool__(self):
raise ValueError("The truth value of an Ibis expression is not "
"defined")
def __nonzero__(self):
return self.__bool__()
def _repr(self, memo=None):
from ibis.expr.format import ExprFormatter
return ExprFormatter(self, memo=memo).get_result()
def _repr_png_(self):
if not ibis.options.graphviz_repr:
return None
try:
import ibis.expr.visualize as viz
except ImportError:
return None
else:
try:
return viz.to_graph(self).pipe(format='png')
except Exception:
# Something may go wrong, and we can't error in the notebook
# so fallback to the default text representation.
return None
def visualize(self, format='png'):
"""Visualize an expression in the browser as a PNG image.
Parameters
----------
format : str, optional
Defaults to ``'png'``. Some additional formats are
``'jpeg'`` and ``'svg'``. These are specified by the ``graphviz``
Python library.
Notes
-----
This method opens a web browser tab showing the image of the expression
graph created by the code in :module:`ibis.expr.visualize`.
Raises
------
ImportError
If ``graphviz`` is not installed.
"""
import ibis.expr.visualize as viz
path = viz.draw(viz.to_graph(self), format=format)
webbrowser.open('file://{}'.format(os.path.abspath(path)))
def pipe(self, f, *args, **kwargs):
"""Generic composition function to enable expression pipelining.
Parameters
----------
f : function or (function, arg_name) tuple
If the expression needs to be passed as anything other than the first
argument to the function, pass a tuple with the argument name. For
example, (f, 'data') if the function f expects a 'data' keyword
args : positional arguments
kwargs : keyword arguments
Examples
--------
>>> import ibis
>>> t = ibis.table([('a', 'int64'), ('b', 'string')], name='t')
>>> f = lambda a: (a + 1).name('a')
>>> g = lambda a: (a * 2).name('a')
>>> result1 = t.a.pipe(f).pipe(g)
>>> result1 # doctest: +NORMALIZE_WHITESPACE
ref_0
UnboundTable[table]
name: t
schema:
a : int64
b : string
a = Multiply[int64*]
left:
a = Add[int64*]
left:
a = Column[int64*] 'a' from table
ref_0
right:
Literal[int8]
1
right:
Literal[int8]
2
>>> result2 = g(f(t.a)) # equivalent to the above
>>> result1.equals(result2)
True
Returns
-------
result : result type of passed function
"""
if isinstance(f, tuple):
f, data_keyword = f
kwargs = kwargs.copy()
kwargs[data_keyword] = self
return f(*args, **kwargs)
else:
return f(self, *args, **kwargs)
__call__ = pipe
def op(self):
return self._arg
@property
def _factory(self):
def factory(arg, name=None):
return type(self)(arg, name=name)
return factory
def execute(self, limit='default', async=False, params=None, **kwargs):
"""
If this expression is based on physical tables in a database backend,
execute it against that backend.
Parameters
----------
limit : integer or None, default 'default'
Pass an integer to effect a specific row limit. limit=None means "no
limit". The default is whatever is in ibis.options.
Returns
-------
result : expression-dependent
Result of compiling expression and executing in backend
"""
from ibis.client import execute
return execute(self, limit=limit, async=async, params=params, **kwargs)
