iridium_core 0.1.12

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use crate::ast::Statement;
use crate::error::DbError;
use crate::parser::parse_batch_with_quoted_ident;

use super::super::locks::SessionId;
use super::super::result::QueryResult;
use super::{CursorFetchResult, StatementExecutor};
use super::{EngineCatalog, EngineStorage};
use super::execution_support;
use super::cursor_rpc;

impl<C, S> StatementExecutor for super::StatementExecutorService<C, S>
where
    C: EngineCatalog,
    S: EngineStorage,
{
    fn execute_session(
        &self,
        session_id: SessionId,
        stmt: Statement,
    ) -> Result<Option<QueryResult>, DbError> {
        execution_support::with_session(&self.state, session_id, |session| {
            execution_support::execute_single_statement(&self.state, session_id, session, stmt)
        })
    }

    fn execute_session_batch(
        &self,
        session_id: SessionId,
        stmts: Vec<Statement>,
    ) -> Result<Option<QueryResult>, DbError> {
        execution_support::with_session(&self.state, session_id, |session| {
            execution_support::execute_batch_statements(&self.state, session_id, session, stmts)
        })
    }

    fn execute_session_batch_sql(
        &self,
        session_id: SessionId,
        sql: &str,
    ) -> Result<Option<QueryResult>, DbError> {
        let quoted_ident = execution_support::with_session(&self.state, session_id, |session| {
            Ok(session.options.quoted_identifier)
        })?;

        let stmts = parse_batch_with_quoted_ident(sql, quoted_ident)?;
        execution_support::with_session(&self.state, session_id, |session| {
            execution_support::execute_batch_statements(&self.state, session_id, session, stmts)
        })
    }

    fn execute_session_batch_sql_multi(
        &self,
        session_id: SessionId,
        sql: &str,
    ) -> Result<Vec<Option<QueryResult>>, DbError> {
        let quoted_ident = execution_support::with_session(&self.state, session_id, |session| {
            Ok(session.options.quoted_identifier)
        })?;

        let stmts = parse_batch_with_quoted_ident(sql, quoted_ident)?;
        execution_support::with_session(&self.state, session_id, |session| {
            execution_support::execute_batch_statements_multi(
                &self.state,
                session_id,
                session,
                stmts,
            )
        })
    }

    fn set_session_metadata(
        &self,
        session_id: SessionId,
        user: Option<String>,
        app_name: Option<String>,
        host_name: Option<String>,
        database: Option<String>,
    ) -> Result<(), DbError> {
        execution_support::with_session(&self.state, session_id, |session| {
            session.user = user;
            session.app_name = app_name;
            session.host_name = host_name;
            if let Some(database) = database {
                session.current_database = database.clone();
                session.original_database = database;
            }
            Ok(())
        })
    }

    fn set_session_database(&self, session_id: SessionId, database: String) -> Result<(), DbError> {
        execution_support::with_session(&self.state, session_id, |session| {
            session.current_database = database;
            Ok(())
        })
    }

    // ── Cursor RPC operations ──────────────────────────────────────

    fn cursor_rpc_open(
        &self,
        session_id: SessionId,
        sql: &str,
        _scroll_opt: i32,
    ) -> Result<(i32, QueryResult), DbError> {
        cursor_rpc::cursor_rpc_open(&self.state, session_id, sql, _scroll_opt)
    }

    fn cursor_rpc_fetch(
        &self,
        session_id: SessionId,
        handle: i32,
        fetch_type: i32,
        row_num: i32,
        n_rows: i32,
    ) -> Result<CursorFetchResult, DbError> {
        cursor_rpc::cursor_rpc_fetch(&self.state, session_id, handle, fetch_type, row_num, n_rows)
    }

    fn cursor_rpc_close(&self, session_id: SessionId, handle: i32) -> Result<(), DbError> {
        cursor_rpc::cursor_rpc_close(&self.state, session_id, handle)
    }

    fn cursor_rpc_deallocate(&self, session_id: SessionId, handle: i32) -> Result<(), DbError> {
        cursor_rpc::cursor_rpc_deallocate(&self.state, session_id, handle)
    }

    fn set_bulk_load_active(
        &self,
        session_id: SessionId,
        active: bool,
        table: crate::ast::ObjectName,
        columns: Vec<crate::ast::statements::ddl::ColumnSpec>,
        received_metadata: bool,
    ) -> Result<(), DbError> {
        cursor_rpc::set_bulk_load_active(
            &self.state,
            session_id,
            active,
            table,
            columns,
            received_metadata,
        )
    }

    fn get_bulk_load_state(
        &self,
        session_id: SessionId,
    ) -> (
        bool,
        Option<crate::ast::ObjectName>,
        Option<Vec<crate::ast::statements::ddl::ColumnSpec>>,
        bool,
    ) {
        cursor_rpc::get_bulk_load_state(&self.state, session_id)
    }
}