interstellar 0.2.0

A high-performance graph database with Gremlin-style traversals and GQL query language
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

//! Error types for the Gremlin parser and compiler.

use crate::gremlin::ast::Span;
use thiserror::Error;

/// Top-level Gremlin error encompassing parse, compile, and execution errors.
#[derive(Debug, Error)]
pub enum GremlinError {
    /// Error during parsing
    #[error("Parse error: {0}")]
    Parse(#[from] ParseError),

    /// Error during compilation
    #[error("Compile error: {0}")]
    Compile(#[from] CompileError),

    /// Error during execution
    #[error("Execution error: {0}")]
    Execution(String),
}

/// Parse errors with source location information.
#[derive(Debug, Error)]
pub enum ParseError {
    /// Syntax error at a specific position
    #[error("Syntax error at position {span:?}: {message}")]
    SyntaxAt { span: Span, message: String },

    /// General syntax error
    #[error("Syntax error: {0}")]
    Syntax(String),

    /// Empty query provided
    #[error("Empty query")]
    Empty,

    /// Invalid literal value
    #[error("Invalid literal '{value}' at {span:?}: {reason}")]
    InvalidLiteral {
        value: String,
        span: Span,
        reason: &'static str,
    },

    /// Unexpected token encountered
    #[error("Unexpected token at {span:?}: found '{found}', expected {expected}")]
    UnexpectedToken {
        span: Span,
        found: String,
        expected: String,
    },

    /// Missing source step (query must start with g.V(), g.E(), etc.)
    #[error("Missing source step (query must start with g.V(), g.E(), etc.)")]
    MissingSource,

    /// Invalid step
    #[error("Invalid step '{step}' at {span:?}: {reason}")]
    InvalidStep {
        step: String,
        span: Span,
        reason: String,
    },
}

/// Compile errors during AST to traversal compilation.
#[derive(Debug, Error)]
pub enum CompileError {
    /// Step is not yet supported
    #[error("Unsupported step: {step}")]
    UnsupportedStep { step: String },

    /// Invalid arguments for a step
    #[error("Invalid arguments for {step}: {message}")]
    InvalidArguments { step: String, message: String },

    /// Type mismatch during compilation
    #[error("Type mismatch: {message}")]
    TypeMismatch { message: String },

    /// Reference to undefined label
    #[error("Undefined label: '{label}'")]
    UndefinedLabel { label: String },

    /// Invalid predicate construction
    #[error("Invalid predicate: {message}")]
    InvalidPredicate { message: String },

    /// Step requires a preceding step that wasn't found
    #[error("Step '{step}' requires preceding '{required}'")]
    MissingPrecedingStep { step: String, required: String },
}

impl ParseError {
    /// Create a syntax error at a specific span
    pub fn at(span: Span, message: impl Into<String>) -> Self {
        ParseError::SyntaxAt {
            span,
            message: message.into(),
        }
    }

    /// Create a syntax error from a pest parsing error
    pub fn from_pest(error: pest::error::Error<crate::gremlin::parser::Rule>) -> Self {
        ParseError::Syntax(error.to_string())
    }
}