Can I find somewhere more specific infos, about what is already supported by the postgresql backend?

[v217]

I did run the psql examples successfully!
I am learning about logica, so if something does not work it is helpful, if there is a way to tell if that's my error or the feature is not ported yet.
(One workaround is to look at the generated sql code, but still it would be nice to have more specific info.)
By the way the error messages are great, so this question is mostly out of curiosity.
Thanks!

[EvgSkv]

Congrats on running the examples! :-)

We do need a better support for PostgreSQL, including clear documentation on supported features. We don't have it right now.

These are the biggest things that are missing (and we are aware of):

• Output of structures is not supported. E.g. with "psql" engine currently you can't do
  Q(contact: {name: "John", email: "connor@gmail.com"});
  This is because PostgreSQL requires pre-defining types before using the structs and this is not implemented.
• ArgMaxK is ignoring the limit, so picking a few maximal values from a very large set is impossible. We don't know how to fix this, as PostgreSQL does not support LIMIT in ARRAY_AGG.
• No work on specifying PostgreSQL built-in functions was done. So if the function is not available in BigQuery SQL then user has to define it using "SqlExpr" function.

We would be happy to accept contributions addressing these issues.

[v217]

Good to know! Thanks!

[v217]

If that's OK I will start two issues with the first two points. Or better one generic issue 'Postgresql support' ?

[v217]

A completely different question.
I was very inspired by this blog post by Bill Wadge about 'extensional higher order prolog' (hopes).
How would you translate this higher order map relation for an arbitrary relation R (eg. >) from standard higher order prolog/datalog to logica.

map(R,[],[]).
map(R,[X|Xs],[Y|Ys]) :- R(X,Y), map(R,Xs,Ys).

Thanks, if I know howto translate this to logica, I think, I can translate the other examples to logica myself.

[EvgSkv]

PostgreSQL

Yes, let's start a generic 'PostgreSQL support' and we can create sub-issues later when we plan specific next steps.

Higher order predicates

This is a nuanced question. First of all: the syntax used in the snippet above is not supported in Logica. A predicate can not take a another predicate as an argument and apply it.

But a lot of functionality that is implemented with higher order functions/predicates can be done naturally in Logica.
For instance the map functionality, and generically list comprehension itself can be implemented using aggregation.

For example Double functional predicate implemented below returns an input list, where all elements are doubled. It would be a canonical usecase of the map function from your example.

Double(input_list) = output_list :-
  output_list List= (2 * x :- x in input_list)

Furthermore there is a special syntax for creating functions that operate over predicates. Currently there are limitations on what kind of functions you can implement, but we find that it covered practical needs that we had.

For instance if you want to create a function that takes in a predicate that describes a set of numbers and doubles them you can do it as follows.

# This is a functor, of an argument Arg that returns a predicate having
# all values of predicate Arg doubled.
DoublePredicate(2 * x) :- Arg(x);

S(1);
S(2);
S(5);

# Applying DoublePredicate to S. Result will contain numbers {2, 4, 10}.
DoubleS := DoublePredicate(Arg: S);

Functors can only be applied at the top level, applying them to predicates already defined. They are implemented by simple substitution.

I'm happy to discuss this in further details, feel free to start a new thread, as this may be interesting to many users.

Thanks again for your interest!

[v217]

Thank you!
This post clarified a lot my understanding of the two approaches.