FWD » Core Development » Database

We need to create test cases with OO expressions in the WHERE clause of a query/FIND/FOR/etc., which does not reference the current buffer. These should convert such that the OO expression is refactored into a query substitution parameter.

Constantin, I understand you discovered a problem with this. Do you already have a test case to start with?

I think the issue is that we don't emit as lambda the OO expression. Take this test:

for each tt1 where tt1.f1 = func1(1):
  message "d" tt1.f1.
end.

         forEach("loopLabel3", new Block((Init) () -> 
         {
            query3.initialize(tt1, "tt1.f1 = ?", null, "tt1.recid asc", new Object[]
            {
               (P2JQuery.Parameter) () -> func1(new integer(1))
            });
         }, 

Note how a lambda is emitted.

Now, for OO case:

for each tt1 where tt1.f1 = oo.Foo:m2(1):
  message "a" tt1.f1.
end.

         forEach("loopLabel0", new Block((Init) () -> 
         {
            query0.initialize(tt1, "tt1.f1 = ?", null, "tt1.recid asc", new Object[]
            {
               com.goldencode.testcases.oo.Foo.m2(new integer(1))
            });
         }, 

From this, other tests where instance methods or both operands are OO calls can be written.

Gentlemen, I couldn't figure out details of the conversion procedure. So, anyone who has time and knowledge is more than welcome to enlighten me :)

What I know/did so far:

I created test cases to simulate the difference as described above. I understand the conversion goes through stages (preprocessor, lexer, parser, ASTs) and results of individual stages are stored next to the original *.p file as *.lexer, *.parser, *.jast, etc. The stages are defined in ConversionDriver and more steps in TransformDriver.

Then there are rule sets in /rules/, but I am not sure how they participate in the conversion. Are they only used for code validation/analysis (incorrect code triggers rules) or they actually generate the resulting code at some point?

Anyway, I can see that *.jast file already contains the transformed code including the difference described in this task. What I don't understand is what part of our code decided this difference should be there. Any guidance greatly appreciated!

Boris, first, run conversion with -Drules.tracing=true. Use this for both the OO and non-OO tests.

You can look at the .ast and .jast file for the non-OO test, and there will be annotations which have the byRule text in them - this will specify which TRPL rule (from rules/) was responsible for emitting that AST node. So, looking at the lambda AST in the .jast file, you can find the .rules file which generated this. You can analyze and backtrack from there.

Otherwise, the TRPL code in rules/ folder is responsible for interpreting the parsed .ast, annotating it, and finally generating the .jast and the .java code.

You must include Foo.cls in your conversion list.

Constantin Asofiei wrote:

You must include Foo.cls in your conversion list.

But it's already reported as being parsed:

   Lvl01 parse: ./oo/foo.cls
   ...
   Lvl01 DONE:  ./oo/foo.cls

Nevertheless, it does the trick :)

Thank you, Constantin!

It is parsed because it is referenced elsewhere. As I've noted previously via email, just because it is parsed doesn't mean that it is added automatically to the conversion list. At this time you MUST explicitly include every non-skeleton class/interface/enum in the referenced object graphs of all converted classes or procedures. See #6082 for the task where we fix this. Until then, add everything referenced.

The change looks good. Please post a sample of the 4GL and generated code where the OO method is involved.

I'd like to get this merged to trunk, today if possible.

After posting as requested by Constantin, please rebase from the latest trunk.

The 4GL code was simple like:

using oo.*.

for each test_tab1 where test_tab1.col2 = Foo:func1():
  message "d" test_tab1.col2.
end.

It newly translates to:

   @LegacySignature(type = Type.MAIN, name = "do2.p")
   public void execute()
   {
      externalProcedure(Do2.this, new Block((Body) () -> 
      {
         AdaptiveQuery query0 = new AdaptiveQuery();

         forEach("loopLabel0", new Block((Init) () -> 
         {
            RecordBuffer.openScope(testTab1);
            query0.initialize(testTab1, "testTab1.col2 = ?", null, "testTab1.recid asc", new Object[]
            {
               (P2JQuery.Parameter) () -> com.goldencode.testcases.oo.Foo.func1()
            });
         }, 
         (Body) () -> 
         {
            query0.next();
            message(new Object[]
            {
               "d",
               (integer) new FieldReference(testTab1, "col2").getValue()
            });
         }));
      }));
   }

Branch is rebased, ready to merge.

Please do some tests with an instance function instead of static, parameters (simple vars, more complex like a function call, etc), call via THIS-OBJECT:func1(). I'm pretty sure this should work, but please double-check.

Seems to work just as well:

public void execute()
   {
      externalProcedure(Do3.this, new Block((Init) () -> 
      {
         ObjectOps.register(inst);
      }, 
      (Body) () -> 
      {
         inst.assign(ObjectOps.newInstance(com.goldencode.testcases.oo.Foo.class));

         AdaptiveQuery query0 = new AdaptiveQuery();

         forEach("loopLabel0", new Block((Init) () -> 
         {
            RecordBuffer.openScope(testTab1);
            query0.initialize(testTab1, "testTab1.col2 = ?", null, "testTab1.recid asc", new Object[]
            {
               (P2JQuery.Parameter) () -> inst.ref().func2(new integer(1))
            });
         }, 
         (Body) () -> 
         {
            query0.next();
            message(new Object[]
            {
               "d",
               (integer) new FieldReference(testTab1, "col2").getValue()
            });
         }));
      }));
   }

Thanks, looks good to merge to trunk.

Go ahead with the merge.

Merged as revision 14586.