FWD » Core Development » Database

In BufferManager.bufferInitialized, the buffer.activeScopeDepth is 0-based; this code:

      if (global)
      {
        ...
      }
      else
      {
         int scopes = getOpenBufferScopes();
         if (buffer.activeScopeDepth <= scopes)
         {
            openBuffers.addAt(scopes - buffer.activeScopeDepth, buffer);
            buffer.addOpenBuffersScope(buffer.activeScopeDepth);
         }
      }

In the case where I see this, the 'activeScopeDepth' is from a dataset parameter, TemporaryBuffer.associateImpl ~line 2648:

                        // open scope for this new buffer. Bound buffers go to global scope, the other local
                        tbuf.openScopeAt(bind ? 0 : tbuf.bufferManager.getOpenBufferScopes() - 1);

Things are confusing is wrong with the meaning of 'depth'. For TemporaryBuffer.openScopeAt:

    * @param   blockDepth
    *          Zero-based depth of the block (starting from the outermost scope) at which the
    *          buffer scope is opened.

seems to be the depth of the stack, from the bottom (0 is the bottom of the stack). So using tbuf.bufferManager.getOpenBufferScopes() - 1 for 'current scope' is right.

For ScopedList.addAt:

    * Add the given element to the tail of the scope at the given scope depth, where zero depth
    * represents the current scope, and a positive depth indicate older scopes. A depth of
    * {@code scopes() - 1} indicates the global scope.
    *
    * @param   depth
    *          Depth of the scope to which to add the element, as described above.

depth meaning is reversed: a zero means current scope, while scopes() - 1 the global scope.

So I think the code in bufferInitilized needs to be this:

         int scopes = getOpenBufferScopes();
         if (buffer.activeScopeDepth + 1 <= scopes)
         {
            openBuffers.addAt(scopes - (buffer.activeScopeDepth + 1), buffer);
            buffer.addOpenBuffersScope(buffer.activeScopeDepth);
         }

as we need to transform from a 0 to scopes' depth (for the activeScopeDepth) to a 'scopes - 1' to zero depth, as we need 0 to be 'current scope'.

Code Review Task Branch 10483a Revision 16137 and 16138

For RB.openScope(), what are 4GL code examples that cause a single buffer instance to ever have an open count > 0? I understand that your change is safer because of the conditions, but it seems like our approach should protect against any way that the same buffer instance can be opened more than once.

Greg Shah wrote:

Code Review Task Branch 10483a Revision 16137 and 16138

For RB.openScope(), what are 4GL code examples that cause a single buffer instance to ever have an open count > 0? I understand that your change is safer because of the conditions, but it seems like our approach should protect against any way that the same buffer instance can be opened more than once.

The change prevents the same buffer instance to open the scope more than once in the same 'execute'/external block. I agree that this should be somewhere lower in RB.openScope, and maybe consider any kind of block, to prevent this problem. Or maybe even ScopedList, if the key already exists, things get... weird with the linked nodes.

The scenario is like this:

• oo/Foo.cls
  

  class oo.Foo inherits oo.Bar:
    method public void m1().
       find first tt1.
    end.
  end.
  

• oo/Bar.cls
  

  class oo.Bar:
     def temp-table tt1 field f1 as int.
     method public void m2().
       find first tt1.
     end.
  end.
  

RB.openScope(tt1) appears in the pseudo-execute method for both Foo.java and Bar.java. The protection ensures only for this specific case.

The protection ensures only for this specific case.

I understand. But should we expand this to be unconditional? I can't think of a scenario where the 4GL allows nested open scope on the same buffer instance.