关于logos在databend中的应用

databend中关于将sql进行token化，则是基于logos来完成，其本身进行封装定义了Tokenizer

pub struct Tokenizer<'a> {
    source: &'a str,           // 解析的token对应的内容
    lexer: Lexer<'a, TokenKind>, // 解析当前tokenkind的lexer
    prev_token: Option<TokenKind>, // 当前token前面一个token
    eoi: bool,                     // 是否解析到了当前被解析内容的末尾或hint中碰到eoi
}

同时并没有选择derive结构体Token，而是选择了TokenKind

#[derive(Clone, PartialEq, Eq)]
pub struct Token<'a> {
    pub source: &'a str,  // 当前token的内容
    pub kind: TokenKind,  // 当前token的类型
    pub span: Range,      // 当前token在提供的sql字符串的内容的范围
}

#[allow(non_camel_case_types)]
#[derive(Logos, EnumIter, Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TokenKind {
        // 省略内部代码
}

关于logos

logos代码库
logos是一个使用rust编写的词法解析器；更多见logos文档
常见应用logos方式：

• 在自定义的Struct上声明 #[derive(logos)]即可，也即说明当前struct实现了Logos trait，不过实现代码是通过macro方式来完成具体代码生成的可见logos-codegen；
• 使用Lexer<T: Logos>这个iterator来完成最终的词法解析过程；
• 针对struct定义的那些待被解析的item可以通过#[token]:纯文本字符串 [regex]:正则表达式

补充关于自定义的struct还可以指定logos其他的属性

• [logos(skip "regex literal")]： 指定跳过某些满足正则表达式文本的内容，不需要进行token化

• [logos(extras = ExtrasType)]： 自定义Extras，用于来满足进行token过程，提供一些友好的内容输出比如输出解析item在原有文本中的行、列的位置等，便于定位

• [logos(error = ErrorType)]： 自定义Error，默认情况下logos出现error输出的(),得不到具体错误信息，则可以使用自定义error输出具体错误信息

• [logos(crate = path::to::logos)]：自定义第三方的logos的路径

• [logos(source = SourceType)]：主要是自定义logos接受的输入类型，默认是&str

#[derive(Logos, Debug, PartialEq)]
#[logos(skip r"[ \t\n\f]+")] // Ignore this regex pattern between tokens
#[logos(error = LexingErr)]
enum Token {
    // Tokens can be literal strings, of any length.
    #[token("fast")]
    Fast,

    #[token(".")]
    Period,

    #[token(",")]
    Comma,

    // Or regular expressions.
    #[regex("[a-zA-Z]+")]
    Text,

    // number
    #[regex("[0-9]*")]
    NUM
}

#[derive(Default, Debug, Clone, PartialEq)]
enum LexingErr {
    InvalidInteger(String),
    #[default]
    NonAsciiChar,
}

use std::num::IntErrorKind::{PosOverflow, NegOverflow};


impl From<ParseIntError> for LexingErr {
    fn from(err: ParseIntError) -> Self {
        match err.kind() {
            PosOverflow | NegOverflow=> LexingErr::InvalidInteger("overflow error".to_owned()),
            _ => LexingErr::InvalidInteger("other error".to_owned()),
        }
    }
}


for tk in Token::lexer("select a, b from bar where c 1234"){
        match tk {
            Ok(ref token)=> println!("token={:?}, val={:?}", token, tk),
            Err(e) => panic!("something error: {:?}", e),
        }
    }

一般Lexer有3个方法：

• next()： 用于获取下一个token；返回结果Result<Token, _>
• span(): 获取当前token在输入文本的范围:[start..end]
• slice(): 获取当前token对应的具体内容

关于logos针对自定义struct/enum每个item的处理

#[derive(Logos)]
enum Token {
    #[token(literal [, callback, priority = <integer>, ignore(<flag>, ...)]]
    #[regex(literal [, callback, priority = <integer>, ignore(<flag>, ...)]]
    SomeVariant,
}

以上token和regex除了literal外其他都是可选的；

• callback：可以给每个item指定callback，针对当前item进行其他处理，可以使用闭包形式也可以定义方法
• priority：指定当前规则的优先级，特别时出现匹配多个规则时；
• ignore：忽略某些不需要的内容

/// Update the line count and the char index.
fn newline_callback(lex: &mut Lexer<Token>) -> Skip {
    lex.extras.0 += 1;
    lex.extras.1 = lex.span().end;
    Skip
}

/// Compute the line and column position for the current word.
fn word_callback(lex: &mut Lexer<Token>) -> (usize, usize) {
    let line = lex.extras.0;
    let column = lex.span().start - lex.extras.1;

    (line, column)
}

/// Simple tokens to retrieve words and their location.
#[derive(Debug, Logos)]
#[logos(extras = (usize, usize))]
enum Token {
    #[regex(r"\n", newline_callback)]
    Newline,

    #[regex(r"\w+", word_callback)]
    Word((usize, usize)),
}

let mut lex = Token::lexer("[package]
name = "rustdemos"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
spin ="0.9.8"
logos = "0.13.0"
regex = "1.10.2"
num = "0.4.1"");

    while let Some(token) = lex.next() {
        match token {
            Ok(Token::Word((line, column))) => {
                println!("Word '{}' found at ({}, {})", lex.slice(), line, column);
            }
            _ => (),
        }
    }

关于logos进行item解析时匹配多个规则时遵循如下要求

• Longer beats shorter.
• Specific beats generic.

另外若是同时满足多个规则，此时可以通过priority来进行调整否则会panic