Struct ExperimentChange 

pub struct ExperimentChange {
    pub id: i64,
    pub experiment: String,
    pub mutation: String,
    pub actor: Option<String>,
    pub changed_at: NaiveDateTime,
}

Fields

id: i64

experiment: String

mutation: String

actor: Option<String>

changed_at: NaiveDateTime

Implementations

impl ExperimentChange

pub const __AUTUMN_COLUMN_COUNT: usize = 5usize

impl ExperimentChange

pub fn factory() -> ExperimentChangeFactory

Create a factory builder for constructing [#name] instances.

Returns a [#factory_name] with all fields at their Default value. Override any subset with the fluent setter methods, then call build() for an in-memory instance or create(pool) to persist it.

impl ExperimentChange

pub fn preload() -> ExperimentChangePreload

Start building an eager-loading spec for this model’s associations. Pass the result to a #[repository] preload(...) call.

Trait Implementations

impl AsChangeset for ExperimentChange

type Target = table

The table which Self::Changeset will be updating

type Changeset = <(Grouped<Eq<experiment, <String as AsExpression<<experiment as Expression>::SqlType>>::Expression>>, Grouped<Eq<mutation, <String as AsExpression<<mutation as Expression>::SqlType>>::Expression>>, Option<Grouped<Eq<actor, <String as AsExpression<<actor as Expression>::SqlType>>::Expression>>>, Grouped<Eq<changed_at, <NaiveDateTime as AsExpression<<changed_at as Expression>::SqlType>>::Expression>>) as AsChangeset>::Changeset

The update statement this type represents

fn as_changeset(self) -> <Self as AsChangeset>::Changeset

Convert self into the actual update statement being executed

impl<'update> AsChangeset for &'update ExperimentChange

where (Eq<experiment, &'update String>, Eq<mutation, &'update String>, Option<Eq<actor, &'update String>>, Eq<changed_at, &'update NaiveDateTime>): AsChangeset,

type Target = table

The table which Self::Changeset will be updating

type Changeset = <(Grouped<Eq<experiment, <&'update String as AsExpression<<experiment as Expression>::SqlType>>::Expression>>, Grouped<Eq<mutation, <&'update String as AsExpression<<mutation as Expression>::SqlType>>::Expression>>, Option<Grouped<Eq<actor, <&'update String as AsExpression<<actor as Expression>::SqlType>>::Expression>>>, Grouped<Eq<changed_at, <&'update NaiveDateTime as AsExpression<<changed_at as Expression>::SqlType>>::Expression>>) as AsChangeset>::Changeset

The update statement this type represents

fn as_changeset(self) -> <Self as AsChangeset>::Changeset

Convert self into the actual update statement being executed

impl AutumnSearchableModel for ExperimentChange

const IS_SEARCHABLE: bool = false

const SEARCH_LANGUAGE: &'static str = "simple"

const SEARCH_FIELDS: &'static [(&'static str, char)]

impl Clone for ExperimentChange

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExperimentChange

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExperimentChange

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FormModel for ExperimentChange

fn form_fields() -> Vec<FormField>

The ordered list of fields form_for should render.

impl Insertable<table> for ExperimentChange

where i64: AsExpression<<id as Expression>::SqlType>, String: AsExpression<<experiment as Expression>::SqlType> + AsExpression<<mutation as Expression>::SqlType> + AsExpression<<actor as Expression>::SqlType>, NaiveDateTime: AsExpression<<changed_at as Expression>::SqlType>,

type Values = <(Option<Grouped<Eq<id, <i64 as AsExpression<<id as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<experiment, <String as AsExpression<<experiment as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<mutation, <String as AsExpression<<mutation as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<actor, <String as AsExpression<<actor as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<changed_at, <NaiveDateTime as AsExpression<<changed_at as Expression>::SqlType>>::Expression>>>) as Insertable<table>>::Values

The VALUES clause to insert these records

fn values( self, ) -> <(Option<Eq<id, i64>>, Option<Eq<experiment, String>>, Option<Eq<mutation, String>>, Option<Eq<actor, String>>, Option<Eq<changed_at, NaiveDateTime>>) as Insertable<table>>::Values

Construct Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values>

where T: Table, Self: Sized,

Insert self into a given table.

impl<'insert> Insertable<table> for &'insert ExperimentChange

where &'insert i64: AsExpression<<id as Expression>::SqlType>, &'insert String: AsExpression<<experiment as Expression>::SqlType> + AsExpression<<mutation as Expression>::SqlType> + AsExpression<<actor as Expression>::SqlType>, &'insert NaiveDateTime: AsExpression<<changed_at as Expression>::SqlType>,

type Values = <(Option<Grouped<Eq<id, <&'insert i64 as AsExpression<<id as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<experiment, <&'insert String as AsExpression<<experiment as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<mutation, <&'insert String as AsExpression<<mutation as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<actor, <&'insert String as AsExpression<<actor as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<changed_at, <&'insert NaiveDateTime as AsExpression<<changed_at as Expression>::SqlType>>::Expression>>>) as Insertable<table>>::Values

The VALUES clause to insert these records

fn values( self, ) -> <(Option<Eq<id, &'insert i64>>, Option<Eq<experiment, &'insert String>>, Option<Eq<mutation, &'insert String>>, Option<Eq<actor, &'insert String>>, Option<Eq<changed_at, &'insert NaiveDateTime>>) as Insertable<table>>::Values

Construct Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values>

where T: Table, Self: Sized,

Insert self into a given table.

impl ModelPrimaryKey for ExperimentChange

type IdType = i64

fn primary_key_value(&self) -> Self::IdType

impl ModelTenantIdMeta for ExperimentChange

const HAS_MANUAL_TENANT_ID: bool = false

True if the struct has a manual tenant_id field.

fn try_set_tenant_id(&mut self, _tenant_id: &str)

Sets the tenant ID field on the struct if it has one.

impl Normalize for ExperimentChange

fn normalize(&mut self)

Canonicalize every #[normalize] field in place.

impl NormalizedModel for ExperimentChange

fn normalize_lookup(column: &str, value: &str) -> Option<String>

The canonical form of value for column, or None if column is not a #[normalize] column on this model.

impl OpenApiSchema for ExperimentChange

fn schema_name() -> &'static str

Component schema name (appears under #/components/schemas/).

fn schema() -> Value

Produce the JSON schema for this type.

impl Preloadable for ExperimentChange

type Spec = ExperimentChangePreload

The builder describing which associations (and nested associations) to load. #[model] generates a {Model}Preload type; association-free models use super::NoPreload.

fn load_associations<'__a>( records: &'__a mut [Preloaded<Self>], spec: &'__a Self::Spec, conn: &'__a mut RuntimeConnection, ) -> PreloadFuture<'__a>

Load every association named in spec for records, issuing at most one batched query per association level, then recurse into any nested specs. All queries run on conn so preloads share the read role of the parent query.

impl<__DB: Backend, __ST0, __ST1, __ST2, __ST3, __ST4> Queryable<(__ST0, __ST1, __ST2, __ST3, __ST4), __DB> for ExperimentChange

where (i64, String, String, Option<String>, NaiveDateTime): FromStaticSqlRow<(__ST0, __ST1, __ST2, __ST3, __ST4), __DB>,

type Row = (i64, String, String, Option<String>, NaiveDateTime)

The Rust type you’d like to map from.

fn build( row: (i64, String, String, Option<String>, NaiveDateTime), ) -> Result<Self>

Construct an instance of this type

impl<__DB: Backend> Selectable<__DB> for ExperimentChange

type SelectExpression = (id, experiment, mutation, actor, changed_at)

The expression you’d like to select.

fn construct_selection() -> Self::SelectExpression

Construct an instance of the expression

impl Serialize for ExperimentChange

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl UndecoratedInsertRecord<table> for ExperimentChange