With one important exception, file views derived from any file mapping object that is backed by the same file are coherent or identical at a specific time. Coherency is guaranteed for views within a process and for views that are mapped by different processes.

The exception is related to remote files. Although CreateFileMapping works with remote files, it does not keep them coherent. For example, if two computers both map a file as writable, and both change the same page, each computer only sees its own writes to the page. When the data gets updated on the disk, it is not merged.

a http webserver that more like asm scripting engine

This doesn't appear to be any sort of "breakthrough" as you put it. It is just like the standard DB access that every DB engine offers.

BTW: It is also really really slow.

+1 from me. super cool idea Idea
fasm compiler online with feedback on local procs something using RPC (remote procedure call) and revisiting
the protocol if necessary.
Cheers,

// server main loop
WHILE Server_Is_Running
    FOR EACH Client IN Connected_Clients
        // did the client send a READ/WRITE command?
        Read = recv (Client, Cmd_Buffer, CMD_SIZE)
        IF Read == CMD_SIZE THEN
            IF Cmd_Buffer == CMD_READ THEN
                // get the parameters (offset) and (size)
                Read0 = recv (Client, Param_Offset_Buffer, PARAM_SIZE)
                Read1 = recv (Client, Param_Size_Buffer, PARAM_SIZE)
                IF Read0 == PARAM_SIZE && Read1 == PARAM_SIZE THEN
                    // give the client the requested portion of memory
                    send (Client, Cmd_Buffer, CMD_SIZE)
                    send (Client, Param_Offset_Buffer, PARAM_SIZE)
                    send (Client, Param_Size_Buffer, PARAM_SIZE)
                    send (Client, Mapped_File_View_Ptr + Param_Offset_Buffer, Param_Size_Buffer)
                END IF
            ELSE IF Cmd_Buffer == CMD_WRITE THEN
                // get the parameters (offset) and (size)
                Read0 = recv (Client, Param_Offset_Buffer, PARAM_SIZE)
                Read1 = recv (Client, Param_Size_Buffer, PARAM_SIZE)
                IF Read0 == PARAM_SIZE && Read1 == PARAM_SIZE THEN
                    // get the parameter (data) to write
                    Read = recv (Client, Data_Buffer, Param_Size_Buffer)
                    IF Read == Param_Size_Buffer THEN
                        // update the memory
                        CopyMemory (Mapped_File_view_Ptr + Param_Offset_Buffer, Data_Buffer, Param_Size_Buffer)
                        // Tell all clients of the updated portion of the memory
                        FOR EACH c IN Connected_Clients
                            send (c, Cmd_Buffer, CMD_SIZE)
                            send (c, Param_Offset_Buffer, PARAM_SIZE)
                            send (c, Param_Size_Buffer, PARAM_SIZE)
                            // choose whether you want clients to receive updated data automatically
                            // or if they should just be notified and have to request the data
                            send (c, Data_Buffer, Param_Size_Buffer)
                        END FOR
                    END IF
                END IF
            END IF
        END IF
    END FOR
END WHILE
    

{Read|Write}{Offset}{Size}{Data}
    

{Offset} {Size|-Size} {Data}