New rule. Any sufficiently advanced type system is an ad-hoc re-implementation of Prolog. Once you have unification and backtracking you basically have Prolog and can implement whatever Turing machine you want with the type system.
Getting to grasp logic programming would improve your skills, even if you never use Prolog again.
Use SWI-Prolog, one of the best free implementations out there.
It is debatable if Datalog is enough or if cuts et al are worthwhile.
So the argument is that it is a similar eye-opening transition from ignorance to awareness.
I seldom use an ORM, I rather leave the work for the database engine.
My knowledge of PL/SQL, Transact-SQL, PL/pgSQL is way better than trying to make an ORM perform better.
Something like Dapper.NET or jOOQ are good enough for the remaining part of the work.
Example https://unify.ly5.ch/ (Caveat: it's an old implementation)
"Writing custom type systems for Python in Prolog"
The best days are when Niko posts about his work on Rust. Always interesting and they often exploit the power behind ideas like "It's basically Prolog" instead of apologizing for it. It's exciting and the kind of thinking that makes me remember why I fell in love with programming in the first place.
Accidentally Turing Complete type systems are usually not all that pleasant in practice. Examples: C++ Templates, and now it seems, Rust.
EDIT: Just because people may not know this: A relevant quote by Alan Perlis: "Beware of the Turing tar-pit in which everything is possible but nothing of interest is easy." This applies to type-level programming as it does any type of programming.
EDIT#2: Also, look into Shen for a principled way to do this type of thing.
If instead I add to the mix prolog, (or a prolog interpreter?) this will help a lot, or not worth the effort?
There is also a F# implementation, https://github.com/palladin/logic