Function parse_from_option

crates/gitql-parser/src/parser.rs:831–983

(
    context: &mut ParserContext,
    env: &mut Environment,
    tables_to_select_from: &mut Vec<String>,
    joins: &mut Vec<Join>,
    tokens: &[Token],
    position: &mut usize,
)

}

fn parse_from_option(
    context: &mut ParserContext,
    env: &mut Environment,
    tables_to_select_from: &mut Vec<String>,
    joins: &mut Vec<Join>,
    tokens: &[Token],
    position: &mut usize,
) -> Result<(), Box<Diagnostic>> {
    if is_current_token(tokens, position, TokenKind::From) {
        // Consume `From` keyword
        *position += 1;

        // Parse and consume Symbol as Table name
        let table_name = consume_conditional_token_or_errors(
            tokens,
            position,
            |token| matches!(token.kind, TokenKind::Symbol(_)),
            "Expect `Table` value after `FROM` keyword",
        )?
        .to_string();

        if !env
            .schema
            .tables_fields_names
            .contains_key(table_name.as_str())
        {
            let mut diagnostic =
                Diagnostic::error(&format!("Cannot find table with name `{table_name}`"))
                    .add_note("You can use the `SHOW TABLES` query to get list of current tables")
                    .add_note("Check the documentations to see available tables")
                    .with_location(calculate_safe_location(tokens, *position));

            let canditates: Vec<&&str> = env.schema.tables_fields_names.keys().collect();
            if let Some(closest_valid_name) = find_closeest_string(&table_name, &canditates) {
                let message =
                    &format!("a table with a similar name exists: `{closest_valid_name}`");
                diagnostic = diagnostic.add_help(message);
            }

            return Err(diagnostic.as_boxed());
        }

        // Register the table
        tables_to_select_from.push(table_name.to_string());
        context.selected_tables.push(table_name.to_string());
        register_current_table_fields_types(env, &table_name)?;

        // Parse Joins
        let mut number_previous_of_joins = 0;
        while is_join_or_join_type_token(tokens, position) {
            let join_token = &tokens[*position];

            // The default join type now is cross join because we don't support `ON` Condition
            let mut join_kind = JoinKind::Default;
            if join_token.kind != TokenKind::Join {
                join_kind = match join_token.kind {
                    TokenKind::Left => JoinKind::Left,
                    TokenKind::Right => JoinKind::Right,