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)