kql-language-tools 0.1.0

Rust bindings to Kusto.Language for KQL validation and language services
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

//! Raw FFI declarations for the native library
//!
//! This module contains the low-level FFI function declarations
//! that map to the C ABI exposed by the .NET AOT library.
//!
//! These functions should not be called directly - use the safe
//! wrappers in the `validator` module instead.

use std::ffi::c_int;

/// Type alias for FFI function pointers
pub type FfiResult = c_int;

/// FFI function type: Initialize the library
///
/// Returns 0 on success, negative error code on failure.
pub type KqlInitFn = unsafe extern "C" fn() -> FfiResult;

/// FFI function type: Cleanup the library
pub type KqlCleanupFn = unsafe extern "C" fn();

/// FFI function type: Validate KQL syntax
///
/// # Arguments
/// * `query` - Pointer to UTF-8 encoded query string
/// * `query_len` - Length of the query in bytes
/// * `output` - Pointer to output buffer for JSON result
/// * `output_max_len` - Maximum size of output buffer
///
/// # Returns
/// * `> 0` - Success, value is the length of JSON written to output
/// * `0` - Success, empty result
/// * `-1` - Buffer too small
/// * `-2` - Parse error in input
/// * `-3` - Internal error
pub type KqlValidateSyntaxFn =
    unsafe extern "C" fn(query: *const u8, query_len: c_int, output: *mut u8, output_max_len: c_int) -> FfiResult;

/// FFI function type: Validate KQL with schema
///
/// # Arguments
/// * `query` - Pointer to UTF-8 encoded query string
/// * `query_len` - Length of the query in bytes
/// * `schema_json` - Pointer to UTF-8 encoded JSON schema
/// * `schema_len` - Length of the schema JSON in bytes
/// * `output` - Pointer to output buffer for JSON result
/// * `output_max_len` - Maximum size of output buffer
///
/// # Returns
/// Same as `KqlValidateSyntaxFn`
pub type KqlValidateWithSchemaFn = unsafe extern "C" fn(
    query: *const u8,
    query_len: c_int,
    schema_json: *const u8,
    schema_len: c_int,
    output: *mut u8,
    output_max_len: c_int,
) -> FfiResult;

/// FFI function type: Get the last error message
///
/// # Arguments
/// * `output` - Pointer to output buffer for error message
/// * `output_max_len` - Maximum size of output buffer
///
/// # Returns
/// * `> 0` - Length of error message written
/// * `0` - No error message available
/// * `-1` - Buffer too small
pub type KqlGetLastErrorFn = unsafe extern "C" fn(output: *mut u8, output_max_len: c_int) -> FfiResult;

/// FFI function type: Get completions at cursor position
///
/// # Arguments
/// * `query` - Pointer to UTF-8 encoded query string
/// * `query_len` - Length of the query in bytes
/// * `cursor_pos` - Cursor position (0-based character offset)
/// * `schema_json` - Pointer to UTF-8 encoded JSON schema (can be null)
/// * `schema_len` - Length of the schema JSON in bytes (0 if null)
/// * `output` - Pointer to output buffer for JSON result
/// * `output_max_len` - Maximum size of output buffer
///
/// # Returns
/// Same as `KqlValidateSyntaxFn`
pub type KqlGetCompletionsFn = unsafe extern "C" fn(
    query: *const u8,
    query_len: c_int,
    cursor_pos: c_int,
    schema_json: *const u8,
    schema_len: c_int,
    output: *mut u8,
    output_max_len: c_int,
) -> FfiResult;

/// FFI function type: Get syntax classifications
///
/// # Arguments
/// * `query` - Pointer to UTF-8 encoded query string
/// * `query_len` - Length of the query in bytes
/// * `output` - Pointer to output buffer for JSON result
/// * `output_max_len` - Maximum size of output buffer
///
/// # Returns
/// Same as `KqlValidateSyntaxFn`
pub type KqlGetClassificationsFn =
    unsafe extern "C" fn(query: *const u8, query_len: c_int, output: *mut u8, output_max_len: c_int) -> FfiResult;

/// Symbol names in the native library
pub mod symbols {
    /// Initialize function symbol
    pub const KQL_INIT: &str = "kql_init";

    /// Cleanup function symbol
    pub const KQL_CLEANUP: &str = "kql_cleanup";

    /// Validate syntax function symbol
    pub const KQL_VALIDATE_SYNTAX: &str = "kql_validate_syntax";

    /// Validate with schema function symbol
    pub const KQL_VALIDATE_WITH_SCHEMA: &str = "kql_validate_with_schema";

    /// Get last error function symbol
    pub const KQL_GET_LAST_ERROR: &str = "kql_get_last_error";

    /// Get completions function symbol
    pub const KQL_GET_COMPLETIONS: &str = "kql_get_completions";

    /// Get classifications function symbol
    pub const KQL_GET_CLASSIFICATIONS: &str = "kql_get_classifications";
}

/// Return codes from FFI functions
pub mod return_codes {
    use std::ffi::c_int;

    /// Buffer too small - need to retry with larger buffer
    pub const BUFFER_TOO_SMALL: c_int = -1;

    /// Check if return code indicates success
    pub fn is_success(code: c_int) -> bool {
        code >= 0
    }

    /// Check if return code indicates buffer too small
    pub fn is_buffer_too_small(code: c_int) -> bool {
        code == BUFFER_TOO_SMALL
    }
}

/// Default buffer size for FFI output (64KB)
pub const DEFAULT_BUFFER_SIZE: usize = 64 * 1024;

/// Maximum buffer size for FFI output (4MB)
pub const MAX_BUFFER_SIZE: usize = 4 * 1024 * 1024;