I am writing a grpc code generator.
It generates the normal stuff plus all database crud.

The DBs are only kv ones. Like boltdb and goleveldb. Also Mino fs can be used 
as a kv store.

You model you functions in grpc with a get and set name at the start. This 
allows me to see what is a read and what is a write to the dB.

Now i am ready to implement materialised views.
This allows a change in a base record to trigger an update in a materialised 
view.

So imagine you have 1000 record types. You know from a business perspective 
that you need to have relations between many of the base records. So for a kv 
store you can des eine the materialised view in the grpc using type composition.
This is a nice situation be sure your using type composition at the database 
level too so it's easy to code gen it.

This architecture is really nice for crdt style architectures because a write 
mutation can be designed ribed at the grpc level and the production of the 
materialised views can use that meta data 

My question relates to the best way to do the code to build the materialised 
views.

I figured that something like this is easy to do but i am guessing there are 
many ways of doing this.

-- 
You received this message because you are subscribed to the Google Groups 
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to golang-nuts+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to