GeezerVison is showing docs.rs — ViewConfigUpdate in perspective_python - Rust Struct ViewConfigUpdate Source pub struct ViewConfigUpdate {
pub group_by: Option<Vec<String>>,
pub split_by: Option<Vec<String>>,
pub columns: Option<Vec<Option<String>>>,
pub filter: Option<Vec<Filter>>,
pub sort: Option<Vec<Sort>>,
pub expressions: Option<Expressions>,
pub windows: Option<Windows>,
pub aggregates: Option<HashMap<String, Aggregate>>,
pub group_by_depth: Option<u32>,
pub filter_op: Option<FilterReducer>,
pub group_rollup_mode: Option<GroupRollupMode>,
pub split_rollup_mode: Option<SplitRollupMode>,
}
Fields§§group_by: Option<Vec<String>>A group by groups the dataset by the unique values of each column used
as a group by - a close analogue in SQL to the GROUP BY statement.
The underlying dataset is aggregated to show the values belonging to
each group, and a total row is calculated for each group, showing
the currently selected aggregated value (e.g. sum) of the column.
Group by are useful for hierarchies, categorizing data and
attributing values, i.e. showing the number of units sold based on
State and City. In Perspective, group by are represented as an array
of string column names to pivot, are applied in the order provided;
For example, a group by of ["State", "City", "Postal Code"] shows
the values for each Postal Code, which are grouped by City,
which are in turn grouped by State.
split_by: Option<Vec<String>>A split by splits the dataset by the unique values of each column used
as a split by. The underlying dataset is not aggregated, and a new
column is created for each unique value of the split by. Each newly
created column contains the parts of the dataset that correspond to
the column header, i.e. a View that has ["State"] as its split
by will have a new column for each state. In Perspective, Split By
are represented as an array of string column names to pivot.
columns: Option<Vec<Option<String>>>The columns property specifies which columns should be included in the
crate::View’s output. This allows users to show or hide a specific
subset of columns, as well as control the order in which columns
appear to the user. This is represented in Perspective as an array
of string column names.
filter: Option<Vec<Filter>>The filter property specifies columns on which the query can be
filtered, returning rows that pass the specified filter condition.
This is analogous to the WHERE clause in SQL. There is no limit on
the number of columns where filter is applied, but the resulting
dataset is one that passes all the filter conditions, i.e. the
filters are joined with an AND condition.
Perspective represents filter as an array of arrays, with the values
of each inner array being a string column name, a string filter
operator, and a filter operand in the type of the column.
sort: Option<Vec<Sort>>The sort property specifies columns on which the query should be
sorted, analogous to ORDER BY in SQL. A column can be sorted
regardless of its data type, and sorts can be applied in ascending
or descending order. Perspective represents sort as an array of
arrays, with the values of each inner array being a string column
name and a string sort direction. When column-pivots are applied,
the additional sort directions "col asc" and "col desc" will
determine the order of pivot columns groups.
sort is the ONLY thing that orders a View’s rows — without it
they keep the Table’s natural (insertion) order, which any
consumer reading rows sequentially will reflect. Not to be
confused with a window column’s order_by, which orders rows
WITHIN a window frame and does not reorder the View.
expressions: Option<Expressions>The expressions property specifies new columns in Perspective that
are created using existing column values or arbitary scalar values
defined within the expression. In <perspective-viewer>,
expressions are added using the “New Column” button in the side
panel.
windows: Option<Windows>The windows property declares ordered, partitioned rolling
computations (moving aggregates, cumulative sums) as new columns
keyed by output alias ({"name": {...spec}}, symmetric with
expressions), analogous to SQL window functions. See
crate::config::WindowSpec.
aggregates: Option<HashMap<String, Aggregate>>Aggregates perform a calculation over an entire column, and are
displayed when one or more Group By are applied to the
View. Aggregates can be specified by the user, or Perspective will
use the following sensible default aggregates based on column type:
- “sum” for
integer and float columns
- “count” for all other columns
Perspective provides a selection of aggregate functions that can be
applied to columns in the View constructor using a dictionary of
column name to aggregate function name.
An aggregate also determines the column’s RESULT TYPE, which need
not match the input: "count" yields an integer whatever it
counts, so a date column left on the default "count" is an
integer in the resulting View — no longer a date. Set an
aggregate that preserves the type (e.g. "any", "last") when
the original type matters, such as a date used as a chart axis.
group_by_depth: Option<u32>§filter_op: Option<FilterReducer>§group_rollup_mode: Option<GroupRollupMode>§split_rollup_mode: Option<SplitRollupMode>Trait Implementations§
Performs copy-assignment from source. Read more
Formats the value using the given formatter. Read more
Returns the “default value” for a type. Read more
Deserialize this value from the given Serde deserializer. Read more
Converts to this type from the input type.
Converts to this type from the input type.
Serialize this value into the given Serde serializer. Read more
If this type does not have generic parameters, then WithoutGenerics should just be Self.
If the type does have generic parameters, then all generic parameters must be replaced with
a dummy type, e.g ts_rs::Dummy or ().
The only requirement for these dummy types is that EXPORT_TO must be None. Read more
If the implementing type is std::option::Option<T>, then this associated type is set to T.
All other implementations of TS should set this type to Self instead.
Identifier of this type, excluding generic parameters.
Name of this type in TypeScript, including generic parameters
Declaration of this type using the supplied generic arguments.
The resulting TypeScript definition will not be generic. For that, see TS::decl().
If this type is not generic, then this function is equivalent to TS::decl().
Declaration of this type, e.g. type User = { user_id: number, ... }.
This function will panic if the type has no declaration. Read more
Formats this types definition in TypeScript, e.g { user_id: number }.
This function will panic if the type cannot be inlined.
Flatten a type declaration.
This function will panic if the type cannot be flattened.
Iterates over all type parameters of this type.
Returns the output path to where T should be exported.
The returned path does not include the base directory from TS_RS_EXPORT_DIR. Read more
Iterates over all dependency of this type.
JSDoc comment to describe this type in TypeScript - when TS is derived, docs are
automatically read from your doc comments or #[doc = ".."] attributes
Resolves all dependencies of this type recursively.
Manually export this type to the filesystem.
To export this type together with all of its dependencies, use TS::export_all. Read more
Manually export this type to the filesystem, together with all of its dependencies.
To export only this type, without its dependencies, use TS::export. Read more
Manually export this type into the given directory, together with all of its dependencies.
To export only this type, without its dependencies, use TS::export. Read more
Manually generate bindings for this type, returning a String.
This function does not format the output, even if the format feature is enabled. Read more
Returns the output path to where T should be exported. Read moreAuto Trait Implementations§Blanket Implementations§
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more
🔬This is a nightly-only experimental API. (clone_to_uninit) Performs copy-assignment from self to dest. Read more
Returns the argument unchanged.
Instruments this type with the provided Span, returning an
Instrumented wrapper. Read more
Calls U::from(self).
That is, this conversion is whatever the implementation of
From<T> for U chooses to do.
The resulting type after obtaining ownership.
Creates owned data from borrowed data, usually by cloning. Read more
Uses borrowed data to replace owned data, usually by cloning. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.
|