_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q24900 | convert_to_database_compatible_value | train | def convert_to_database_compatible_value(value):
"""Pandas 0.23 broke DataFrame.to_sql, so we workaround it by rolling our
own extremely low-tech conversion routine
| python | {
"resource": ""
} |
q24901 | matches | train | def matches(value, pattern):
"""Check whether `value` matches `pattern`.
Parameters
----------
value : ast.AST
pattern : ast.AST
Returns
-------
matched : bool
"""
# types must match exactly
if type(value) != type(pattern):
return False
# primitive value, such ... | python | {
"resource": ""
} |
q24902 | highest_precedence_dtype | train | 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
... | python | {
"resource": ""
} |
q24903 | castable | train | def castable(source, target):
"""Return whether source ir type is implicitly castable to target
Based on the underlying datatypes and the value in case of Literals
"""
op | python | {
"resource": ""
} |
q24904 | one_of | train | def one_of(inners, arg):
"""At least one of the inner validators must pass"""
for inner in inners:
with suppress(com.IbisTypeError, ValueError):
return inner(arg)
| python | {
"resource": ""
} |
q24905 | instance_of | train | def instance_of(klass, arg):
"""Require that a value has a particular Python type."""
if not isinstance(arg, klass):
raise com.IbisTypeError(
| python | {
"resource": ""
} |
q24906 | value | train | def value(dtype, arg):
"""Validates that the given argument is a Value with a particular datatype
Parameters
----------
dtype : DataType subclass or DataType instance
arg : python literal or an ibis expression
If a python literal is given the validator tries to coerce it to an ibis
lite... | python | {
"resource": ""
} |
q24907 | table | train | def table(schema, arg):
"""A table argument.
Parameters
----------
schema : Union[sch.Schema, List[Tuple[str, dt.DataType]]
A validator for the table's columns. Only column subset validators are
currently supported. Accepts any arguments that `sch.schema` accepts.
See the exampl... | python | {
"resource": ""
} |
q24908 | wrap_uda | train | def wrap_uda(
hdfs_file,
inputs,
output,
update_fn,
init_fn=None,
merge_fn=None,
finalize_fn=None,
serialize_fn=None,
close_fn=None,
name=None,
):
"""
Creates a callable aggregation function object. Must be created in Impala
to be used
Parameters
----------
... | python | {
"resource": ""
} |
q24909 | wrap_udf | train | def wrap_udf(hdfs_file, inputs, output, so_symbol, name=None):
"""
Creates a callable scalar function object. Must be created in Impala to be
used
Parameters
----------
hdfs_file: .so file that contains relevant UDF
inputs: list of strings or sig.TypeSignature
Input types to UDF
o... | python | {
"resource": ""
} |
q24910 | add_operation | train | def add_operation(op, func_name, db):
"""
Registers the given operation within the Ibis SQL translation toolchain
Parameters
----------
op: operator class
name: used in issuing statements to SQL engine
database: database the relevant operator is registered to
"""
full_name = '{0}.{1... | python | {
"resource": ""
} |
q24911 | connect | train | def connect(
host='localhost',
port=21050,
database='default',
timeout=45,
use_ssl=False,
ca_cert=None,
user=None,
password=None,
auth_mechanism='NOSASL',
kerberos_service_name='impala',
pool_size=8,
hdfs_client=None,
):
"""Create an ImpalaClient for use with Ibis.
... | python | {
"resource": ""
} |
q24912 | execute_with_scope | train | def execute_with_scope(expr, scope, aggcontext=None, clients=None, **kwargs):
"""Execute an expression `expr`, with data provided in `scope`.
Parameters
----------
expr : ibis.expr.types.Expr
The expression to execute.
scope : collections.Mapping
A dictionary mapping :class:`~ibis.e... | python | {
"resource": ""
} |
q24913 | execute_until_in_scope | train | def execute_until_in_scope(
expr, scope, aggcontext=None, clients=None, post_execute_=None, **kwargs
):
"""Execute until our op is in `scope`.
Parameters
----------
expr : ibis.expr.types.Expr
scope : Mapping
aggcontext : Optional[AggregationContext]
clients : List[ibis.client.Client]
... | python | {
"resource": ""
} |
q24914 | execute_bottom_up | train | def execute_bottom_up(
expr, scope, aggcontext=None, post_execute_=None, clients=None, **kwargs
):
"""Execute `expr` bottom-up.
Parameters
----------
expr : ibis.expr.types.Expr
scope : Mapping[ibis.expr.operations.Node, object]
aggcontext : Optional[ibis.pandas.aggcontext.AggregationContex... | python | {
"resource": ""
} |
q24915 | KuduImpalaInterface.connect | train | def connect(
self,
host_or_hosts,
port_or_ports=7051,
rpc_timeout=None,
admin_timeout=None,
):
"""
Pass-through connection interface to the Kudu client
Parameters
----------
host_or_hosts : string or list of strings
If you ha... | python | {
"resource": ""
} |
q24916 | KuduImpalaInterface.create_table | train | def create_table(
self,
impala_name,
kudu_name,
primary_keys=None,
obj=None,
schema=None,
database=None,
external=False,
force=False,
):
"""
Create an Kudu-backed table in the connected Impala cluster. For
non-external t... | python | {
"resource": ""
} |
q24917 | connect | train | def connect(
host='localhost',
port=9000,
database='default',
user='default',
password='',
client_name='ibis',
compression=_default_compression,
):
"""Create an ClickhouseClient for use with Ibis.
Parameters
----------
host : str, optional
Host name of the clickhouse... | python | {
"resource": ""
} |
q24918 | ClickhouseClient.list_databases | train | def list_databases(self, like=None):
"""
List databases in the Clickhouse cluster.
Like the SHOW DATABASES command in the clickhouse-shell.
Parameters
----------
like : string, default None
| python | {
"resource": ""
} |
q24919 | remap_overlapping_column_names | train | def remap_overlapping_column_names(table_op, root_table, data_columns):
"""Return an ``OrderedDict`` mapping possibly suffixed column names to
column names without suffixes.
Parameters
----------
table_op : TableNode
The ``TableNode`` we're selecting from.
root_table : TableNode
... | python | {
"resource": ""
} |
q24920 | _compute_predicates | train | def _compute_predicates(table_op, predicates, data, scope, **kwargs):
"""Compute the predicates for a table operation.
Parameters
----------
table_op : TableNode
predicates : List[ir.ColumnExpr]
data : pd.DataFrame
scope : dict
kwargs : dict
Returns
-------
computed_predica... | python | {
"resource": ""
} |
q24921 | flatten_union | train | def flatten_union(table):
"""Extract all union queries from `table`.
Parameters
----------
table : TableExpr
Returns
-------
Iterable[Union[TableExpr, | python | {
"resource": ""
} |
q24922 | ExprTranslator.get_result | train | def get_result(self):
"""
Build compiled SQL expression from the bottom up and return as a string
"""
translated = self.translate(self.expr)
| python | {
"resource": ""
} |
q24923 | Select.compile | train | def compile(self):
"""
This method isn't yet idempotent; calling multiple times may yield
unexpected results
"""
# Can't tell if this is a hack or not. Revisit later
self.context.set_query(self)
# If any subqueries, translate them and add to beginning of query as... | python | {
"resource": ""
} |
q24924 | table | train | def table(schema, name=None):
"""
Create an unbound Ibis table for creating expressions. Cannot be executed
without being bound to some physical table.
Useful for testing
Parameters
----------
schema : ibis Schema
name : string, default None
Name for table
Returns
------... | python | {
"resource": ""
} |
q24925 | timestamp | train | def timestamp(value, timezone=None):
"""
Returns a timestamp literal if value is likely coercible to a timestamp
Parameters
----------
value : timestamp value as string
timezone: timezone as string
defaults to None
Returns
--------
result : TimestampScalar
"""
if is... | python | {
"resource": ""
} |
q24926 | date | train | def date(value):
"""
Returns a date literal if value is likely coercible to a date
Parameters
----------
value : | python | {
"resource": ""
} |
q24927 | time | train | def time(value):
"""
Returns a time literal if value is likely coercible to a time
Parameters
----------
value : | python | {
"resource": ""
} |
q24928 | interval | train | def interval(
value=None,
unit='s',
years=None,
quarters=None,
months=None,
weeks=None,
days=None,
hours=None,
minutes=None,
seconds=None,
milliseconds=None,
microseconds=None,
nanoseconds=None,
):
"""
Returns an interval literal
Parameters
----------... | python | {
"resource": ""
} |
q24929 | negate | train | def negate(arg):
"""
Negate a numeric expression
Parameters
----------
arg : numeric value expression
Returns
| python | {
"resource": ""
} |
q24930 | over | train | def over(expr, window):
"""
Turn an aggregation or full-sample analytic operation into a windowed
operation. See ibis.window for more details on window configuration
Parameters
----------
expr : value expression
window : ibis.Window
| python | {
"resource": ""
} |
q24931 | value_counts | train | def value_counts(arg, metric_name='count'):
"""
Compute a frequency table for this value expression
Parameters
----------
Returns
-------
counts : TableExpr
Aggregated table
"""
base = ir.find_base_table(arg)
metric = base.count().name(metric_name)
try:
| python | {
"resource": ""
} |
q24932 | isin | train | def isin(arg, values):
"""
Check whether the value expression is contained within the indicated
list of values.
Parameters
----------
values : list, tuple, or array expression
The values can be scalar or array-like. Each of them must be
comparable with the calling expression, or Non... | python | {
"resource": ""
} |
q24933 | cases | train | def cases(arg, case_result_pairs, default=None):
"""
Create a case expression in one shot.
Returns
-------
case_expr : SimpleCase
| python | {
"resource": ""
} |
q24934 | _generic_summary | train | def _generic_summary(arg, exact_nunique=False, prefix=None):
"""
Compute a set of summary metrics from the input value expression
Parameters
----------
arg : value expression
exact_nunique : boolean, default False
Compute the exact number of distinct values (slower)
prefix : string, d... | python | {
"resource": ""
} |
q24935 | _numeric_summary | train | def _numeric_summary(arg, exact_nunique=False, prefix=None):
"""
Compute a set of summary metrics from the input numeric value expression
Parameters
----------
arg : numeric value expression
exact_nunique : boolean, default False
prefix : string, default None
String prefix for metric ... | python | {
"resource": ""
} |
q24936 | round | train | def round(arg, digits=None):
"""
Round values either to integer or indicated number of decimal places.
Returns
-------
rounded : type depending on digits argument
digits None or 0
decimal types: decimal
other numeric types: bigint
| python | {
"resource": ""
} |
q24937 | log | train | def log(arg, base=None):
"""
Perform the logarithm using a specified base
Parameters
----------
| python | {
"resource": ""
} |
q24938 | quantile | train | def quantile(arg, quantile, interpolation='linear'):
"""
Return value at the given quantile, a la numpy.percentile.
Parameters
----------
quantile : float/int or array-like
0 <= quantile <= 1, the quantile(s) to compute
interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'... | python | {
"resource": ""
} |
q24939 | _integer_to_interval | train | def _integer_to_interval(arg, unit='s'):
"""
Convert integer interval with the same inner type
Parameters
----------
| python | {
"resource": ""
} |
q24940 | correlation | train | def correlation(left, right, where=None, how='sample'):
"""
Compute correlation of two numeric array
Parameters
----------
how : {'sample', 'pop'}, default 'sample'
Returns
| python | {
"resource": ""
} |
q24941 | covariance | train | def covariance(left, right, where=None, how='sample'):
"""
Compute covariance of two numeric array
Parameters
----------
how : {'sample', 'pop'}, default 'sample'
Returns
| python | {
"resource": ""
} |
q24942 | geo_area | train | def geo_area(arg, use_spheroid=None):
"""
Compute area of a geo spatial data
Parameters
----------
arg : geometry or geography
use_spheroid: default None
Returns | python | {
"resource": ""
} |
q24943 | geo_contains | train | def geo_contains(left, right):
"""
Check if the first geometry contains the second one
Parameters
----------
left : geometry
right : geometry
| python | {
"resource": ""
} |
q24944 | geo_distance | train | def geo_distance(left, right, use_spheroid=None):
"""
Compute distance between two geo spatial data
Parameters
----------
left : geometry or geography
right : geometry or geography
use_spheroid : default | python | {
"resource": ""
} |
q24945 | geo_length | train | def geo_length(arg, use_spheroid=None):
"""
Compute length of a geo spatial data
Parameters
----------
arg : geometry or geography
use_spheroid : default None
| python | {
"resource": ""
} |
q24946 | geo_perimeter | train | def geo_perimeter(arg, use_spheroid=None):
"""
Compute perimeter of a geo spatial data
Parameters
----------
arg : geometry or geography
use_spheroid : default None
| python | {
"resource": ""
} |
q24947 | geo_max_distance | train | def geo_max_distance(left, right):
"""Returns the 2-dimensional maximum distance between two geometries in
projected units. If g1 and g2 is the same geometry the function will
return the distance between the two vertices most far from each other
in that geometry
Parameters
----------
left :... | python | {
"resource": ""
} |
q24948 | geo_point_n | train | def geo_point_n(arg, n):
"""Return the Nth point in a single linestring in the geometry.
Negative values are counted backwards from the end of the LineString,
so that -1 is the last point. Returns NULL if there is no linestring in
the geometry
Parameters
----------
arg : | python | {
"resource": ""
} |
q24949 | ifelse | train | def ifelse(arg, true_expr, false_expr):
"""
Shorthand for implementing ternary expressions
bool_expr.ifelse(0, 1)
e.g., in SQL: CASE WHEN bool_expr THEN 0 else 1 END
| python | {
"resource": ""
} |
q24950 | _string_substr | train | def _string_substr(self, start, length=None):
"""
Pull substrings out of each string value by position and maximum
length.
Parameters
----------
start : int
First character to start splitting, indices starting at 0 (like
Python)
length : int, optional
Maximum length of eac... | python | {
"resource": ""
} |
q24951 | regex_extract | train | def regex_extract(arg, pattern, index):
"""
Returns specified index, 0 indexed, from string based on regex pattern
given
Parameters
----------
pattern : string (regular expression string)
| python | {
"resource": ""
} |
q24952 | regex_replace | train | def regex_replace(arg, pattern, replacement):
"""
Replaces match found by regex with replacement string.
Replacement string can also be a regex
Parameters
----------
pattern : string (regular expression string)
replacement : string (can be regular expression string)
Examples
------... | python | {
"resource": ""
} |
q24953 | _string_replace | train | def _string_replace(arg, pattern, replacement):
"""
Replaces each exactly occurrence of pattern with given replacement
string. Like Python built-in str.replace
Parameters
----------
pattern : string
replacement : string
Examples
--------
>>> import ibis
>>> table = ibis.tab... | python | {
"resource": ""
} |
q24954 | to_timestamp | train | def to_timestamp(arg, format_str, timezone=None):
"""
Parses a string and returns a timestamp.
Parameters
----------
format_str : A format string potentially of the type '%Y-%m-%d'
timezone : An optional string indicating the timezone,
i.e. 'America/New_York'
Examples
--------
... | python | {
"resource": ""
} |
q24955 | parse_url | train | def parse_url(arg, extract, key=None):
"""
Returns the portion of a URL corresponding to a part specified
by 'extract'
Can optionally specify a key to retrieve an associated value
if extract parameter is 'QUERY'
Parameters
----------
extract : one of {'PROTOCOL', 'HOST', 'PATH', 'REF',
... | python | {
"resource": ""
} |
q24956 | _array_slice | train | def _array_slice(array, index):
"""Slice or index `array` at `index`.
Parameters
----------
index : int or ibis.expr.types.IntegerValue or slice
Returns
-------
sliced_array : ibis.expr.types.ValueExpr
If `index` is an ``int`` or :class:`~ibis.expr.types.IntegerValue` then
... | python | {
"resource": ""
} |
q24957 | get | train | def get(expr, key, default=None):
"""
Return the mapped value for this key, or the default
if the key does not exist
Parameters
----------
| python | {
"resource": ""
} |
q24958 | _struct_get_field | train | def _struct_get_field(expr, field_name):
"""Get the `field_name` field from the ``Struct`` expression `expr`.
Parameters
----------
field_name : str
The name of the field to access from the ``Struct`` typed expression
`expr`. Must be a Python ``str`` type; programmatic struct field
... | python | {
"resource": ""
} |
q24959 | join | train | def join(left, right, predicates=(), how='inner'):
"""Perform a relational join between two tables. Does not resolve resulting
table schema.
Parameters
----------
left : TableExpr
right : TableExpr
predicates : join expression(s)
how : string, default 'inner'
- 'inner': inner join... | python | {
"resource": ""
} |
q24960 | asof_join | train | def asof_join(left, right, predicates=(), by=(), tolerance=None):
"""Perform an asof join between two tables. Similar to a left join
except that the match is done on nearest key rather than equal keys.
Optionally, match keys with 'by' before joining with predicates.
Parameters | python | {
"resource": ""
} |
q24961 | _table_info | train | def _table_info(self, buf=None):
"""
Similar to pandas DataFrame.info. Show column names, types, and null
counts. Output to stdout by default
"""
metrics = [self.count().name('nrows')]
for col in self.columns:
metrics.append(self[col].count().name(col))
metrics = self.aggregate(metr... | python | {
"resource": ""
} |
q24962 | _table_set_column | train | def _table_set_column(table, name, expr):
"""
Replace an existing column with a new expression
Parameters
----------
name : string
Column name to replace
expr : value expression
New data for column
Returns
-------
set_table : TableExpr
New table expression
"""... | python | {
"resource": ""
} |
q24963 | filter | train | def filter(table, predicates):
"""
Select rows from table based on boolean expressions
Parameters
----------
predicates : boolean array expressions, | python | {
"resource": ""
} |
q24964 | aggregate | train | def aggregate(table, metrics=None, by=None, having=None, **kwds):
"""
Aggregate a table with a given set of reductions, with grouping
expressions, and post-aggregation filters.
Parameters
----------
table : table expression
metrics : expression or expression list
| python | {
"resource": ""
} |
q24965 | _table_union | train | def _table_union(left, right, distinct=False):
"""
Form the table set union of two table expressions having identical
schemas.
Parameters
----------
right : TableExpr
distinct : boolean, default False
Only union distinct rows not occurring in the calling table (this
| python | {
"resource": ""
} |
q24966 | _table_materialize | train | def _table_materialize(table):
"""
Force schema resolution for a joined table, selecting all fields from
all tables.
"""
if | python | {
"resource": ""
} |
q24967 | mutate | train | def mutate(table, exprs=None, **mutations):
"""
Convenience function for table projections involving adding columns
Parameters
----------
exprs : list, default None
List of named expressions to add as columns
mutations : keywords for new columns
Returns
-------
mutated : Tabl... | python | {
"resource": ""
} |
q24968 | projection | train | def projection(table, exprs):
"""
Compute new table expression with the indicated column expressions from
this table.
Parameters
----------
exprs : column expression, or string, or list of column expressions and
strings. If strings passed, must be columns in the table already
Returns... | python | {
"resource": ""
} |
q24969 | _table_relabel | train | def _table_relabel(table, substitutions, replacements=None):
"""
Change table column names, otherwise leaving table unaltered
Parameters
----------
substitutions
Returns
-------
relabeled : TableExpr
"""
if replacements is not None:
raise NotImplementedError
observ... | python | {
"resource": ""
} |
q24970 | prevent_rewrite | train | def prevent_rewrite(expr, client=None):
"""Prevent optimization from happening below `expr`.
Parameters
----------
expr : ir.TableExpr
Any table expression whose optimization you want to prevent
client : ibis.client.Client, optional, default None
A client to use to create the SQLQue... | python | {
"resource": ""
} |
q24971 | from_dataframe | train | def from_dataframe(df, name='df', client=None):
"""
convenience function to construct an ibis table
from a DataFrame
EXPERIMENTAL API
Parameters
----------
df : DataFrame
name : str, default 'df'
client : Client, default new PandasClient
client dictionary will be mutated wi... | python | {
"resource": ""
} |
q24972 | _flatten_subclass_tree | train | def _flatten_subclass_tree(cls):
"""Return the set of all child classes of `cls`.
Parameters
----------
cls : Type
Returns
-------
frozenset[Type]
"""
subclasses | python | {
"resource": ""
} |
q24973 | bigquery_field_to_ibis_dtype | train | def bigquery_field_to_ibis_dtype(field):
"""Convert BigQuery `field` to an ibis type."""
typ = field.field_type
if typ == 'RECORD':
fields = field.fields
assert fields, 'RECORD fields are empty'
names = [el.name for el in fields]
ibis_types = list(map(dt.dtype, fields))
... | python | {
"resource": ""
} |
q24974 | bigquery_schema | train | def bigquery_schema(table):
"""Infer the schema of a BigQuery `table` object."""
fields = OrderedDict((el.name, dt.dtype(el)) for el in table.schema)
partition_info = table._properties.get('timePartitioning', None)
| python | {
"resource": ""
} |
q24975 | parse_project_and_dataset | train | def parse_project_and_dataset(
project: str, dataset: Optional[str] = None
) -> Tuple[str, str, Optional[str]]:
"""Compute the billing project, data project, and dataset if available.
This function figure out the project id under which queries will run versus
the project of where the data live as well ... | python | {
"resource": ""
} |
q24976 | BigQueryCursor.fetchall | train | def fetchall(self):
"""Fetch all rows."""
result = self.query.result()
| python | {
"resource": ""
} |
q24977 | BigQueryCursor.columns | train | def columns(self):
"""Return the columns of the result set."""
| python | {
"resource": ""
} |
q24978 | BigQueryCursor.description | train | def description(self):
"""Get the fields of the result set's schema."""
| python | {
"resource": ""
} |
q24979 | execute_cast_simple_literal_to_timestamp | train | def execute_cast_simple_literal_to_timestamp(op, data, type, **kwargs):
"""Cast integer and strings to | python | {
"resource": ""
} |
q24980 | execute_cast_timestamp_to_timestamp | train | def execute_cast_timestamp_to_timestamp(op, data, type, **kwargs):
"""Cast timestamps to other timestamps including timezone if necessary"""
input_timezone = data.tz
| python | {
"resource": ""
} |
q24981 | wrap_case_result | train | def wrap_case_result(raw, expr):
"""Wrap a CASE statement result in a Series and handle returning scalars.
Parameters
----------
raw : ndarray[T]
The raw results of executing the ``CASE`` expression
expr : ValueExpr
The expression from the which `raw` was computed | python | {
"resource": ""
} |
q24982 | window | train | def window(preceding=None, following=None, group_by=None, order_by=None):
"""Create a window clause for use with window functions.
This ROW window clause aggregates adjacent rows based on differences in row
number.
All window frames / ranges are inclusive.
Parameters
----------
preceding ... | python | {
"resource": ""
} |
q24983 | range_window | train | def range_window(preceding=None, following=None, group_by=None, order_by=None):
"""Create a range-based window clause for use with window functions.
This RANGE window clause aggregates rows based upon differences in the
value of the order-by expression.
All window frames / ranges are inclusive.
P... | python | {
"resource": ""
} |
q24984 | cumulative_window | train | def cumulative_window(group_by=None, order_by=None):
"""Create a cumulative window for use with aggregate window functions.
All window frames / ranges are inclusive.
Parameters
----------
group_by : expressions, default None
Either specify here or with TableExpr.group_by
order_by : exp... | python | {
"resource": ""
} |
q24985 | trailing_window | train | def trailing_window(rows, group_by=None, order_by=None):
"""Create a trailing window for use with aggregate window functions.
Parameters
----------
rows : int
Number of trailing rows to include. 0 includes only the current row
group_by : expressions, default None
Either specify here... | python | {
"resource": ""
} |
q24986 | trailing_range_window | train | def trailing_range_window(preceding, order_by, group_by=None):
"""Create a trailing time window for use with aggregate window functions.
Parameters
----------
preceding : float or expression of intervals, i.e.
ibis.interval(days=1) + ibis.interval(hours=5)
order_by : expressions, default No... | python | {
"resource": ""
} |
q24987 | ImpalaDatabase.create_table | train | def create_table(self, table_name, obj=None, **kwargs):
"""
Dispatch to ImpalaClient.create_table. See that | python | {
"resource": ""
} |
q24988 | ImpalaConnection.close | train | def close(self):
"""
Close all open Impyla sessions
"""
for impyla_connection in self._connections:
| python | {
"resource": ""
} |
q24989 | ImpalaTable.compute_stats | train | def compute_stats(self, incremental=False):
"""
Invoke Impala COMPUTE STATS command to compute column, table, and
partition statistics.
See also ImpalaClient.compute_stats
"""
| python | {
"resource": ""
} |
q24990 | ImpalaTable.insert | train | def insert(
self,
obj=None,
overwrite=False,
partition=None,
values=None,
validate=True,
):
"""
Insert into Impala table. Wraps ImpalaClient.insert
Parameters
----------
obj : TableExpr or pandas DataFrame
overwrite : b... | python | {
"resource": ""
} |
q24991 | ImpalaTable.add_partition | train | def add_partition(self, spec, location=None):
"""
Add a new table partition, creating any new directories in HDFS if
necessary.
Partition parameters can be set in a single DDL statement, or you can
| python | {
"resource": ""
} |
q24992 | ImpalaTable.alter_partition | train | def alter_partition(
self,
spec,
location=None,
format=None,
tbl_properties=None,
serde_properties=None,
):
"""
Change setting and parameters of an existing partition
Parameters
----------
spec : dict or list
The part... | python | {
"resource": ""
} |
q24993 | ImpalaTable.drop_partition | train | def drop_partition(self, spec):
"""
Drop an existing table partition
"""
| python | {
"resource": ""
} |
q24994 | ImpalaClient.close | train | def close(self):
"""
Close Impala connection and drop any temporary objects
"""
for obj in self._temp_objects:
try:
| python | {
"resource": ""
} |
q24995 | ImpalaClient.create_database | train | def create_database(self, name, path=None, force=False):
"""
Create a new Impala database
Parameters
----------
name : string
Database name
path : string, default None
HDFS path where to store the database data; otherwise uses Impala
default... | python | {
"resource": ""
} |
q24996 | ImpalaClient.drop_database | train | def drop_database(self, name, force=False):
"""Drop an Impala database.
Parameters
----------
name : string
Database name
force : bool, default False
If False and there are any tables in this database, raises an
IntegrityError
"""
i... | python | {
"resource": ""
} |
q24997 | ImpalaClient.list_databases | train | def list_databases(self, like=None):
"""
List databases in the Impala cluster. Like the SHOW DATABASES command
in the impala-shell.
Parameters
----------
like : string, default None
e.g. 'foo*' to match all | python | {
"resource": ""
} |
q24998 | ImpalaClient.get_options | train | def get_options(self):
"""
Return current query options for the Impala session
"""
| python | {
"resource": ""
} |
q24999 | ImpalaClient.parquet_file | train | def parquet_file(
self,
hdfs_dir,
schema=None,
name=None,
database=None,
external=True,
like_file=None,
like_table=None,
persist=False,
):
"""
Make indicated parquet file in HDFS available as an Ibis table.
The table cr... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.