iridium_core 0.1.0

SQL Server-compatible Rust engine core for Iridium SQL
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use crate::ast::Expr;
use crate::catalog::Catalog;
use crate::error::DbError;
use crate::storage::Storage;
use crate::types::Value;

use super::super::clock::Clock;
use super::super::context::ExecutionContext;
use super::super::evaluator::eval_expr;
use super::super::model::ContextTable;

pub(crate) fn eval_coalesce(
    args: &[Expr],
    row: &[ContextTable],
    ctx: &mut ExecutionContext,
    catalog: &dyn Catalog,
    storage: &dyn Storage,
    clock: &dyn Clock,
) -> Result<Value, DbError> {
    if args.is_empty() {
        return Err(DbError::Execution(
            "COALESCE requires at least one argument".into(),
        ));
    }
    for arg in args {
        let val = eval_expr(arg, row, ctx, catalog, storage, clock)?;
        if !val.is_null() {
            return Ok(val);
        }
    }
    Ok(Value::Null)
}

pub(crate) fn eval_isnull(
    args: &[Expr],
    row: &[ContextTable],
    ctx: &mut ExecutionContext,
    catalog: &dyn Catalog,
    storage: &dyn Storage,
    clock: &dyn Clock,
) -> Result<Value, DbError> {
    if args.len() != 2 {
        return Err(DbError::Execution("ISNULL expects 2 arguments".into()));
    }
    let left = eval_expr(&args[0], row, ctx, catalog, storage, clock)?;
    if !left.is_null() {
        Ok(left)
    } else {
        eval_expr(&args[1], row, ctx, catalog, storage, clock)
    }
}

pub(crate) fn eval_iif(
    args: &[Expr],
    row: &[ContextTable],
    ctx: &mut ExecutionContext,
    catalog: &dyn Catalog,
    storage: &dyn Storage,
    clock: &dyn Clock,
) -> Result<Value, DbError> {
    if args.len() != 3 {
        return Err(DbError::Execution("IIF expects 3 arguments".into()));
    }
    let condition = eval_expr(&args[0], row, ctx, catalog, storage, clock)?;
    let is_true = match condition {
        Value::Bit(b) => b,
        Value::Null => false,
        Value::Int(v) => v != 0,
        Value::BigInt(v) => v != 0,
        Value::TinyInt(v) => v != 0,
        Value::SmallInt(v) => v != 0,
        _ => !condition.to_string_value().is_empty(),
    };
    if is_true {
        eval_expr(&args[1], row, ctx, catalog, storage, clock)
    } else {
        eval_expr(&args[2], row, ctx, catalog, storage, clock)
    }
}

pub(crate) fn eval_nullif(
    args: &[Expr],
    row: &[ContextTable],
    ctx: &mut ExecutionContext,
    catalog: &dyn Catalog,
    storage: &dyn Storage,
    clock: &dyn Clock,
) -> Result<Value, DbError> {
    if args.len() != 2 {
        return Err(DbError::Execution("NULLIF expects 2 arguments".into()));
    }
    let left = eval_expr(&args[0], row, ctx, catalog, storage, clock)?;
    let right = eval_expr(&args[1], row, ctx, catalog, storage, clock)?;
    if left == right {
        Ok(Value::Null)
    } else {
        Ok(left)
    }
}

pub(crate) fn eval_choose(
    args: &[Expr],
    row: &[ContextTable],
    ctx: &mut ExecutionContext,
    catalog: &dyn Catalog,
    storage: &dyn Storage,
    clock: &dyn Clock,
) -> Result<Value, DbError> {
    if args.len() < 2 {
        return Err(DbError::Execution(
            "CHOOSE expects at least 2 arguments".into(),
        ));
    }
    let index_val = eval_expr(&args[0], row, ctx, catalog, storage, clock)?;
    let idx = index_val.to_integer_i64().unwrap_or(0);
    if idx < 1 || idx as usize > args.len() - 1 {
        return Ok(Value::Null);
    }
    eval_expr(&args[idx as usize], row, ctx, catalog, storage, clock)
}