Object-relational mapping continues to be well talked about, including on here. I've knowledge about a couple of approaches and also the issues and compromises. True resolution appears enjoy it requires changes towards the OO or relational models themselves.

If utilizing a functional language, does exactly the same problem present itself? It appears in my experience these too paradigms should fit together much better than OO and RDBMS. The thought of thinking in takes hold an RDBMS appears to mesh with automatic parallelism that functional approaches appear to promise.

Does anybody have interesting opinions or experience? What is the condition of participate in the industry?

I've not done functional-relational mapping, per sé, but I have tried personally functional programming strategies to accelerate use of an RDBMS.

Extremely common to begin with a dataset, perform some complex computation onto it, and keep results, in which the answers are a subset from the original with a lot more values, for instance. The imperative approach dictates that you simply store your initial dataset with extra NULL posts, do your computation, then update the records using the calculated values.

Appears reasonable. The main problem with that's it may end up with slow. In case your computation requires another SQL statement aside from the update query itself, as well as must be completed in application code, you literally need to (re-)look for the records that you're altering following the computation to keep your leads to the best rows.

You will get for this simply by developing a new table for results. By doing this, you can easily always place rather than update. You finish up getting another table, copying the secrets, however, you no more have to waste space on posts storing NULL -- you simply store that which you have. After this you join your leads to one last choose.

I (ab)used an RDBMS by doing this and wound up writing SQL claims that looked mostly such as this...

create table temp_foo_1 as select ...;
create table temp_foo_2 as select ...;
...
create table foo_results as
  select * from temp_foo_n inner join temp_foo_1 ... inner join temp_foo_2 ...;

What this really is basically doing is creating a lot of immutable bindings. The excellent factor, though, is that you could focus on entire sets at the same time. Type of reminds you of languages that allow you to use matrices, like Matlab.

I picture this would also permit parallelism much simpler.

An additional perk is the fact that kinds of posts for tables produced by doing this needn't be specified since they're deduced in the posts they are selected from.

I'd guess functional to relational mapping ought to be simpler to produce and employ than OO to RDBMS. As lengthy while you only query the database, that's. I do not really see (yet) how you could do this database updates without unwanted effects inside a nice way.

The primary problem I see is performance. The modern RDMS are not shipped for use with functional queries, and can most likely behave poorly in a number of cases.

I'd believe that, as Mike pointed out, when the DB ought to be up-to-date, exactly the same concurrency issues need to be faced just like OO world. The running character from the program could maybe be even a bit more problematic compared to object character due to the condition of information, transactions etc from the RDBMS.

However for reading through, the running language may well be more natural with a few problem domain names (because it appears to become no matter the DB)

The running<->RDBMS mapping shouldn't have any large variations to OO<->RDMBS mappings. However I believe that that is dependent a great deal on which type of data types you need to use, if you wish to create a program having a completely new DB schema or to behave against a legacy DB schema, etc..

The lazy brings etc for associations for instance could most likely be implemented quite nicely with a few lazy evaluation -related concepts. (Despite the fact that they may be done quite nicely with OO also)

Edit : With a few searching I discovered HaskellDB (SQL library for Haskell) - that may be really worth trying?

Hard problems of stretching the relational database are extended transactions, data-type mismatches, automated query translation and such things as N+1 Choose which are fundamental problems of departing the relational system and -- for me -- don't change by altering the receiving programming paradigm.