In-Database WebApps and REST Services - Revision history

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

2026-08-28T10:13:58Z

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

← Older revision		Revision as of 12:13, 28 August 2026
Line 9:		Line 9:
	== Routing a path prefix ==		== Routing a path prefix ==

	<~~syntaxhighlight lang="scheme"~~>		<pre>
	(define http_handler (begin		(define http_handler (begin
	(set old_handler http_handler)		(set old_handler http_handler)
Line 19:		Line 19:
	((res "print") "{\"ok\":true}"))		((res "print") "{\"ok\":true}"))
	(old_handler req res))))))		(old_handler req res))))))
	</~~syntaxhighlight~~>		</pre>

	Always delegate unmatched paths to the previous handler. Replacing the global handler without chaining it can hide the dashboard, SQL endpoints, or routes installed by other modules.		Always delegate unmatched paths to the previous handler. Replacing the global handler without chaining it can hide the dashboard, SQL endpoints, or routes installed by other modules.
Line 29:		Line 29:
	Parse and optimize fixed SQL outside the request hot path where practical; bind request values rather than concatenating untrusted SQL. The exact request/response functions are documented in [[IO]] and examples under <code>apps/</code>.		Parse and optimize fixed SQL outside the request hot path where practical; bind request values rather than concatenating untrusted SQL. The exact request/response functions are documented in [[IO]] and examples under <code>apps/</code>.

	<~~syntaxhighlight lang="scheme"~~>		<pre>
	(set find_user (parse_sql "myapp"		(set find_user (parse_sql "myapp"
	"SELECT id, name FROM users WHERE id = @user_id"))		"SELECT id, name FROM users WHERE id = @user_id"))
Line 38:		Line 38:
	(set resultrow (res "jsonl"))		(set resultrow (res "jsonl"))
	(eval find_user)		(eval find_user)
	</~~syntaxhighlight~~>		</pre>

	Prepared formulas capture a fixed query shape, not permission to trust their parameters. Validate request types, authorize the selected record, and do not let callers choose arbitrary identifiers. Stream rows when possible; do not collect an unbounded result merely to turn it into one JSON array.		Prepared formulas capture a fixed query shape, not permission to trust their parameters. Validate request types, authorize the selected record, and do not let callers choose arbitrary identifiers. Stream rows when possible; do not collect an unbounded result merely to turn it into one JSON array.

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

2026-08-28T09:59:29Z

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

@@ Line 1: / Line 1: @@
-In-Database WebApps are a huge game changer in REST API performance since the web app runs in the same context as the
+<!-- Copyright (C) 2026 Carl-Philip Haensch -->
-== REST Endpoint setup ==
+Embedded handlers run in the MemCP process and can access Scheme and storage APIs without a separate database connection. <code>lib/main.scm</code> defines <code>http_handler</code>; application modules can wrap the previous handler and route only their own path prefix.
-For more details, take a look at [[Scheme: serve|HTTP Server]].
+This is useful for small JSON APIs, dashboards, webhooks, static assets, or WebSocket gateways whose hot path is mostly database work. It reduces deployment pieces and transport overhead, but also couples application code to the database process. Keep CPU-heavy, blocking, untrusted, or independently deployed workloads outside MemCP.
-== Including SQL or RDF queries in your custom REST endpoint ==
+== Routing a path prefix ==
-* <code>(parse_sparql schema query)</code> to create the code for a SPARQL query
+<syntaxhighlight lang="scheme">
-* <code>(parse_sql schema query)</code> to create the code for a SQL query
+(define http_handler (begin
-Basically, you do the parsing and preparation outside of your HTTP handler in order to get the best performance out of prepared statements.
+Always delegate unmatched paths to the previous handler. Replacing the global handler without chaining it can hide the dashboard, SQL endpoints, or routes installed by other modules.
-In the last step, you overwrite the query parameters as well as the function <code>resultrow</code> in your scope and then feed the code into <code>eval</code>:
+The request object exposes method, host, path, query fields, headers, username/password, remote address, and lazy body readers. The response object sets headers and status, writes text/lines or JSONL rows, and can upgrade a connection to WebSocket. See [[IO]] for the generated function reference and <code>apps/</code> for executable examples.
-== Example WebApps ==
+== Prepared SQL and response streaming ==
-You find a complex example of a RDF browser and whole template engine in:
+Parse and optimize fixed SQL outside the request hot path where practical; bind request values rather than concatenating untrusted SQL. The exact request/response functions are documented in [[IO]] and examples under <code>apps/</code>.
-https://github.com/launix-de/rdfop
+<syntaxhighlight lang="scheme">
-Another example can be found in [[Websockets in MemCP]]
+/* inside a request handler */

Carli: /* Example WebApps */

2024-10-08T20:54:24Z

Example WebApps

← Older revision		Revision as of 22:54, 8 October 2024
Line 55:		Line 55:

	https://github.com/launix-de/rdfop		https://github.com/launix-de/rdfop

			Another example can be found in [[Websockets in MemCP]]

Carli: Carli moved page In-Database WebApps to In-Database WebApps and REST Services

2024-05-19T13:46:23Z

Carli moved page In-Database WebApps to In-Database WebApps and REST Services

← Older revision

Revision as of 15:46, 19 May 2024

Carli: /* Including SQL or RDF queries in your custom REST endpoint */

2024-05-19T13:44:50Z

Including SQL or RDF queries in your custom REST endpoint

← Older revision		Revision as of 15:44, 19 May 2024
Line 45:		Line 45:

	/* now inside your HTTP handler: */		/* now inside your HTTP handler: */
	(set resultrow (~~req~~ "jsonl")) /* this is the jsonl printer, but you can also use print or any lambda that takes a associative array with the results */		(set resultrow (res "jsonl")) /* this is the jsonl printer, but you can also use print or any lambda that takes a associative array with the results */
	(eval my_code) /* execute query */		(eval my_code) /* execute query */
	To read on how to handle the result object, take a look at: [[Lists and Objects]]		To read on how to handle the result object, take a look at: [[Lists and Objects]]

Carli: Created page with "In-Database WebApps are a huge game changer in REST API performance since the web app runs in the same context as the == REST Endpoint setup == You basically set up a REST endpoint by overwriting the `http_handler` variable in the global scope. Best practice is here to overload http_handler, store the old handler in `old_handler` and cascade the router with a prefix: (define http_handler (begin (set old_handler (coalesce http_handler han..."

2024-05-19T09:08:30Z

Created page with "In-Database WebApps are a huge game changer in REST API performance since the web app runs in the same context as the == REST Endpoint setup == You basically set up a REST endpoint by overwriting the <code>http_handler</code> variable in the global scope. Best practice is here to overload http_handler, store the old handler in <code>old_handler</code> and cascade the router with a prefix: (define http_handler (begin (set old_handler (coalesce http_handler han..."

New page

In-Database WebApps are a huge game changer in REST API performance since the web app runs in the same context as the

== REST Endpoint setup ==
You basically set up a REST endpoint by overwriting the <code>http_handler</code> variable in the global scope. Best practice is here to overload http_handler, store the old handler in <code>old_handler</code> and cascade the router with a prefix:
(define http_handler (begin
(set old_handler (coalesce http_handler handler_404))

/* here starts our custom router */
(lambda (req res) (begin
/* hooked our additional paths to it */
(match (req "path")
(regex "^/my_prefix(.*)$" url subpath) (begin
(my_custom_handler req res path)
)
/* default */
(old_handler req res))

))
))
Now you can implement your own custom handler:
(define my_custom_handler (lambda (req res subpath) (begin
/* print hello world */
((res "header") "Content-Type" "text/html")
((res "status") 200)
((res "print") "<nowiki><h1>Hello World</h1></nowiki>")
)))
Now you can query your endpoint with:
curl <nowiki>http://localhost:4321/my_prefix</nowiki>
In your custom handler, you can again parse your subpath to go to the single routes.

For more details, take a look at [[Scheme: serve|HTTP Server]].

== Including SQL or RDF queries in your custom REST endpoint ==
The SQL and RDF frontend have helper functions:

* <code>(parse_sparql schema query)</code> to create the code for a SPARQL query
* <code>(parse_sql schema query)</code> to create the code for a SQL query

Basically, you do the parsing and preparation outside of your HTTP handler in order to get the best performance out of prepared statements.

In the last step, you overwrite the query parameters as well as the function <code>resultrow</code> in your scope and then feed the code into <code>eval</code>:
(set my_code (parse_sql "my_database" "SELECT * FROM a"))
(set my_code (optimize my_code)) /* optionally run the optimizer over it */

/* now inside your HTTP handler: */
(set resultrow (req "jsonl")) /* this is the jsonl printer, but you can also use print or any lambda that takes a associative array with the results */
(eval my_code) /* execute query */
To read on how to handle the result object, take a look at: [[Lists and Objects]]

== Example WebApps ==
You find a minimal example in the apps/ folder in the memcp sources.

You find a complex example of a RDF browser and whole template engine in:

https://github.com/launix-de/rdfop