Meaning of some annotations

[rvalek]

Hi @EvgSkv !

I'd like to understand what is the function of some of the annotations. Namely, @Flag (I understand what @DefineFlag does though), @NoInject, @With, and @NoWith. Could you give a brief hint on each of those, please?
Also, from what I see in test files, @Make does the same thing as := -- correct?

Much appreciated!
~Robert

[EvgSkv]

Hi @rvalek !
Sure!

• @Flag - not used. Was added a while ago, but never used. So nevermind it.

@NoInject, @With and @NoWith are connected with each other.

Some background: a predicate is called injectible if it's defined with a single non-aggregating conjunctive rule. I.e. single rule that doesn't do aggregation and uses only , logical connective, no |. Injectible predicates can be injected (same as inlined) while compilation, i.e. substituted into the body that calls them. If predicate is implementing a computation rather than a table, like F(x) = 2 * x, then injection is the only way to use it.
However a predicate may be injectible and concrete (i.e. computable as a table) at the same time. Logica injects predicates by default.

• @NoInject - forces predicate not to be injected. This has no impact on the result of the query, just the structure of SQL.

Example:

T(1);
T(2);

R(x + 1) :- T(x);

Q(x * 2) :- R(x);

When Q is compiled we get

WITH t_0_T AS (SELECT * FROM (

    SELECT
      1 AS col0
   UNION ALL

    SELECT
      2 AS col0

) AS UNUSED_TABLE_NAME  )

SELECT
  ((((T.col0) + (1))) * (2)) AS col0
FROM
  t_0_T AS T;

Note that there is no sub-query corresponding to R. This is because it got injected at x+1 went inside the final query.

However if we add @NoInject(R) we will force the explicit subquery.

WITH t_1_T AS (SELECT * FROM (

    SELECT
      1 AS col0
   UNION ALL

    SELECT
      2 AS col0

) AS UNUSED_TABLE_NAME  ),
t_0_R AS (SELECT
  ((T.col0) + (1)) AS col0
FROM
  t_1_T AS T)
SELECT
  ((R.col0) * (2)) AS col0
FROM
  t_0_R AS R;

You can see the t_0_R table there now, which corresponds to R predicate.

• @With, @NoWith - control whether sub-query corresponding to a predicate should be compiled as WITH clause, or be placed as a sub-query in-place. These also have no impact on the result of the program. Annotating a predicate with @With also forces it to not be injected.

Logica puts sub-queries into With by default. So practically it only makes sense to use With to force a predicate not to be injected.
I never had a reason to force @NoWith, but it's there for more control. In the program above adding @NoWith(R) results in the following SQL.

WITH t_0_T AS (SELECT * FROM (

    SELECT
      1 AS col0
   UNION ALL

    SELECT
      2 AS col0

) AS UNUSED_TABLE_NAME  )
SELECT
  ((R.col0) * (2)) AS col0
FROM
  (SELECT
    ((T.col0) + (1)) AS col0
  FROM
    t_0_T AS T) AS R;

Note that R is now defined inside the FROM clause rather than a WITH clause.

• Yes, @Make is doing exactly what := does. Best practice is to use := and never use @Make. Under the hood := compiles into@Make, which was done to keep the core syntax tree definition simple.

Hope this helps. Let me know if you have further questions.

[rvalek]

This is an excellent explanation -- exactly what I was looking for. Thank you for doing this, Evgeniy!
One clarification -- what could be the benefit of using @NoInject, then? In one of the tests it seems to have something to do with ..x:

logica/integration_tests/composite_functor_test.l

Line 35 in 1237d2a

@NoInject(TrafficUS); # We want to use ..r.

[EvgSkv]

Yeah, that example is one situation when you may want @NoInject. It comes from the current weakness of the compiler: it doesn't know how to compile ..r of an injectible predicate.
So for instance this program results in an error if you try to compile Q.

T(1);
T(2);
R(x + 1) :- T(x);
Q(..r) :- R(..r), r.col0 > 1;

Using @NoInject(R) is a workaround that forces the predicate R not to be injected and then you can compile. Another workaround is to just avoid ..r in the definition of Q, querying specific columns of R.

Another, more interesting, situation to use @NoInject (or equivalently @With) is to avoid exponential query growth.
We will consider an artificial example, but similar situations occurred in my practice.

T(1);
T(2);

A(x) :- T(x);
B(x) :- A(x), A(x + 1);
C(x) :- B(x), B(x + 1);
D(x) :- C(x), C(x + 1);
E(x) :- D(x), D(x + 1);
F(x) :- E(x), E(x + 1);
G(x) :- F(x), F(x + 1);
H(x) :- G(x), G(x + 1);

If you compile H, then it will ends up with a very long query, because each predicate depends on the previous predicate called twice.
Adding

@With(A);
@With(B);
@With(C);
@With(D);
@With(E);
@With(F);
@With(G);
@With(H);

does not change semantics of the query, but produces shorter SQL.

Let me know if you have further questions.

[rvalek]

I see, thank you very much, this does clear things up!