CharlesKWON
d98f5e1767
First end-to-end working version of the PostgreSQL-wire-compatible
TCP server frontend. A standard `psql` client now connects, runs
`SELECT * FROM employees`, and gets back a properly typed result
set rendered by psql with the right column alignment:
ID | NAME | SALARY
----+----------------------+----------
1 | Alice | 50000.00
2 | Bob | 42000.50
3 | Cho | 77500.00
This is the Phase 2 deliverable from the approved plan at
/Users/charleskwon/.claude/plans/compiled-launching-shore.md.
Builds on the session-state refactor in 93cf5c8 — each connection
gets its own TSqlSession on the PRG side via the new PG_NEW_SESSION
HB_FUNC, so concurrent psql clients won't share transaction logs
or plan caches.
Scope
-----
v1.0 MVP: Simple Query only, trust auth, no TLS yet. SELECT works
against the full FiveSql2 surface (CTEs, window functions, JOINs,
aggregates). DML + per-session transactions are Phase 3, extended
protocol is Phase 4, auth + TLS are Phases 5/6.
Architecture
------------
psql/pgx/JDBC ──TCP:5432──▶ pgserver.Listener
│ accept()
▼ go handleConn(net.Conn)
┌─────────────────────────────┐
│ Session goroutine │
│ 1. SSLRequest peek │
│ 2. StartupMessage │
│ 3. AuthenticationOk (trust) │
│ 4. ParameterStatus×7 │
│ 5. BackendKeyData │
│ 6. ReadyForQuery('I') │
│ 7. loop: Receive() → │
│ dispatchSimpleQuery → │
│ hbrt.Thread.Function( │
│ FIVE_SQL,sql,...,sess) │
│ emit RowDescription │
│ emit DataRow×N │
│ emit CommandComplete │
│ emit ReadyForQuery │
└─────────────────────────────┘
One goroutine per connection, each owning its own *hbrt.Thread and
TSqlSession instance. Uses the existing audit-fixed NewThread()
(cde8673) so statics + WA factory propagate.
New files (hbrtl/pgserver/)
---------------------------
* server.go — Config, Server, Serve loop with MaxConnections gate
via semaphore, Close drains in-flight sessions.
* session.go — full lifecycle: SSLRequest peek + prefixedConn
byte-injection trick for StartupMessage, ParameterStatus
broadcast (server_version "14.0 (FiveSql2)" so pgx negotiates),
BackendKeyData (random pid+secret per session, no CancelRequest
yet), query loop dispatching only Simple Query in v1.0 with a
loud "0A000 not supported" for Extended messages.
* dispatch.go — runSQL invokes FIVE_SQL via PushSymbol+Function,
unpacks the engine's `{aFieldNames, aRows}` envelope or the
`{{"__error__"}, {{nCode, cMsg, cSQL}}}` error shape, emits
RowDescription with text-format OIDs and DataRow per row.
* typemap.go — pgTypeFor() picks INT4 / INT8 / NUMERIC / TEXT /
DATE / TIMESTAMP / BOOL by sampling the first row's value type;
encodeText() formats each cell, returning nil-slice for NULL
(the PG length=-1 convention).
* errmap.go — sqlStateFor() maps FiveSql2 SQL_ERR_* codes to
canonical PG SQLSTATEs (42601/42P01/42703/42804/23505/23514/
23503/25P02/42501/02000/XX000).
* auth.go — trust mode in v1.0; password/MD5/SCRAM lands Phase 5
but the dispatch sentinel is already in place.
* tls.go — upgradeToTLS stub for SSLRequest handling; the byte-
ordering is already wired so Phase 6 just plugs in tls.Config.
* register.go — package init() registers pg_server_start /
pg_server_stop HB_FUNCs. Importing the package (done from
hbrtl/register.go via blank import) is enough to enable them.
* pgserver_test.go — unit tests for encodeText (numeric, string,
NIL), pgTypeFor (OID dispatch), sqlStateFor (error mapping),
commandTagFor (SELECT/INSERT/UPDATE/DELETE/BEGIN/COMMIT).
Other changes
-------------
* _FiveSql2/src/TSqlSession.prg — added PG_NEW_SESSION() factory
used by the Go dispatcher to allocate a per-connection session
bypassing the embedded process default.
* hbrtl/register.go — blank-import five/hbrtl/pgserver so its
init() fires and the HB_FUNCs land in the global dynamic-func
table for VM symbol lookup.
* go.mod / go.sum — github.com/jackc/pgx/v5 v5.9.2 (pgproto3
subpackage). MIT license. Same library pgx itself uses, so
protocol coverage matches the de-facto Go PG ecosystem.
Verification
------------
$ pg_server_start(15432, "trust") /* PRG one-liner */
$ psql -h 127.0.0.1 -p 15432 -U fiveuser -c 'SELECT * FROM employees'
→ 3 rows rendered correctly by psql (ID as INT4, NAME as TEXT,
SALARY as NUMERIC(10,2) with 2 decimal places)
All six release gates green:
go test ./... ✓ (incl. new hbrtl/pgserver tests)
FiveSql2 SQL:1999 43/43 ✓
Harbour compat 56/56 ✓
std.ch 17/17 ✓
FRB 7/7 ✓
examples 65/71 ✓ (unchanged baseline)
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
87 lines
2.2 KiB
Go
87 lines
2.2 KiB
Go
// Copyright (c) 2026 Charles KWON OhJun (charleskwonohjun@gmail.com)
|
|
// All rights reserved.
|
|
|
|
package pgserver
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"strconv"
|
|
|
|
"five/hbrt"
|
|
)
|
|
|
|
// init wires the PG-server entry points into the runtime as
|
|
// HB_FUNCs. Importing this package (e.g. via _ "five/hbrtl/pgserver"
|
|
// from hbrtl's bootstrap) is enough; PRG code then sees:
|
|
//
|
|
// pg_server_start( nPort | cAddr [, cAuthMode ] )
|
|
// → starts server, blocks
|
|
// (call inside SPAWN to keep
|
|
// the calling thread free)
|
|
// pg_server_stop() → closes the active server
|
|
//
|
|
// Embedded callers compose this with their own DBF setup:
|
|
//
|
|
// #include "FiveSqlDef.ch"
|
|
// PROCEDURE Main()
|
|
// USE customers SHARED
|
|
// USE orders SHARED NEW
|
|
// pg_server_start( 5432 ) /* blocks; psql can now connect */
|
|
// RETURN
|
|
func init() {
|
|
hbrt.HB_FUNC("PG_SERVER_START", pgServerStart)
|
|
hbrt.HB_FUNC("PG_SERVER_STOP", pgServerStop)
|
|
}
|
|
|
|
func pgServerStart(ctx *hbrt.HBContext) {
|
|
listen := ":5432"
|
|
if ctx.PCount() >= 1 {
|
|
if ctx.IsNumeric(1) {
|
|
listen = ":" + strconv.Itoa(ctx.ParNI(1))
|
|
} else if ctx.IsChar(1) {
|
|
listen = ctx.ParC(1)
|
|
}
|
|
}
|
|
cfg := Config{Listen: listen}
|
|
if ctx.PCount() >= 2 && ctx.IsChar(2) {
|
|
cfg.AuthMode = ctx.ParC(2)
|
|
}
|
|
srv := NewServer(ctx.T.VM(), cfg)
|
|
setActiveServer(srv)
|
|
fmt.Fprintf(os.Stderr, "pgserver: listening on %s (auth=%s)\n",
|
|
cfg.listenAddr(), defaultStr(cfg.AuthMode, "trust"))
|
|
if err := srv.Serve(context.Background()); err != nil {
|
|
fmt.Fprintf(os.Stderr, "pgserver: %v\n", err)
|
|
}
|
|
ctx.RetNil()
|
|
}
|
|
|
|
func pgServerStop(ctx *hbrt.HBContext) {
|
|
if srv := takeActiveServer(); srv != nil {
|
|
_ = srv.Close()
|
|
}
|
|
ctx.RetNil()
|
|
}
|
|
|
|
func defaultStr(s, fallback string) string {
|
|
if s == "" {
|
|
return fallback
|
|
}
|
|
return s
|
|
}
|
|
|
|
// activeServer tracks the most recently started server so
|
|
// pg_server_stop() can find it without the PRG layer needing to
|
|
// hold a handle. v1.0 is single-server-per-process; a future
|
|
// upgrade can swap this for a slice.
|
|
var activeServerSlot *Server
|
|
|
|
func setActiveServer(s *Server) { activeServerSlot = s }
|
|
func takeActiveServer() *Server {
|
|
s := activeServerSlot
|
|
activeServerSlot = nil
|
|
return s
|
|
}
|