MemCP for Microservices - Revision history

Wikiservice: Refresh MemCP documentation: accuracy, operational guidance, performance profile and maintained API reference

2026-08-28T10:14:01Z

Refresh MemCP documentation: accuracy, operational guidance, performance profile and maintained API reference

← Older revision		Revision as of 12:14, 28 August 2026
Line 23:		Line 23:
	The repository's <code>apps/keyvalue.scm</code> example creates a table and parses fixed SELECT/upsert statements once during startup. Each request creates a session, binds the key/value, and evaluates the prepared formula. That avoids parsing and planning the same statement on every request while keeping caller values separate from SQL text.		The repository's <code>apps/keyvalue.scm</code> example creates a table and parses fixed SELECT/upsert statements once during startup. Each request creates a session, binds the key/value, and evaluates the prepared formula. That avoids parsing and planning the same statement on every request while keeping caller values separate from SQL text.

	<~~syntaxhighlight lang="scheme"~~>		<pre>
	(set item_get (parse_sql "keyvalue"		(set item_get (parse_sql "keyvalue"
	"SELECT value FROM kv WHERE key = @key"))		"SELECT value FROM kv WHERE key = @key"))
Line 29:		Line 29:
	"INSERT INTO kv(key, value) VALUES (@key, @value)		"INSERT INTO kv(key, value) VALUES (@key, @value)
	ON DUPLICATE KEY UPDATE value = @value"))		ON DUPLICATE KEY UPDATE value = @value"))
	</~~syntaxhighlight~~>		</pre>

	The complete example installs a request handler and starts its own HTTP listener:		The complete example installs a request handler and starts its own HTTP listener:

	<~~syntaxhighlight lang="scheme"~~>		<pre>
	(createdatabase "keyvalue" true)		(createdatabase "keyvalue" true)
	(eval (parse_sql "keyvalue"		(eval (parse_sql "keyvalue"
Line 56:		Line 56:

	(serve 1266 (lambda (req res) (http_handler req res)))		(serve 1266 (lambda (req res) (http_handler req res)))
	</~~syntaxhighlight~~>		</pre>

	Run the maintained repository version with <code>./memcp apps/keyvalue.scm</code>, store a value using <code>curl --data-binary value http://localhost:1266/key</code>, and retrieve it with <code>curl http://localhost:1266/key</code>. This demonstration intentionally omits production authentication and limits; do not expose it unchanged.		Run the maintained repository version with <code>./memcp apps/keyvalue.scm</code>, store a value using <code>curl --data-binary value http://localhost:1266/key</code>, and retrieve it with <code>curl http://localhost:1266/key</code>. This demonstration intentionally omits production authentication and limits; do not expose it unchanged.

Wikiservice: Refresh MemCP documentation: accuracy, operational guidance, performance profile and maintained API reference

2026-08-28T09:59:33Z

Refresh MemCP documentation: accuracy, operational guidance, performance profile and maintained API reference

Show changes

Carli: Created page with "MemCP is a neat database to implement microservices. Here's a code example for a simple key value store: /* microservice democase: a simple key value store with prepared statements / (import "../lib/sql-parser.scm") (import "../lib/queryplan.scm") / initialize database and prepare sql statements */ (createdatabase "keyvalue" true) (eval (parse_sql "keyvalue" "CREATE TABLE IF NOT EXISTS kv(key TEXT, value TEXT, UNIQUE KEY PRIMARY(key))")) (set item_get (par..."

2024-12-10T19:33:01Z

Created page with "MemCP is a neat database to implement microservices. Here's a code example for a simple key value store: microservice democase: a simple key value store with prepared statements: (import "../lib/sql-parser.scm") (import "../lib/queryplan.scm") initialize database and prepare sql statements: (createdatabase "keyvalue" true) (eval (parse_sql "keyvalue" "CREATE TABLE IF NOT EXISTS kv(key TEXT, value TEXT, UNIQUE KEY PRIMARY(key))")) (set item_get (par..."

New page

MemCP is a neat database to implement microservices.

Here's a code example for a simple key value store:
/* microservice democase: a simple key value store with prepared statements */
(import "../lib/sql-parser.scm")
(import "../lib/queryplan.scm")

/* initialize database and prepare sql statements */
(createdatabase "keyvalue" true)
(eval (parse_sql "keyvalue" "CREATE TABLE IF NOT EXISTS kv(key TEXT, value TEXT, UNIQUE KEY PRIMARY(key))"))

(set item_get (parse_sql "keyvalue" "SELECT value FROM kv WHERE key = @key"))
(set item_set (parse_sql "keyvalue" "INSERT INTO kv(key, value) VALUES (@key, @value) ON DUPLICATE KEY UPDATE value = @value"))
/*(set item_list (parse_sql "keyvalue" "SELECT key, value FROM kv"))*/

(define http_handler (begin
(lambda (req res) (begin
(set session (newsession))
(session "key" (req "path"))
(if (equal? (req "method") "GET") (begin
/* GET = load */
(set resultrow (lambda (resultset) ((res "print") (resultset "value"))))
(eval item_get)
) (begin
/* PUT / POST: store */
(session "value" ((req "body")))
(eval item_set)
((res "print") "ok")
))
))
))

(set port 1266)
(serve port (lambda (req res) (http_handler req res)))
The example can be found in <code>apps/keyvalue.scm</code> and can be run with:
./memcp apps/keyvalue.scm
Here's a benchmark of a mini-demo on a AMD Ryzen 9 7900X3D 12-Core Processor using <code>ab</code>benchmark tool:
Server Software:
Server Hostname: localhost
Server Port: 1266

Document Path: /hi
Document Length: 5 bytes

Concurrency Level: 10
Time taken for tests: 42.083 seconds
Complete requests: 1000000
Failed requests: 0
Total transferred: 106000000 bytes
HTML transferred: 5000000 bytes
Requests per second: 23762.78 [#/sec] (mean)
Time per request: 0.421 [ms] (mean)
Time per request: 0.042 [ms] (mean, across all concurrent requests)
Transfer rate: 2459.82 [Kbytes/sec] received

Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 0 0.0 0 1
Processing: 0 0 0.1 0 1
Waiting: 0 0 0.1 0 1
Total: 0 0 0.1 0 2

Percentage of the requests served within a certain time (ms)
50% 0
66% 0
75% 0
80% 0
90% 0
95% 1
98% 1
99% 1
100% 2 (longest request)
It is noteworthy that <code>ab</code>even with a concurrency level of 10 took 100% CPU load on a single core while <code>memcp</code> took a cool portion of 20% of all other cores. So the benchmark tells more about <code>ab</code>s performance than that of MemCP.