To take CREATE VIEW one step further, I was dreaming about something like this - given guaranteed always on network connectivity with plentiful bandwidth (I know, unrealistic, but just follow me for a moment), imagine that the view actually existed in the software layer separated by the network from the database. That the view could exist on the client, but the data on the server at all times. This is what I mean by disconnected - not so much that the data has to live on the client, but that the view is not database-resident.
Imagine running a CREATE VIEW statement that actually created an access method to the database that LOOKED like an object model. Heck, should be no problem, after all this is kind of what ORMs are trying to do - create an updateable "view" of the database for the client to use to update the server. Heck, here's a crazy idea - why can't the server update the "view" in the client, if we always had an open connection (see long polling?). Well, at least if the impedence mismatch of needing SQL to get from the code to the database was not there (rather an "object interface"), things are a little nicer.
Also, imagine a dynamic object, for example - one in which you can just set the value of a property, but in the programming environment, you can intercept that operation and see oh, look, this is Person # 123 and the property Last Name is being set, why, I'll go update the database while I update the object. Imagine all changes to data in objects going straight through to the database instead of going through a complex ORM layer (yes, of course, too much traffic to the database with millions of little writes?). This is what happens when the database, and the code, are directly connected. And no, the object doesn't have to LOOK like the database, although it can. Just like a view doesn't need to look like the tables it represents, although it can. Also note, updateable views are possible when a SQL engine can determine how to decompose an update and update related tables (although almost no database can do it when there are joins involved). So updateable objects that work like views seem totally doable. Ironically, already kind of done if you consider MUMPS for example, which had persistent storage by simply going: SET ^Person("123","LastName")="Bob", right in the language itself - just didn't look like a strongly typed object.
Ironically, I am actually a strong relational supporter, and have personally built at least one major relational database that scaled up to several terabytes in the area of large scale fraud detection. So, I am familiar with, and have a deep respect for Boyce, Codd, Chris Date, the relvar, relational algebra and set logic, Inmon, Kimball, data warehousing, OLTP vs OLAP, to name a few.
I am not a "node.js" front-end web cowboy with no understanding of database technology..... and boy, did I have my fill of database replication, in SQL Server, specifically. It worked, but it could be a bear at times. I urge you - if you haven't looked into what the latest distributed relational databases can do (or even go back to Teradata which is expensive but has a long history of distributed scaling) - ACID is totally possibly, performance can be increased, and it's nowhere near as difficult as replication - it DOES work. It turns out that relational operations work really well at being decomposed and distributed in a similar fashion to map/reduce algorithms (see the work of the late Dr Jim Gray, a former top database researcher from Microsoft).
Furthermore, I am currently working a job using a legacy MULTIVALUE database - for fun, if you haven't read up on Pick/D3 or OpenQM, check them out. Most people don't even know what a MV database is, but to understand where I'm coming from, you'd need to know more about the history of what well could have been if a few technology choices had been different in the past. Not to say I'm unhappy with how things did turn out - I think every technology is unique and interesting, but I have a fairly reasonably different viewpoint because of working with older technologies, and newer ones both.
I also agree that, I personally feel that the acronym NoSQL (which we have been told really means "Not Only SQL") was actually really something different, a bit of an underhanded jab - I think they should have called in NoRelational - because that to me seems to be a deeper crux of what is really going on here. After all, SQL is a query language - who cares what database it runs against (although it clearly was designed with relations in mind), but that doesn't mean it necessarily had to run against a relational database. Ultimately, NoSQL is another technology for the toolbag, and a new direction for people to research.
I am interested in what could be (as evidenced by my "dreaming"). I see, based on our short memory of past history, our long recent successes with relational databases, and the new developments in NoSQL databases, a new possibility - some sort of hybrid which is a mix of technologies, and something that truly can achieve a lot of aims that we all have (distributed systems, connectivity, less mismatch, data integrity, etc). And I see this possibility manifested in the kind of thought that happened in this Opa project. New thought should be encouraged, not discouraged, and hopefully, these new thoughts root themselves in solid solutions and learn from the past as much as they look to the future.