perf: replace binary search keyword lookup with FNV-1a hash table (O(1))

Use a 512-slot open-addressing hash table with linear probing instead
of binary search (~7 comparisons) for keyword classification. The table
is built once at startup from the existing keyword arrays.

Benchmarks show 15-30% improvement across parser operations:
- Select_Simple: 239ns -> 185ns (-23%)
- Select_Complex: 1448ns -> 1104ns (-24%)
- Classify_Begin: 38ns -> 31ns (-18%)
- Select_MultiJoin: 1577ns -> 1073ns (-32%)

Closes #12

Author: renecannao

include/sql_parser/keyword_hash.h

@@ -0,0 +1,86 @@
+#ifndef SQL_PARSER_KEYWORD_HASH_H
+#define SQL_PARSER_KEYWORD_HASH_H
+
+#include "sql_parser/token.h"
+#include <cstdint>
+#include <cstring>
+
+namespace sql_parser {
+namespace keyword_hash {
+
+// FNV-1a hash (case-insensitive: lowercases ASCII bytes before hashing)
+// Uses the standard FNV-1a 32-bit offset basis and prime.
+inline uint32_t hash_keyword(const char* text, uint32_t len) {
+    uint32_t h = 0x811c9dc5u;
+    for (uint32_t i = 0; i < len; ++i) {
+        uint8_t c = static_cast<uint8_t>(text[i]);
+        // ASCII uppercase to lowercase
+        if (c >= 'A' && c <= 'Z') c += 32;
+        h ^= c;
+        h *= 0x01000193u;
+    }
+    return h;
+}
+
+// Hash table entry
+struct HashEntry {
+    const char* text;   // uppercase keyword text (nullptr = empty slot)
+    uint8_t     len;
+    TokenType   token;
+};
+
+// Table size must be a power of 2. 512 gives ~29% load for 150 MySQL keywords
+// (max probe = 5) and ~24% load for 123 PgSQL keywords (max probe = 3).
+static constexpr uint32_t TABLE_SIZE = 512;
+static constexpr uint32_t TABLE_MASK = TABLE_SIZE - 1;
+
+// Maximum number of linear probes before giving up.
+// Empirically: MySQL = 5, PgSQL = 3. Use 8 for safety margin.
+static constexpr uint32_t MAX_PROBE = 8;
+
+// Case-insensitive equality check (input may be mixed case, entry is uppercase)
+inline bool ci_equal(const char* input, const char* upper, uint32_t len) {
+    for (uint32_t i = 0; i < len; ++i) {
+        uint8_t a = static_cast<uint8_t>(input[i]);
+        uint8_t b = static_cast<uint8_t>(upper[i]);
+        if (a >= 'a' && a <= 'z') a -= 32;
+        if (a != b) return false;
+    }
+    return true;
+}
+
+// Build a hash table from a sorted keyword array.
+// KeywordArray must have .text, .len, .token fields.
+// Returns the number of keywords inserted (for debug).
+template <typename KeywordEntry, size_t N>
+inline void build_table(const KeywordEntry (&keywords)[N], HashEntry (&table)[TABLE_SIZE]) {
+    // Zero-init
+    for (uint32_t i = 0; i < TABLE_SIZE; ++i) {
+        table[i] = {nullptr, 0, TokenType::TK_IDENTIFIER};
+    }
+    for (size_t k = 0; k < N; ++k) {
+        uint32_t idx = hash_keyword(keywords[k].text, keywords[k].len) & TABLE_MASK;
+        while (table[idx].text != nullptr) {
+            idx = (idx + 1) & TABLE_MASK;
+        }
+        table[idx] = {keywords[k].text, keywords[k].len, keywords[k].token};
+    }
+}
+
+// Lookup a keyword in a pre-built hash table.
+inline TokenType lookup_in_table(const HashEntry (&table)[TABLE_SIZE],
+                                  const char* text, uint32_t len) {
+    uint32_t idx = hash_keyword(text, len) & TABLE_MASK;
+    for (uint32_t probe = 0; probe <= MAX_PROBE; ++probe) {
+        const HashEntry& e = table[idx];
+        if (e.text == nullptr) return TokenType::TK_IDENTIFIER;
+        if (e.len == len && ci_equal(text, e.text, len)) return e.token;
+        idx = (idx + 1) & TABLE_MASK;
+    }
+    return TokenType::TK_IDENTIFIER;
+}
+
+} // namespace keyword_hash
+} // namespace sql_parser
+
+#endif // SQL_PARSER_KEYWORD_HASH_H

include/sql_parser/keywords_mysql.h

@@ -2,6 +2,7 @@
 #define SQL_PARSER_KEYWORDS_MYSQL_H
 
 #include "sql_parser/token.h"
+#include "sql_parser/keyword_hash.h"
 #include <algorithm>
 #include <cstring>
 
@@ -169,16 +170,14 @@ inline constexpr KeywordEntry KEYWORDS[] = {
 
 inline constexpr size_t KEYWORD_COUNT = sizeof(KEYWORDS) / sizeof(KEYWORDS[0]);
 
+inline keyword_hash::HashEntry HASH_TABLE[keyword_hash::TABLE_SIZE];
+inline bool HASH_TABLE_INIT = [] {
+    keyword_hash::build_table(KEYWORDS, HASH_TABLE);
+    return true;
+}();
+
 inline TokenType lookup(const char* text, uint32_t len) {
-    size_t lo = 0, hi = KEYWORD_COUNT;
-    while (lo < hi) {
-        size_t mid = lo + (hi - lo) / 2;
-        int cmp = sql_parser::ci_cmp(text, len, KEYWORDS[mid].text, KEYWORDS[mid].len);
-        if (cmp == 0) return KEYWORDS[mid].token;
-        if (cmp < 0) hi = mid;
-        else lo = mid + 1;
-    }
-    return TokenType::TK_IDENTIFIER;
+    return keyword_hash::lookup_in_table(HASH_TABLE, text, len);
 }
 
 } // namespace mysql_keywords

include/sql_parser/keywords_pgsql.h

@@ -2,6 +2,7 @@
 #define SQL_PARSER_KEYWORDS_PGSQL_H
 
 #include "sql_parser/token.h"
+#include "sql_parser/keyword_hash.h"
 
 namespace sql_parser {
 namespace pgsql_keywords {
@@ -140,16 +141,14 @@ inline constexpr KeywordEntry KEYWORDS[] = {
 
 inline constexpr size_t KEYWORD_COUNT = sizeof(KEYWORDS) / sizeof(KEYWORDS[0]);
 
+inline keyword_hash::HashEntry HASH_TABLE[keyword_hash::TABLE_SIZE];
+inline bool HASH_TABLE_INIT = [] {
+    keyword_hash::build_table(KEYWORDS, HASH_TABLE);
+    return true;
+}();
+
 inline TokenType lookup(const char* text, uint32_t len) {
-    size_t lo = 0, hi = KEYWORD_COUNT;
-    while (lo < hi) {
-        size_t mid = lo + (hi - lo) / 2;
-        int cmp = sql_parser::ci_cmp(text, len, KEYWORDS[mid].text, KEYWORDS[mid].len);
-        if (cmp == 0) return KEYWORDS[mid].token;
-        if (cmp < 0) hi = mid;
-        else lo = mid + 1;
-    }
-    return TokenType::TK_IDENTIFIER;
+    return keyword_hash::lookup_in_table(HASH_TABLE, text, len);
 }
 
 } // namespace pgsql_keywords