qlue-ls 3.2.1

A language server for SPARQL
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

use crate::server::{
    Server,
    lsp::{
        ExecuteOperationErrorData, ExecuteOperationRequest, ExecuteOperationResponse,
        ExecuteOperationResponseResult, errors::LSPError,
    },
    message_handler::execute::utils::get_timestamp,
    sparql_operations::{SparqlRequestError, execute_update},
};
use futures::lock::Mutex;
use std::rc::Rc;

pub(super) async fn handle_execute_update_request(
    server_rc: Rc<Mutex<Server>>,
    request: ExecuteOperationRequest,
    url: String,
    query: String,
) -> Result<(), LSPError> {
    let start_time = get_timestamp();
    let update_result = match execute_update(
        server_rc.clone(),
        &url,
        &query,
        request.params.query_id.as_ref().map(|s| s.as_ref()),
        request.params.access_token.as_ref().map(|s| s.as_ref()),
    )
    .await
    {
        Ok(res) => res,
        Err(SparqlRequestError::QLeverException(exception)) => {
            return server_rc
                .lock()
                .await
                .send_message(ExecuteOperationResponse::error(
                    request.get_id(),
                    ExecuteOperationErrorData::QLeverException(exception),
                ));
        }
        Err(SparqlRequestError::Connection(error)) => {
            return server_rc
                .lock()
                .await
                .send_message(ExecuteOperationResponse::error(
                    request.get_id(),
                    ExecuteOperationErrorData::Connection(error),
                ));
        }
        Err(SparqlRequestError::Http(error)) => {
            return server_rc
                .lock()
                .await
                .send_message(ExecuteOperationResponse::error(
                    request.get_id(),
                    ExecuteOperationErrorData::Http(error),
                ));
        }
        Err(SparqlRequestError::Canceled(error)) => {
            return server_rc
                .lock()
                .await
                .send_message(ExecuteOperationResponse::error(
                    request.get_id(),
                    ExecuteOperationErrorData::Canceled(error),
                ));
        }
        Err(SparqlRequestError::Deserialization(error)) => {
            return server_rc
                .lock()
                .await
                .send_message(ExecuteOperationResponse::error(
                    request.get_id(),
                    ExecuteOperationErrorData::InvalidFormat {
                        query,
                        message: error,
                    },
                ));
        }
        Err(_err) => {
            return server_rc
                .lock()
                .await
                .send_message(ExecuteOperationResponse::error(
                    request.get_id(),
                    ExecuteOperationErrorData::Unknown,
                ));
        }
    };
    let stop_time = get_timestamp();
    let _duration = stop_time - start_time;
    server_rc
        .lock()
        .await
        .send_message(ExecuteOperationResponse::success(
            request.get_id(),
            ExecuteOperationResponseResult::UpdateResult(update_result),
        ))
}