oxirs-core 0.2.4

Core RDF and SPARQL functionality for OxiRS - native Rust implementation with zero dependencies
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

//! Hash functions for SPARQL 1.2

use crate::model::{Literal, Term};
use crate::OxirsError;

/// SHA1 - Compute SHA-1 hash
pub(super) fn fn_sha1(args: &[Term]) -> Result<Term, OxirsError> {
    if args.len() != 1 {
        return Err(OxirsError::Query(
            "SHA1 requires exactly 1 argument".to_string(),
        ));
    }

    match &args[0] {
        Term::Literal(lit) => {
            use sha1::{Digest, Sha1};
            let mut hasher = Sha1::new();
            hasher.update(lit.value().as_bytes());
            let result = hasher.finalize();
            let hex = format!("{result:x}");
            Ok(Term::Literal(Literal::new(&hex)))
        }
        _ => Err(OxirsError::Query(
            "SHA1 requires string literal".to_string(),
        )),
    }
}

/// SHA256 - Compute SHA-256 hash
pub(super) fn fn_sha256(args: &[Term]) -> Result<Term, OxirsError> {
    if args.len() != 1 {
        return Err(OxirsError::Query(
            "SHA256 requires exactly 1 argument".to_string(),
        ));
    }

    match &args[0] {
        Term::Literal(lit) => {
            use sha2::{Digest, Sha256};
            let mut hasher = Sha256::new();
            hasher.update(lit.value().as_bytes());
            let result = hasher.finalize();
            let hex = format!("{result:x}");
            Ok(Term::Literal(Literal::new(&hex)))
        }
        _ => Err(OxirsError::Query(
            "SHA256 requires string literal".to_string(),
        )),
    }
}

/// SHA384 - Compute SHA-384 hash
pub(super) fn fn_sha384(args: &[Term]) -> Result<Term, OxirsError> {
    if args.len() != 1 {
        return Err(OxirsError::Query(
            "SHA384 requires exactly 1 argument".to_string(),
        ));
    }

    match &args[0] {
        Term::Literal(lit) => {
            use sha2::{Digest, Sha384};
            let mut hasher = Sha384::new();
            hasher.update(lit.value().as_bytes());
            let result = hasher.finalize();
            let hex = format!("{result:x}");
            Ok(Term::Literal(Literal::new(&hex)))
        }
        _ => Err(OxirsError::Query(
            "SHA384 requires string literal".to_string(),
        )),
    }
}

/// SHA512 - Compute SHA-512 hash
pub(super) fn fn_sha512(args: &[Term]) -> Result<Term, OxirsError> {
    if args.len() != 1 {
        return Err(OxirsError::Query(
            "SHA512 requires exactly 1 argument".to_string(),
        ));
    }

    match &args[0] {
        Term::Literal(lit) => {
            use sha2::{Digest, Sha512};
            let mut hasher = Sha512::new();
            hasher.update(lit.value().as_bytes());
            let result = hasher.finalize();
            let hex = format!("{result:x}");
            Ok(Term::Literal(Literal::new(&hex)))
        }
        _ => Err(OxirsError::Query(
            "SHA512 requires string literal".to_string(),
        )),
    }
}

/// MD5 - Compute MD5 hash
pub(super) fn fn_md5(args: &[Term]) -> Result<Term, OxirsError> {
    if args.len() != 1 {
        return Err(OxirsError::Query(
            "MD5 requires exactly 1 argument".to_string(),
        ));
    }

    match &args[0] {
        Term::Literal(lit) => {
            let mut hasher = md5::Context::new();
            hasher.consume(lit.value().as_bytes());
            let result = hasher.finalize();
            let hex = format!("{result:x}");
            Ok(Term::Literal(Literal::new(&hex)))
        }
        _ => Err(OxirsError::Query("MD5 requires string literal".to_string())),
    }
}