Time Functions

time::day()

The time::day() function extracts the day as a number from a datetime.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::day(dt);
assert_eq!(
    result.to_raw().build(),
    "time::day('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::day(rebirth_date);
assert_eq!(result.to_raw().build(), "time::day(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::day(param);
assert_eq!(result.to_raw().build(), "time::day($rebirth_date)");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::day(dt);
assert_eq!(
    result.to_raw().build(),
    "time::day('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::day(rebirth_date);
assert_eq!(result.to_raw().build(), "time::day(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::day(param);
assert_eq!(result.to_raw().build(), "time::day($rebirth_date)");
}

time::floor()

The time::floor() function rounds a datetime down by a specific duration.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let rebirth_date = Field::new("rebirth_date");
let duration = Field::new("duration");
let result = time::floor(rebirth_date, duration);

assert_eq!(
    result.to_raw().build(),
    "time::floor(rebirth_date, duration)"
);
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let rebirth_date = Field::new("rebirth_date");
let duration = Field::new("duration");
let result = time::floor(rebirth_date, duration);

assert_eq!(
    result.to_raw().

build(),
    "time::floor(rebirth_date, duration)"
);
}

time::format()

The time::format() function outputs a datetime according to a specific format.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);
let format_str = "'Year: 'yyyy-MM-dd";

let result = time::format(dt, format_str);
assert_eq!(
    result.to_raw().build(),
    "time::format('1970-01-01T00:01:01Z', 'Year: 'yyyy-MM-dd)"
);
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);
let format_str = "'Year: 'yyyy-MM-dd";

let result = time::format(dt, format_str);
assert_eq!(
    result.to_raw().build(),
    "time::format('1970-01-01T00:01:01Z', 'Year: 'yyyy-MM-dd)"
);
}

time::group()

The time::group() function groups a datetime by a particular time interval.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);
let interval = "month";

let result = time::group(dt, interval);
assert_eq!(
    result.to_raw().build(),
    "time::group('1970-01-01T00:01:01Z', 'month')"
);

let rebirth_date = Field::new("rebirth_date");
let interval_field = Field::new("interval");
let result = time::group(rebirth_date, interval_field);
assert_eq!(
    result.to_raw().build(),
    "time::group(rebirth_date, interval)"
);

let param = Param::new("rebirth_date");
let result = time::group(param, interval);
assert_eq!(
    result.to_raw().build(),
    "time::group($rebirth_date, 'month')"
);
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);
let interval = "month";

let result = time::group(dt, interval);
assert_eq!(
    result.to_raw().build(),
    "time::group('1970-01-01T00:01:01Z', 'month')"
);

let rebirth_date = Field::new("rebirth_date");
let interval_field = Field::new("interval");
let result = time::group(rebirth_date, interval_field);
assert_eq!(
    result.to_raw().build(),
    "time::group(rebirth_date, interval)"
);

let param = Param::new("rebirth_date");
let result = time::group(param, interval);
assert_eq!(
    result.to_raw().build(),
    "time::group($rebirth_date, 'month')"
);
}

time::hour()

The time::hour() function extracts the hour as a number

from a datetime.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::hour(dt);
assert_eq!(
    result.to_raw().build(),
    "time::hour('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::hour(rebirth_date);
assert_eq!(result.to_raw().build(), "time::hour(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::hour(param);
assert_eq!(result.to_raw().build(), "time::hour($rebirth_date)");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::hour(dt);
assert_eq!(
    result.to_raw().build(),
    "time::hour('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::hour(rebirth_date);
assert_eq!(result.to_raw().build(), "time::hour(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::hour(param);
assert_eq!(result.to_raw().build(), "time::hour($rebirth_date)");
}

time::minute()

The time::minute() function extracts the minutes as a number from a datetime.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::minute(dt);
assert_eq!(
    result.to_raw().build(),
    "time::minute('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::minute(rebirth_date);
assert_eq!(result.to_raw().build(), "time::minute(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::minute(param);
assert_eq!(result.to_raw().build(), "time::minute($rebirth_date)");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::minute(dt);
assert_eq!(
    result.to_raw().build(),
    "time::minute('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::minute(rebirth_date);
assert_eq!(result.to_raw().build(), "time::minute(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::minute(param);
assert_eq!(result.to_raw().build(), "time::minute($rebirth_date)");
}

time::month()

The time::month() function extracts the month as a number from a datetime.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::month(dt);
assert_eq!(
    result.to_raw().build(),
    "time::month('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::month(rebirth_date);
assert_eq!(result.to_raw().build(), "time::month(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::month(param);
assert_eq!(result.to_raw().build(), "time::month($rebirth_date)");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::month(dt);
assert_eq!(
    result.to_raw().build(),
    "time::month('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::month(rebirth_date);
assert_eq!(result.to_raw().build(), "time::month(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::month(param);
assert_eq!(result.to_raw().build(), "time::month($rebirth_date)");
}

time::nano()

The time::nano() function returns the number of nanoseconds since the UNIX epoch.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let result = time::nano();
assert_eq!(result.to_raw().build(), "time::nano()");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let result = time::nano();
assert_eq!(result.to_raw().build(), "time::nano()");
}

time::now()

The time::now() function returns the current datetime.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let result = time::now();
assert_eq!(result.to_raw().build(), "time::now()");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let result = time::now();
assert_eq!(result.to_raw().build(), "time::now()");
}

time::round()

The time::round() function rounds a datetime to the nearest multiple of a specific duration.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let rebirth_date = Field::new("rebirth_date");
let duration = Field::new("duration");
let result = time::round(rebirth_date, duration);

assert_eq!(
    result.to_raw().build(),
    "time::round(rebirth_date, duration)"
);
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let rebirth_date = Field::new("rebirth_date");
let duration = Field::new("duration");
let result = time::round(rebirth_date, duration);

assert_eq!(
    result.to_raw().build(),
    "time::round(rebirth_date, duration)"
);
}

time::second() </a

The time::second() function extracts the second as a number from a datetime.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::second(dt);
assert_eq!(
    result.to_raw().build(),
    "time::second('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::second(rebirth_date);
assert_eq!(result.to_raw().build(), "time::second(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::second(param);
assert_eq!(result.to_raw().build(), "time::second($rebirth_date)");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::second(dt);
assert_eq!(
    result.to_raw().build(),
    "time::second('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::second(rebirth_date);
assert_eq!(result.to_raw().build(), "time::second(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::second(param);
assert_eq!(result.to_raw().build(), "time::second($rebirth_date)");
}

time::timezone()

The time::timezone() function returns the current local timezone offset in hours.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let result = time::timezone();
assert_eq!(result.to_raw().build(), "time::timezone()");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let result = time::timezone();
assert_eq!(result.to_raw().build(), "time::timezone()");
}

time::unix()

The time::unix() function returns the number of seconds since the UNIX epoch.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let result = time::unix();
assert_eq!(result.to_raw().build(), "time::unix()");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let result = time::unix();
assert_eq!(result.to_raw().build(), "time::unix()");
}

time::wday()

The time::wday() function extracts the week day as a number from a datetime.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::wday(dt);
assert_eq!(
    result.to_raw().build(),
    "time::wday('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::wday(rebirth_date);
assert_eq!(result.to_raw().build(), "time::wday(rebirth_date)");



let param = Param::new("rebirth_date");
let result = time::wday(param);
assert_eq!(result.to_raw().build(), "time::wday($rebirth_date)");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::wday(dt);
assert_eq!(
    result.to_raw().build(),
    "time::wday('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::wday(rebirth_date);
assert_eq!(result.to_raw().build(), "time::wday(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::wday(param);
assert_eq!(result.to_raw().build(), "time::wday($rebirth_date)");
}

time::week()

The time::week() function extracts the week as a number from a datetime.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::week(dt);
assert_eq!(
    result.to_raw().build(),
    "time::week('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::week(rebirth_date);
assert_eq!(result.to_raw().build(), "time::week(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::week(param);
assert_eq!(result.to_raw().build(), "time::week($rebirth_date)");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::week(dt);
assert_eq!(
    result.to_raw().build(),
    "time::week('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::week(rebirth_date);
assert_eq!(result.to_raw().build(), "time::week(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::week(param);
assert_eq!(result.to_raw().build(), "time::week($rebirth_date)");
}

time::yday()

The time::yday() function extracts the yday as a number from a datetime.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::yday(dt);
assert_eq!(
    result.to_raw().build(),
    "time::yday('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::yday(rebirth_date);
assert_eq!(result.to_raw().build(), "

time::yday(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::yday(param);
assert_eq!(result.to_raw().build(), "time::yday($rebirth_date)");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::yday(dt);
assert_eq!(
    result.to_raw().build(),
    "time::yday('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::yday(rebirth_date);
assert_eq!(result.to_raw().build(), "time::yday(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::yday(param);
assert_eq!(result.to_raw().build(), "time::yday($rebirth_date)");
}

time::year()

The time::year() function extracts the year as a number from a datetime.

Usage:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::year(dt);
assert_eq!(
    result.to_raw().build(),
    "time::year('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::year(rebirth_date);
assert_eq!(result.to_raw().build(), "time::year(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::year(param);
assert_eq!(result.to_raw().build(), "time::year($rebirth_date)");
}

Example:

#![allow(unused)]
fn main() {
use surreal_orm::{*, functions::time};

let dt = chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(
    chrono::NaiveDateTime::from_timestamp_opt(61, 0).unwrap(),
    chrono::Utc,
);

let result = time::year(dt);
assert_eq!(
    result.to_raw().build(),
    "time::year('1970-01-01T00:01:01Z')"
);

let rebirth_date = Field::new("rebirth_date");
let result = time::year(rebirth_date);
assert_eq!(result.to_raw().build(), "time::year(rebirth_date)");

let param = Param::new("rebirth_date");
let result = time::year(param);
assert_eq!(result.to_raw().build(), "time::year($rebirth_date)");
}