Struct Task

pub struct Task { /* private fields */ }

The task model.

Trait Implementations

impl Clone for Task

fn clone(&self) -> Task

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Task

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DecodeRow<SqliteRow> for Task

type Error = Error

The error type.

fn decode_row(row: &DatabaseRow) -> Result<Self, Self::Error>

Decodes a row and attempts to create an instance of Self.

impl Default for Task

fn default() -> Task

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Task

where Task: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Entity for Task

const PRIMARY_KEY: Self::Column = {transmute(0x00): <task::Task as zino_orm::Entity>::Column}

The primary key column.

type Column = TaskColumn

The column type.

fn format_column(col: &Self::Column) -> String

Formats the column name.

impl Model for Task

const MODEL_NAME: &'static str = "task"

Model name.

fn new() -> Self

Creates a new instance.

fn read_map(&mut self, data: &Map) -> Validation

Updates the model using the json object and returns the validation result.

const ITEM_NAME: (&'static str, &'static str) = _

Data item name.

fn model_name() -> &'static str

Returns the model name.

fn try_from_map(data: Map<String, Value>) -> Result<Self, Error>

Attempts to construct a model from a json object.

fn try_from_avro_record(data: Vec<(String, Value)>) -> Result<Self, Error>

Attempts to construct a model from an Avro record.

fn into_map(self) -> Map<String, Value>

Consumes the model and returns as a json object.

fn into_avro_record(self) -> Vec<(String, Value)>

Consumes the model and returns as an Avro record.

fn data_item(value: impl Into<Value>) -> Map<String, Value>

Constructs an instance of Map for the data item.

fn data_items<T>(values: Vec<T>) -> Map<String, Value>

where T: Into<Value>,

Constructs an instance of Map for the data items.

impl ModelAccessor<Uuid> for Task

fn id(&self) -> &Uuid

Returns the id field, i.e. the primary key.

fn name(&self) -> &str

Returns the name field.

fn namespace(&self) -> &str

Returns the namespace field.

fn visibility(&self) -> &str

Returns the visibility field.

fn status(&self) -> &str

Returns the status field.

fn description(&self) -> &str

Returns the description field.

fn extra(&self) -> Option<&Map>

Returns the extra field.

fn created_at(&self) -> DateTime

Returns the created_at field.

fn updated_at(&self) -> DateTime

Returns the updated_at field.

fn version(&self) -> u64

Returns the version field.

fn edition(&self) -> u32

Returns the edition field.

fn snapshot(&self) -> ZinoMap

Returns a snapshot of the model.

fn soft_delete_mutation(&self) -> Mutation

Constructs a Mutation for logically deleting the model.

fn lock_mutation(&self) -> Mutation

Constructs a Mutation for locking the model.

fn archive_mutation(&self) -> Mutation

Constructs a Mutation for archiving the model.

fn default_snapshot_query() -> Query

Constructs a default snapshot Query for the model.

fn default_list_query() -> Query

Constructs a default list Query for the model.

async fn check_constraints(&self) -> Result<ZinoValidation, ZinoError>

Checks the constraints for the model.

async fn fetch(query: &Query) -> Result<Vec<ZinoMap>, ZinoError>

Fetches the data of models seleted by the Query.

async fn fetch_by_id(id: &Uuid) -> Result<ZinoMap, ZinoError>

Fetches the data of a model seleted by the primary key.

async fn random_associations() -> Result<ZinoMap, ZinoError>

Generates random associations for the model.

fn deleted_at(&self) -> Option<DateTime>

Returns the deleted_at field.

fn has_name(&self) -> bool

Returns true if the name is nonempty.

fn has_namespace_prefix(&self, namespace: &str) -> bool

Returns true if self has the namespace prefix.

fn has_namespace_suffix(&self, namespace: &str) -> bool

Returns true if self has the namespace suffix.

fn has_visibility(&self, visibility: &str) -> bool

Returns true if the model has the specific visibility.

fn is_public(&self) -> bool

Returns true if the visibility is Public.

fn is_internal(&self) -> bool

Returns true if the visibility is Internal.

fn is_protected(&self) -> bool

Returns true if the visibility is Protected.

fn is_private(&self) -> bool

Returns true if the visibility is Private.

fn has_status(&self, status: &str) -> bool

Returns true if the model has the specific status.

fn is_active(&self) -> bool

Returns true if the status is Active.

fn is_inactive(&self) -> bool

Returns true if the status is Inactive.

fn is_locked(&self) -> bool

Returns true if the status is Locked.

fn is_deleted(&self) -> bool

Returns true if the status is Deleted.

fn is_archived(&self) -> bool

Returns true if the status is Archived.

fn has_description(&self) -> bool

Returns true if the description is nonempty.

fn get_extra_value(&self, key: &str) -> Option<&Value>

Returns a reference to the value corresponding to the key in extra.

fn next_version(&self) -> u64

Returns the next version for the model.

fn current_version_filters(&self) -> Map<String, Value>

Constructs the query filters for the model of the current version.

fn current_version_query(&self) -> Query

Constructs the Query for the model of the current version.

fn next_version_filters(&self) -> Map<String, Value>

Constructs the query filters for the model of the next version.

fn next_version_updates(&self) -> Map<String, Value>

Constructs the mutation updates for the model of the next version.

fn next_version_mutation(&self, updates: &mut Map<String, Value>) -> Mutation

Constructs the Mutation for the model of the next version.

fn next_edition(&self) -> u32

Returns the next edition for the model.

fn current_edition_filters(&self) -> Map<String, Value>

Constructs the query filters for the model of the current edition.

fn current_edition_query(&self) -> Query

Constructs the Query for the model of the current edition.

fn next_edition_filters(&self) -> Map<String, Value>

Constructs the query filters for the model of the next edition.

fn next_edition_updates(&self) -> Map<String, Value>

Constructs the mutation updates for the model of the next edition.

fn next_edition_mutation(&self, updates: &mut Map<String, Value>) -> Mutation

Constructs the Mutation for the model of the next edition.

async fn soft_delete_by_id(id: &K) -> Result<(), Error>

Deletes a model of the primary key by setting the status as Deleted.

async fn lock_by_id(id: &K) -> Result<(), Error>

Locks a model of the primary key by setting the status as Locked.

async fn archive_by_id(id: &K) -> Result<(), Error>

Archives a model of the primary key by setting the status as Archived.

async fn mutate_by_id( id: &K, data: &mut Map<String, Value>, extension: Option<Self::Extension>, ) -> Result<(Validation, Self), Error>

Mutates a model of the primary key with the JSON data and the optional extension.

async fn mock() -> Result<(Validation, Self), Error>

Attempts to generate a mocked model.

impl ModelHooks for Task

type Data = ()

Model data.

type Extension = UserSession<Uuid>

Extension data.

async fn after_extract(&mut self, session: Self::Extension) -> Result<(), Error>

A hook running after extracting the model data.

async fn before_validation( data: &mut Map, extension: Option<&Self::Extension>, ) -> Result<(), Error>

A hook running before validating the model data.

async fn before_extract() -> Result<(), Error>

A hook running before extracting the model data.

async fn after_validation( &mut self, _model: &mut Map<String, Value>, ) -> Result<(), Error>

A hook running after validating the model data.

async fn before_create_table() -> Result<(), Error>

A hook running before creating the table.

async fn after_create_table() -> Result<(), Error>

A hook running after creating the table.

async fn before_scan(query: &str) -> Result<QueryContext, Error>

A hook running before scanning the table.

async fn after_scan(ctx: &QueryContext) -> Result<(), Error>

A hook running after scanning the table.

async fn before_insert_check( &mut self, _extension: Option<&Self::Extension>, ) -> Result<(), Error>

A hook running before checking the constraints when inserting a model into the table.

async fn before_insert(&mut self) -> Result<Self::Data, Error>

A hook running before inserting a model into the table.

async fn after_insert(ctx: &QueryContext, data: Self::Data) -> Result<(), Error>

A hook running after inserting a model into the table.

async fn before_soft_delete(&mut self) -> Result<Self::Data, Error>

A hook running before logically deleting a model from the table.

async fn after_soft_delete( ctx: &QueryContext, data: Self::Data, ) -> Result<(), Error>

A hook running after logically deleting a model from the table.

async fn before_lock(&mut self) -> Result<Self::Data, Error>

A hook running before locking a model in the table.

async fn after_lock(ctx: &QueryContext, data: Self::Data) -> Result<(), Error>

A hook running after locking a model in the table.

async fn before_archive(&mut self) -> Result<Self::Data, Error>

A hook running before archiving a model in the table.

async fn after_archive( ctx: &QueryContext, data: Self::Data, ) -> Result<(), Error>

A hook running after archiving a model in the table.

async fn before_update(&mut self) -> Result<Self::Data, Error>

A hook running before updating a model in the table.

async fn after_update(ctx: &QueryContext, data: Self::Data) -> Result<(), Error>

A hook running after updating a model in the table.

async fn before_upsert(&mut self) -> Result<Self::Data, Error>

A hook running before updating or inserting a model into the table.

async fn after_upsert(ctx: &QueryContext, data: Self::Data) -> Result<(), Error>

A hook running after updating or inserting a model into the table.

async fn before_save(&mut self) -> Result<Self::Data, Error>

A hook running before saving a model into the table.

async fn after_save(ctx: &QueryContext, _data: Self::Data) -> Result<(), Error>

A hook running after saving a model into the table.

async fn before_delete(&mut self) -> Result<Self::Data, Error>

A hook running before deleting a model from the table.

async fn after_delete( self, ctx: &QueryContext, _data: Self::Data, ) -> Result<(), Error>

A hook running after deleting a model from the table.

async fn before_count(_query: &Query) -> Result<(), Error>

A hook running before counting the models in the table.

async fn after_count(ctx: &QueryContext) -> Result<(), Error>

A hook running after counting the models in the table.

async fn before_aggregate(_query: &Query) -> Result<(), Error>

A hook running before aggregating the models in the table.

async fn after_aggregate(ctx: &QueryContext) -> Result<(), Error>

A hook running after aggregating the models in the table.

async fn before_query(_query: &Query) -> Result<(), Error>

A hook running before selecting the models with a Query from the table.

async fn after_query(ctx: &QueryContext) -> Result<(), Error>

A hook running after selecting the models with a Query from the table.

async fn before_mutation( _query: &Query, _mutation: &mut Mutation, ) -> Result<(), Error>

A hook running before updating the models with a Mutation in the table.

async fn after_mutation(ctx: &QueryContext) -> Result<(), Error>

A hook running after updating the models with a Mutation in the table.

async fn before_list( _query: &mut Query, _extension: Option<&Self::Extension>, ) -> Result<(), Error>

A hook running before listing the models with a Query from the table.

async fn before_batch_delete( _query: &mut Query, _extension: Option<&Self::Extension>, ) -> Result<(), Error>

A hook running before batch deleting the models with a Query from the table.

async fn after_decode(_model: &mut Map<String, Value>) -> Result<(), Error>

A hook running after decoding the model as a Map.

async fn before_respond( _model: &mut Map<String, Value>, _extension: Option<&Self::Extension>, ) -> Result<(), Error>

A hook running before returning the model data as a HTTP response.

async fn before_mock() -> Result<Map<String, Value>, Error>

A hook running before mocking the model data.

async fn after_mock(&mut self) -> Result<(), Error>

A hook running after mocking the model data.

impl PartialEq for Task

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Schema for Task

const PRIMARY_KEY_NAME: &'static str = "id"

Primary key name.

const READER_NAME: &'static str = "main"

Reader name.

const WRITER_NAME: &'static str = "main"

Writer name.

const TABLE_NAME: Option<&'static str> = None

Optional custom table name.

type PrimaryKey = Uuid

Primary key.

fn primary_key(&self) -> &Self::PrimaryKey

Returns the primary key.

fn primary_key_value(&self) -> JsonValue

Returns the primary key as a JSON value.

fn primary_key_column() -> &'static Column<'static>

Returns the primary key column.

fn schema() -> &'static Schema

Returns a reference to the Avro schema.

fn columns() -> &'static [Column<'static>]

Returns a reference to the columns.

fn fields() -> &'static [&'static str]

Returns a reference to the column fields.

fn read_only_fields() -> &'static [&'static str]

Returns a reference to the read-only column fields.

fn write_only_fields() -> &'static [&'static str]

Returns a reference to the write-only column fields.

async fn acquire_reader() -> Result<&'static ConnectionPool, ZinoError>

Retrieves a connection pool for the model reader.

async fn acquire_writer() -> Result<&'static ConnectionPool, ZinoError>

Retrieves a connection pool for the model writer.

fn table_name() -> &'static str

Returns the table name.

fn model_namespace() -> &'static str

Returns the model namespace.

fn driver_name() -> &'static str

Returns the driver name.

fn table_prefix() -> &'static str

Returns the prefix for the table name.

fn namespace_prefix() -> &'static str

Returns the prefix for the model namespace.

fn get_column(key: &str) -> Option<&Column<'static>>

Gets a column for the field.

fn get_writable_column(key: &str) -> Option<&Column<'static>>

Gets a column for the field if it is writable.

fn has_column(key: &str) -> bool

Returns true if the model has a column for the specific field.

fn default_query() -> Query

Constructs a default Query for the model.

fn default_mutation() -> Mutation

Constructs a default Mutation for the model.

fn init_reader() -> Result<&'static ConnectionPool, Error>

Initializes the model reader.

fn init_writer() -> Result<&'static ConnectionPool, Error>

Initializes the model writer.

async fn create_table() -> Result<(), Error>

Creates a database table for the model.

async fn synchronize_schema() -> Result<(), Error>

Synchronizes the table schema for the model.

async fn create_indexes() -> Result<u64, Error>

Creates indexes for the model.

async fn prepare_insert(self) -> Result<QueryContext, Error>

Prepares the SQL to insert the model into the table.

async fn insert(self) -> Result<QueryContext, Error>

Inserts the model into the table.

async fn prepare_insert_many(models: Vec<Self>) -> Result<QueryContext, Error>

Prepares the SQL to insert many models into the table.

async fn insert_many(models: Vec<Self>) -> Result<QueryContext, Error>

Inserts many models into the table.

async fn prepare_insert_from_subquery<C, E>( columns: &[C], subquery: QueryBuilder<E>, ) -> Result<QueryContext, Error>

where C: AsRef<str>, E: Entity + Schema,

Prepares the SQL to insert models selected by a subquery.

async fn insert_from_subquery<C, E>( columns: &[C], subquery: QueryBuilder<E>, ) -> Result<QueryContext, Error>

where C: AsRef<str>, E: Entity + Schema,

Inserts the models selected by a subquery.

async fn prepare_update(self) -> Result<QueryContext, Error>

Prepares the SQL to update the model in the table.

async fn update(self) -> Result<QueryContext, Error>

Updates the model in the table.

async fn prepare_update_partial<C>( self, columns: &[C], ) -> Result<QueryContext, Error>

where C: AsRef<str>,

Prepares the SQL to update the model for partial columns in the table.

async fn update_partial<C>(self, columns: &[C]) -> Result<QueryContext, Error>

where C: AsRef<str>,

Updates the model for partial columns in the table.

async fn prepare_update_one( query: &Query, mutation: &mut Mutation, ) -> Result<QueryContext, Error>

Prepares the SQL to update at most one model selected by the query in the table.

async fn update_one( query: &Query, mutation: &mut Mutation, ) -> Result<QueryContext, Error>

Updates at most one model selected by the query in the table.

async fn prepare_update_many( query: &Query, mutation: &mut Mutation, ) -> Result<QueryContext, Error>

Prepares the SQL to update many models selected by the query in the table.

async fn update_many( query: &Query, mutation: &mut Mutation, ) -> Result<QueryContext, Error>

Updates many models selected by the query in the table.

async fn prepare_upsert(self) -> Result<QueryContext, Error>

Prepares the SQL to update or insert the model into the table.

async fn upsert(self) -> Result<QueryContext, Error>

Updates or inserts the model into the table.

async fn prepare_delete() -> Result<QueryContext, Error>

Prepares the SQL to delete the model in the table.

async fn delete(self) -> Result<QueryContext, Error>

Deletes the model in the table.

async fn prepare_delete_one(query: &Query) -> Result<QueryContext, Error>

Prepares the SQL to delete at most one model selected by the query in the table.

async fn delete_one(query: &Query) -> Result<QueryContext, Error>

Deletes at most one model selected by the query in the table.

async fn prepare_delete_many(query: &Query) -> Result<QueryContext, Error>

Prepares the SQL to delete many models selected by the query in the table.

async fn delete_many(query: &Query) -> Result<QueryContext, Error>

Deletes many models selected by the query in the table.

async fn prepare_delete_by_subquery<C, E>( columns: &[C], subquery: QueryBuilder<E>, ) -> Result<QueryContext, Error>

where C: AsRef<str>, E: Entity + Schema,

Prepares the SQL to delete models selected by a subquery.

async fn delete_by_subquery<C, E>( columns: &[C], subquery: QueryBuilder<E>, ) -> Result<QueryContext, Error>

where C: AsRef<str>, E: Entity + Schema,

Deletes the models selected by a subquery.

async fn find<T>(query: &Query) -> Result<Vec<T>, Error>

where T: DecodeRow<SqliteRow, Error = Error>,

Finds a list of models selected by the query in the table, and decodes it as Vec<T>.

async fn find_as<T>(query: &Query) -> Result<Vec<T>, Error>

where T: DeserializeOwned,

Finds a list of models selected by the query in the table, and parses it as Vec<T>.

async fn find_one<T>(query: &Query) -> Result<Option<T>, Error>

where T: DecodeRow<SqliteRow, Error = Error>,

Finds one model selected by the query in the table, and decodes it as an instance of type T.

async fn find_one_as<T>(query: &Query) -> Result<Option<T>, Error>

where T: DeserializeOwned,

Finds one model selected by the query in the table, and parses it as an instance of type T.

async fn populate<C>( query: &mut Query, data: &mut Vec<Map<String, Value>>, columns: &[C], ) -> Result<u64, Error>

where C: AsRef<str>,

Populates the related data in the corresponding columns for Vec<Map> using a merged select on the primary key, which solves the N+1 problem.

async fn populate_one<C>( query: &mut Query, data: &mut Map<String, Value>, columns: &[C], ) -> Result<(), Error>

where C: AsRef<str>,

Populates the related data in the corresponding columns for Map using a merged select on the primary key, which solves the N+1 problem.

async fn lookup<M, T>( query: &Query, join_on: &JoinOn<Self, M>, ) -> Result<Vec<T>, Error>

where M: Schema, T: DecodeRow<SqliteRow, Error = Error>,

Performs a join to another table to filter rows in the “joined” table, and decodes it as Vec<T>.

async fn lookup_as<M, T>( query: &Query, join_on: &JoinOn<Self, M>, ) -> Result<Vec<T>, Error>

where M: Schema, T: DeserializeOwned,

Performs a join to another table to filter rows in the “joined” table, and parses it as Vec<T>.

async fn exists(query: &Query) -> Result<bool, Error>

Checks whether there is a model selected by the query in the table.

async fn count(query: &Query) -> Result<u64, Error>

Counts the number of rows selected by the query in the table.

async fn count_many<C, T>( query: &Query, columns: &[(C, bool)], ) -> Result<T, Error>

where C: AsRef<str>, T: DecodeRow<SqliteRow, Error = Error>,

Counts the number of rows selected by the query in the table. The boolean value determines whether it only counts distinct values or not.

async fn count_many_as<C, T>( query: &Query, columns: &[(C, bool)], ) -> Result<T, Error>

where C: AsRef<str>, T: DeserializeOwned,

Counts the number of rows selected by the query in the table, and parses it as an instance of type T.

async fn aggregate<T>(query: &Query) -> Result<Vec<T>, Error>

where T: DecodeRow<SqliteRow, Error = Error>,

Aggregates the rows selected by the query in the table.

async fn aggregate_as<T>(query: &Query) -> Result<Vec<T>, Error>

where T: DeserializeOwned,

Aggregates the rows selected by the query in the table, and parses it as an instance of type T.

async fn execute( query: &str, params: Option<&Map<String, Value>>, ) -> Result<QueryContext, Error>

Executes the query in the table, and returns the total number of rows affected.

async fn query<T>( query: &str, params: Option<&Map<String, Value>>, ) -> Result<Vec<T>, Error>

where T: DecodeRow<SqliteRow, Error = Error>,

Executes the query in the table, and decodes it as Vec<T>.

async fn query_as<T>( query: &str, params: Option<&Map<String, Value>>, ) -> Result<Vec<T>, Error>

where T: DeserializeOwned,

Executes the query in the table, and parses it as Vec<T>.

async fn query_one<T>( query: &str, params: Option<&Map<String, Value>>, ) -> Result<Option<T>, Error>

where T: DecodeRow<SqliteRow, Error = Error>,

Executes the query in the table, and decodes it as an instance of type T.

async fn query_one_as<T>( query: &str, params: Option<&Map<String, Value>>, ) -> Result<Option<T>, Error>

where T: DeserializeOwned,

Executes the query in the table, and parses it as an instance of type T.

async fn prepare_delete_by_id() -> Result<QueryContext, Error>

Prepares the SQL to delete a model selected by the primary key in the table.

async fn delete_by_id( primary_key: &Self::PrimaryKey, ) -> Result<QueryContext, Error>

Deletes a model selected by the primary key in the table.

async fn prepare_update_by_id( mutation: &mut Mutation, ) -> Result<QueryContext, Error>

Prepares the SQL to update a model selected by the primary key in the table.

async fn update_by_id<T>( primary_key: &Self::PrimaryKey, mutation: &mut Mutation, ) -> Result<Option<T>, Error>

where T: DecodeRow<SqliteRow, Error = Error>,

Updates a model selected by the primary key in the table, and decodes it as an instance of type T.

async fn find_by_id<T>( primary_key: &Self::PrimaryKey, ) -> Result<Option<T>, Error>

where T: DecodeRow<SqliteRow, Error = Error>,

Finds a model selected by the primary key in the table, and decodes it as an instance of type T.

async fn try_get_model(primary_key: &Self::PrimaryKey) -> Result<Self, Error>

Finds a model selected by the primary key in the table, and parses it as Self.

async fn sample(size: usize) -> Result<Vec<Value>, Error>

Randomly selects the specified number of models from the table and returns a list of the primary key values.

async fn filter<T>(primary_key_values: Vec<T>) -> Result<Vec<Value>, Error>

where T: IntoSqlValue,

Filters the values of the primary key.

async fn is_unique_on<C, T>(&self, columns: Vec<(C, T)>) -> Result<bool, Error>

where C: AsRef<str>, T: IntoSqlValue,

Returns true if the model is unique on the column values.

impl Serialize for Task

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Task