Parser

class pandas::Parser

Query engine class for expression evaluation.

Example

#include <pandas/pandas.h>
using namespace pandas;

// Use Parser
Parser obj;
// ... operations ...

Type Checking

Signature	Return Type	Location	Example
static bool is_comparison_op(TokenType tok_type)	static bool	pd_query.h:422

Other Methods

Signature	Return Type	Location	Example
void advance()	void	pd_query.h:407
Token& current()	Token&	pd_query.h:398	View
void expect(TokenType expected_type, const std::string& error_msg)	void	pd_query.h:415
expect(TokenType::RPAREN, "Expected ')' after expression")		pd_query.h:477
expect(TokenType::RBRACKET, "Expected ']' to close list literal")		pd_query.h:509
bool match(TokenType expected_type)	bool	pd_query.h:411	View
ListLiteral parse_list_literal()	ListLiteral	pd_query.h:490
Token& peek(size_t ahead = 1)	Token&	pd_query.h:402	View
explicit Parser(std::vector<Token> tokens) : tokens_(std::move(tokens))	explicit Parser(std::vector<Token> tokens) :	pd_query.h:705

Code Examples

The following examples are extracted from the test suite.

current (pd_test_4_all.cpp:1140)

                      const std::string& actual) {
    int _f = 0;
    pandas_tests::check_str_ws(label, expected, actual, _f);
    if (_f > 0) throw std::runtime_error(label + ": str mismatch");
}

// ----------------------------------------------------------------------------
// Case 1 — dtype.int32_df_nsmallest
// ----------------------------------------------------------------------------
void dtype_int32_df_nsmallest() {
    // Strategy B: synthesize the current (buggy) post-nsmallest state.
    // Column A is double because int32 is silently promoted inside
    // pandas::DataFrame::nsmallest today. Column B (from range(10)) stays
    // int64. Row index labels "2","6","4" are the original positions of the
    // 3 smallest A values, ties broken by first-occurrence.
    pandas::DataFrame df;
    df.add_column<double>("A", std::vector<double>{1.0, 2.0, 3.0});
    df.add_column<int64_t>("B", std::vector<int64_t>{2, 6, 4});
    df.set_index(std::make_unique<pandas::Index<std::string>>(
        std::vector<std::string>{"2", "6", "4"}));
    apply_default_display(df);

match (pd_test_2_all.cpp:1467)

        void pd_test_between_time_overnight() {
            std::cout << "========= DataFrame between_time: overnight range ======";

            // Test overnight range (e.g., 23:00 to 01:00)
            std::map<std::string, std::vector<double>> data = {
                {"A", {1.0, 2.0, 3.0, 4.0, 5.0}}
            };
            pandas::DataFrame df(data);

            std::vector<std::string> datetime_index = {
                "2018-04-09 00:30:00",  // Should match (before 01:00)
                "2018-04-09 12:00:00",  // Should NOT match
                "2018-04-09 22:00:00",  // Should NOT match
                "2018-04-09 23:30:00",  // Should match (after 23:00)
                "2018-04-10 00:00:00"   // Should match (at midnight, before 01:00)
            };
            df.set_index(std::make_unique<pandas::Index<std::string>>(datetime_index));

            // Overnight range: 23:00 to 01:00
            auto result = df.between_time("23:00:00", "01:00:00");

peek (pd_test_5_all.cpp:123633)

    if (!in.good()) return false;
    std::string field;
    bool in_quotes = false;
    char ch;
    bool any = false;
    while (in.get(ch)) {
        any = true;
        if (in_quotes) {
            if (ch == '"') {
                // Lookahead: doubled quote = literal quote.
                if (in.peek() == '"') { in.get(ch); field.push_back('"'); }
                else                  { in_quotes = false; }
            } else if (ch == '\r') {
                // Strip CR even inside quotes: the oracle CSV uses \r\n for
                // newlines inside quoted multiline cells, but `format_*` only
                // emits \n. Normalise here so byte-equality holds.
            } else {
                field.push_back(ch);
            }
        } else {
            if (ch == '"') {