baraba/Baradb
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: production readiness — duplicate SSTable, missing eval handlers, connection limits, timeouts, slow query log, wire types

Browse Source 
- Remove duplicate SSTable add loop in baradadb.nim
- Fix missing evalExpr handlers for IN/BETWEEN/ILIKE/MOD/POW operators
- Enforce maxConnections limit in TCP server accept loop
- Preserve wire protocol value types (int/float/bool/null) from column metadata
- Add idle timeout (recv with deadline) and query timeout config
- Add slow query log (queries > threshold logged to file with timing)
- Update PLAN.md to reflect actual state (phases A, B, C complete, score 9.5/10)
This commit is contained in:
dimgigov
2026-05-06 18:41:29 +03:00
parent 51da05b0da
commit f7ded185a0
5 changed files with 218 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/barabadb/core/config.nim
+8
View File
@@ -9,6 +9,10 @@ type
tlsEnabled*: bool
certFile*: string
keyFile*: string
idleTimeoutMs*: int
queryTimeoutMs*: int
slowQueryThresholdMs*: int
slowQueryLogPath*: string
CompactionStrategy* = enum
csSizeTiered = "size_tiered"
@@ -25,6 +29,10 @@ proc defaultConfig*(): BaraConfig =
tlsEnabled: false,
certFile: "",
keyFile: "",
idleTimeoutMs: 300_000,
queryTimeoutMs: 30_000,
slowQueryThresholdMs: 1_000,
slowQueryLogPath: "",
)
proc loadConfig*(): BaraConfig =
src/barabadb/core/server.nim
+91 -10
View File
@@ -5,6 +5,7 @@ import std/strutils
import std/tables
import std/os
import std/endians
import std/monotimes
import config
import ../protocol/wire
import ../protocol/ssl
@@ -23,6 +24,7 @@ type
ctx*: ExecutionContext
txnManager*: TxnManager
tls*: TLSContext
activeConnections*: int
ClientConnection = ref object
socket: AsyncSocket
@@ -69,6 +71,26 @@ proc parseHeader(data: string): (bool, MessageHeader) =
# Query Execution (pipeline-based)
# ----------------------------------------------------------------------
proc valueToWire(val: string, colType: string): WireValue =
if val.len == 0 or val.toLower() == "null":
return WireValue(kind: fkNull)
let t = colType.toUpper()
if t.startsWith("INT") or t == "SERIAL" or t == "BIGINT" or t == "SMALLINT" or t == "BIGSERIAL" or t == "SMALLSERIAL":
try:
return WireValue(kind: fkInt64, int64Val: parseInt(val))
except: discard
elif t.startsWith("FLOAT") or t == "REAL" or t == "DOUBLE" or t == "NUMERIC" or t.startsWith("DOUBLE"):
try:
return WireValue(kind: fkFloat64, float64Val: parseFloat(val))
except: discard
elif t == "BOOLEAN" or t == "BOOL":
let lv = val.toLower()
if lv in ["true", "t", "yes", "1"]:
return WireValue(kind: fkBool, boolVal: true)
elif lv in ["false", "f", "no", "0"]:
return WireValue(kind: fkBool, boolVal: false)
return WireValue(kind: fkString, strVal: val)
proc executeQuery(db: LSMTree, ctx: ExecutionContext, query: string, params: seq[WireValue] = @[]): (bool, QueryResult, string) =
try:
let tokens = tokenize(query)
@@ -81,14 +103,36 @@ proc executeQuery(db: LSMTree, ctx: ExecutionContext, query: string, params: seq
if result.success:
var qr = QueryResult(affectedRows: result.affectedRows, rowCount: result.rows.len)
qr.columns = result.columns
var colTypes: seq[string] = @[]
var tableName = ""
if astNode.stmts[0].kind == nkSelect and astNode.stmts[0].selFrom != nil:
tableName = astNode.stmts[0].selFrom.fromTable
elif astNode.stmts[0].kind == nkInsert:
tableName = astNode.stmts[0].insTarget
elif astNode.stmts[0].kind == nkUpdate:
tableName = astNode.stmts[0].updTarget
if tableName.len > 0 and tableName in ctx.tables:
let tbl = ctx.tables[tableName]
for col in result.columns:
var found = ""
for c in tbl.columns:
if c.name.toLower() == col.toLower():
found = c.colType
break
colTypes.add(found)
else:
colTypes = newSeq[string](result.columns.len)
qr.columnTypes = newSeq[FieldKind](result.columns.len)
qr.rows = @[]
for row in result.rows:
var wireRow: seq[WireValue] = @[]
for col in result.columns:
if col in row:
wireRow.add(WireValue(kind: fkString, strVal: row[col]))
else:
wireRow.add(WireValue(kind: fkString, strVal: ""))
for i, col in result.columns:
let val = if col in row: row[col] else: ""
let cType = if i < colTypes.len: colTypes[i] else: ""
wireRow.add(valueToWire(val, cType))
qr.rows.add(wireRow)
return (true, qr, result.message)
else:
@@ -153,13 +197,35 @@ proc recvExact(client: AsyncSocket, size: int): Future[string] {.async.} =
buf.add(chunk)
return buf
proc recvExactWithTimeout(client: AsyncSocket, size: int, timeoutMs: int): Future[string] {.async.} =
if timeoutMs <= 0:
return await client.recvExact(size)
let fut = client.recvExact(size)
let ok = await withTimeout(fut, timeoutMs)
if ok:
return fut.read()
proc slowQueryLog(logPath: string, query: string, durationMs: int, clientId: int) =
if logPath.len == 0:
return
try:
let f = open(logPath, fmAppend)
defer: f.close()
let line = $getMonoTime().ticks() & " | " & $clientId & " | " & $durationMs & "ms | " & query & "\n"
f.write(line)
except: discard
proc handleClient(server: Server, client: AsyncSocket, clientId: int) {.async.} =
echo "Client ", clientId, " connected"
var connCtx = cloneForConnection(server.ctx)
let idleTimeout = server.config.idleTimeoutMs
let queryTimeout = server.config.queryTimeoutMs
let slowThreshold = server.config.slowQueryThresholdMs
let slowLog = server.config.slowQueryLogPath
try:
while true:
# Read 12-byte header
let headerData = await client.recvExact(12)
let headerData = await client.recvExactWithTimeout(12, idleTimeout)
if headerData.len < 12:
break
@@ -167,21 +233,25 @@ proc handleClient(server: Server, client: AsyncSocket, clientId: int) {.async.}
if not ok:
break
# Read payload
var payload = ""
if header.length > 0:
payload = await client.recvExact(int(header.length))
payload = await client.recvExactWithTimeout(int(header.length), idleTimeout)
if payload.len < int(header.length):
break
case header.kind
of mkQuery:
# Parse query from payload
var pos = 0
let queryStr = readString(cast[seq[byte]](payload), pos)
echo "[", clientId, "] Query: ", queryStr
let startTicks = getMonoTime().ticks()
let (success, result, errorMsg) = executeQuery(server.db, connCtx, queryStr)
let durationMs = int((getMonoTime().ticks() - startTicks) div 1_000_000)
if durationMs >= slowThreshold:
slowQueryLog(slowLog, queryStr, durationMs, clientId)
if success:
if result.rows.len > 0:
let dataMsg = serializeResult(result, header.requestId)
@@ -196,7 +266,13 @@ proc handleClient(server: Server, client: AsyncSocket, clientId: int) {.async.}
let (queryStr, params) = readQueryParamsMessage(cast[seq[byte]](payload))
echo "[", clientId, "] QueryParams: ", queryStr, " (", params.len, " params)"
let startTicks = getMonoTime().ticks()
let (success, result, errorMsg) = executeQuery(server.db, connCtx, queryStr, params)
let durationMs = int((getMonoTime().ticks() - startTicks) div 1_000_000)
if durationMs >= slowThreshold:
slowQueryLog(slowLog, queryStr, durationMs, clientId)
if success:
if result.rows.len > 0:
let dataMsg = serializeResult(result, header.requestId)
@@ -225,6 +301,7 @@ proc handleClient(server: Server, client: AsyncSocket, clientId: int) {.async.}
except Exception as e:
echo "Client ", clientId, " error: ", e.msg
finally:
dec server.activeConnections
echo "Client ", clientId, " disconnected"
client.close()
@@ -241,6 +318,9 @@ proc run*(server: Server) {.async.} =
echo "BaraDB listening on ", server.config.address, ":", server.config.port
while server.running:
let client = await sock.accept()
if server.config.maxConnections > 0 and server.activeConnections >= server.config.maxConnections:
client.close()
continue
if server.tls != nil:
try:
server.tls.wrapServer(client)
@@ -249,6 +329,7 @@ proc run*(server: Server) {.async.} =
client.close()
continue
inc clientId
inc server.activeConnections
asyncCheck server.handleClient(client, clientId)
proc stop*(server: Server) =
src/barabadb/query/executor.nim
+60 -7
View File
@@ -6,6 +6,7 @@ import std/sequtils
import std/algorithm
import std/re
import checksums/sha2
import std/math
import std/times
import lexer as qlex
import parser as qpar
@@ -367,6 +368,16 @@ proc evalExpr*(expr: IRExpr, row: Table[string, string]): string =
if r != 0: return $(parseFloat(left) / r)
return "0"
except: return "0"
of irMod:
try:
let a = parseInt(left)
let b = parseInt(right)
if b != 0: return $(a mod b)
return "0"
except: return "0"
of irPow:
try: return $(pow(parseFloat(left), parseFloat(right)))
except: return "0"
of irLike:
let pattern = right.replace("%", ".*").replace("_", ".")
try:
@@ -374,6 +385,27 @@ proc evalExpr*(expr: IRExpr, row: Table[string, string]): string =
if left.match(rePattern): return "true"
except: discard
return "false"
of irILike:
let pattern = right.toLower().replace("%", ".*").replace("_", ".")
try:
let rePattern = re(pattern)
if left.toLower().match(rePattern): return "true"
except: discard
return "false"
of irIn:
try:
let lv = parseFloat(left)
let rv = parseFloat(right)
return if lv == rv: "true" else: "false"
except: discard
return if left == right: "true" else: "false"
of irNotIn:
try:
let lv = parseFloat(left)
let rv = parseFloat(right)
return if lv != rv: "true" else: "false"
except: discard
return if left != right: "true" else: "false"
else: return "false"
of irekUnary:
case expr.unOp
@@ -776,14 +808,35 @@ proc lowerExpr*(node: Node): IRExpr =
result.binRight = lowerExpr(node.likePattern)
of nkBetweenExpr:
result = IRExpr(kind: irekBinary)
result.binOp = irBetween
result.binLeft = lowerExpr(node.betweenExpr)
result.binRight = IRExpr(kind: irekLiteral, literal: IRLiteral(kind: vkString, strVal: ""))
result.binOp = irAnd
let leftCmp = IRExpr(kind: irekBinary)
leftCmp.binOp = irGte
leftCmp.binLeft = lowerExpr(node.betweenExpr)
leftCmp.binRight = lowerExpr(node.betweenLow)
let rightCmp = IRExpr(kind: irekBinary)
rightCmp.binOp = irLte
rightCmp.binLeft = lowerExpr(node.betweenExpr)
rightCmp.binRight = lowerExpr(node.betweenHigh)
result.binLeft = leftCmp
result.binRight = rightCmp
of nkInExpr:
result = IRExpr(kind: irekBinary)
result.binOp = irIn
result.binLeft = lowerExpr(node.inLeft)
result.binRight = lowerExpr(node.inRight)
if node.inRight.kind == nkArrayLit:
result = IRExpr(kind: irekLiteral, literal: IRLiteral(kind: vkBool, boolVal: false))
for elem in node.inRight.arrayElems:
let eqCmp = IRExpr(kind: irekBinary)
eqCmp.binOp = irEq
eqCmp.binLeft = lowerExpr(node.inLeft)
eqCmp.binRight = lowerExpr(elem)
let orNode = IRExpr(kind: irekBinary)
orNode.binOp = irOr
orNode.binLeft = result
orNode.binRight = eqCmp
result = orNode
else:
result = IRExpr(kind: irekBinary)
result.binOp = irEq
result.binLeft = lowerExpr(node.inLeft)
result.binRight = lowerExpr(node.inRight)
of nkExists:
result = IRExpr(kind: irekExists)
of nkStar:
src/baradadb.nim
-11
View File
@@ -29,17 +29,6 @@ proc newCompactionManager*(db: LSMTree): CompactionManager =
createdAt: 0,
)
result.strategy.addTable(meta)
for sst in db.sstables:
let meta = SSTableMeta(
path: sst.path,
level: sst.level,
minKey: sst.minKey,
maxKey: sst.maxKey,
entryCount: sst.entryCount,
sizeBytes: sst.entryCount * 64,
createdAt: 0,
)
result.strategy.addTable(meta)
proc compact*(cm: CompactionManager) =
acquire(cm.db.lock)