High-Performance C++ Read-Through Cache Server

const net = require('net');

function queryAnemo(sql, host = '127.0.0.1', port = 8080) {
    return new Promise((resolve, reject) => {
        const client = net.createConnection({ host, port }, () => {
            client.write(`${sql}<EOQ>`);
        });

        let response = '';
        client.on('data', (chunk) => {
            response += chunk.toString();
            if (response.includes('<EOQ>')) {
                client.end();
                resolve(response.replace('<EOQ>', '').trim());
            }
        });

        client.on('error', reject);
    });
}

// Example usage:
(async () => {
    const res = await queryAnemo("SELECT student_id, name FROM students WHERE student_id = 42;");
    console.log("Result from AnemoDB:", res);
})();

package main

import (
    "bufio"
    "fmt"
    "net"
    "strings"
)

func queryAnemo(sql string) (string, error) {
    conn, err := net.Dial("tcp", "127.0.0.1:8080")
    if err != nil {
        return "", err
    }
    defer conn.Close()

    // Send query framed with <EOQ>
    fmt.Fprintf(conn, "%s<EOQ>", sql)

    // Read response until <EOQ>
    reader := bufio.NewReader(conn)
    raw, err := reader.ReadString('>') // reads up to closing '>'
    if err != nil {
        return "", err
    }
    return strings.TrimSuffix(raw, "<EOQ>"), nil
}

func main() {
    res, _ := queryAnemo("SELECT student_id, name FROM students WHERE student_id = 42;")
    fmt.Println("Result from AnemoDB:", res)
}

# 1. Point lookup via netcat
echo "SELECT student_id, name FROM students WHERE student_id = 42;<EOQ>" | nc localhost 8080

# 2. Inspect real-time server telemetry stats (ANSI console output)
echo "STATS<EOQ>" | nc localhost 8080

# 3. Fetch JSON metrics for Prometheus or Datadog
echo "STATS_JSON<EOQ>" | nc localhost 8080

#include <iostream>
#include <string>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

std::string queryAnemo(const std::string& sql, const char* ip = "127.0.0.1", int port = 8080) {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) return "Socket creation error";

    struct sockaddr_in serv_addr;
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(port);
    
    if (inet_pton(AF_INET, ip, &serv_addr.sin_addr) <= 0) {
        return "Invalid address";
    }

    if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        return "Connection failed";
    }
    
    std::string payload = sql + "<EOQ>";
    send(sock, payload.c_str(), payload.length(), 0);

    char buffer[4096] = {0};
    std::string response;
    while (read(sock, buffer, 4096) > 0) {
        response += buffer;
        if (response.find("<EOQ>") != std::string::npos) break;
    }
    close(sock);

    size_t pos = response.find("<EOQ>");
    if (pos != std::string::npos) response.erase(pos);
    
    return response;
}

int main() {
    std::string res = queryAnemo("SELECT student_id, name FROM students WHERE student_id = 42;");
    std::cout << "Result from AnemoDB: " << res << std::endl;
    return 0;
}

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class AnemoClient {
    public static String queryAnemo(String sql, String host, int port) throws Exception {
        try (Socket socket = new Socket(host, port)) {
            OutputStream out = socket.getOutputStream();
            InputStream in = socket.getInputStream();

            String payload = sql + "<EOQ>";
            out.write(payload.getBytes(StandardCharsets.UTF_8));
            out.flush();

            StringBuilder response = new StringBuilder();
            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                response.append(new String(buffer, 0, bytesRead, StandardCharsets.UTF_8));
                if (response.toString().contains("<EOQ>")) {
                    break;
                }
            }
            return response.toString().replace("<EOQ>", "").trim();
        }
    }

    public static void main(String[] args) {
        try {
            String res = queryAnemo("SELECT student_id, name FROM students WHERE student_id = 42;", "127.0.0.1", 8080);
            System.out.println("Result from AnemoDB: " + res);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

use std::io::{Read, Write};
use std::net::TcpStream;

fn query_anemo(sql: &str) -> std::io::Result<String> {
    let mut stream = TcpStream::connect("127.0.0.1:8080")?;
    
    let payload = format!("{}<EOQ>", sql);
    stream.write_all(payload.as_bytes())?;
    
    let mut response = String::new();
    let mut buffer = [0; 4096];
    
    loop {
        let bytes_read = stream.read(&mut buffer)?;
        if bytes_read == 0 {
            break;
        }
        response.push_str(&String::from_utf8_lossy(&buffer[..bytes_read]));
        if response.contains("<EOQ>") {
            break;
        }
    }
    
    Ok(response.replace("<EOQ>", "").trim().to_string())
}

fn main() {
    match query_anemo("SELECT student_id, name FROM students WHERE student_id = 42;") {
        Ok(res) => println!("Result from AnemoDB: {}", res),
        Err(e) => eprintln!("Error: {}", e),
    }
}