mORMot Open Source

tbo

Member

Registered: 2015-04-20

Posts: 359

Unexpected behaviour

Hallo!

Can someone tell me where I'm going wrong?

Delphi 12.1, mORMot2 Commit 9637

I have an unexpected behaviour in the following source code. I know how to work around the error or rewrite the source code so that it works correctly, but I don't understand why the following doesn't work. There is an overloaded BuildLikeExpression function. In one function, the parameter is passed as an "array of const" and in the second as a "VariantDynArray". The function with the VariantDynArray converts the input parameter into a VarRecDynArray and calls the function with the corresponding type.

If the input parameter VariantDynArray starts with a TSqlLikePlaceholder, the following happens: The array is converted into a VarRecDynArray and the corresponding function is called with it. The problem is the first VarRec record with a string. During processing in the loop Result := Result + LIKE_WILDCARD[TPpSqlLikePlaceholder.xxx], the value Result appears in this record after the assignment. This only happens in this constellation and only for the first VarRec record with a string. All similar sequences of parameters in the following and all other combinations work as expected. If I cast the first string parameter to RawUtf8, the effect does not occur. It is no problem to rewrite the function to handle normal strings or to make the cast, but in my opinion it should also work like this.

Function with parameter "array of const":

function BuildLikeExpression(const aTermList: array of const): RawUtf8; overload;
const
  LIKE_WILDCARD: array[TSqlLikePlaceholder] of RawUtf8 = ('%', '_');
var
  TermIdx: Integer;
  TermLiteral: RawUtf8;
  PLikeTerm: PVarRec;
begin
  for TermIdx := 0 to High(aTermList) do
  begin
    PLikeTerm := @aTermList[TermIdx];
    case PLikeTerm^.VType of
      vtString, vtAnsiString, vtUnicodeString:
        begin
          VarRecToUtf8(PLikeTerm^, TermLiteral);
          Result := Result + TermLiteral;
        end;
      vtInteger:
        case PLikeTerm^.VInteger of
          Ord(TSqlLikePlaceholder.Any):
            Result := Result + LIKE_WILDCARD[TSqlLikePlaceholder.Any];
          Ord(TSqlLikePlaceholder.One):
            Result := Result + LIKE_WILDCARD[TSqlLikePlaceholder.One];
        end;
    end;
  end;
  Result := ' LIKE ' + mormot.core.unicode.QuotedStr(Result);
end;

Function with parameter "VariantDynArray":

function BuildLikeExpression(const aTermList: TVariantDynArray): RawUtf8; overload;
var
  TermIdx: Integer;
  TermLiteral: RawUtf8;
  TermArrayOfConst: TTVarRecDynArray;
  PLikeTerm: PVarRec;
begin
  SetLength(TermArrayOfConst, Length(aTermList));
  for TermIdx := 0 to High(TermArrayOfConst) do
  begin
    PLikeTerm := @TermArrayOfConst[TermIdx];
    case TVarData(aTermList[TermIdx]).VType of
      varString, varUString:
        begin
          TermLiteral := VariantToUtf8(aTermList[TermIdx]);
          PLikeTerm^.VType := vtAnsiString;
          PLikeTerm^.VAnsiString := Pointer(TermLiteral);
        end;
      varByte:
        begin
          PLikeTerm^.VType := vtInteger;
          PLikeTerm^.VInteger := TVarData(aTermList[TermIdx]).VByte;
        end;
    end;
  end;
  Result := BuildLikeExpression(TermArrayOfConst);
end;

These are the results:

// Result: LIKE '_Test%BlaBla_'  <== OK  (with parameter "array of const")
BuildLikeExpression([Ord(TSqlLikePlaceholder.One), 'Test', Ord(TSqlLikePlaceholder.Any), 'BlaBla', Ord(TSqlLikePlaceholder.One)])

// Result: LIKE '__%BlaBla_'  <== False  (with parameter "VariantDynArray")
BuildLikeExpression([TSqlLikePlaceholder.One, 'Test', TSqlLikePlaceholder.Any, 'BlaBla', TSqlLikePlaceholder.One])

// Result: LIKE '_Test%BlaBla_'  <== OK  (with parameter "VariantDynArray")
BuildLikeExpression([TSqlLikePlaceholder.One, RawUtf8('Test'), TSqlLikePlaceholder.Any, 'BlaBla', TSqlLikePlaceholder.One])

With best regards
Thomas

ab

Administrator

From: France

Registered: 2010-06-21

Posts: 14,934

Website

Re: Unexpected behaviour

What seems obvious to me is that you are using a single TermLiteral RawUtf8 value against all TermArrayOfConst[] so an unstable pointer is stored within PLikeTerm^.VAnsiString.

Then I would have used VariantsToArrayOfConst() from mormot.core.variants instead of reinventing the weel.
In VariantToVarRec() you can see that you don't need to allocate anything.
Then just check  "if PLikeTerm^.VType = vtInteger then .... else ... VarRecToUtf8()"

Also note that BuildLikeExpression() needs to initialize their result := ''; before result := result + loop.

tbo

Member

Registered: 2015-04-20

Posts: 359

Re: Unexpected behaviour

Hello Arnaud!

Also note that BuildLikeExpression() needs to initialize their result := ''; before result := result + loop.

Thank you for your reply. Yes, it is secured in the original source code. I am a proponent of the concept of inherent security when writing functions. The example source code is just reduced to an absolute minimum so as not to violate the forum rules. I had the VariantsToArrayOfConst function in mind. I should have mentioned it, the source code is not the original production code but just an example of behaviour I don't understand.

With best regards
Thomas

Last edited by tbo (2025-02-05 13:32:33)

tbo

Member

Registered: 2015-04-20

Posts: 359

Re: Unexpected behaviour

Hello Arnaud!

In VariantToVarRec() you can see that you don't need to allocate anything.

Your note about VariantToVarRec led me to a variation that works as expected. However, I am still puzzled by the behaviour of my version from the initial post. I would just like to mention that this solution is not production code either, but only serves the purpose of understanding.

function BuildLikeExpression(const aTermList: TVariantDynArray): RawUtf8; overload;
var
  TermIdx: Integer;
  TermArrayOfConst: TTVarRecDynArray;
  TermLiteralArray: TRawUtf8DynArray;
  PLikeTerm: PVarRec;
begin
  SetLength(TermArrayOfConst, Length(aTermList));
  SetLength(TermLiteralArray, Length(aTermList));
  for TermIdx := 0 to High(TermArrayOfConst) do
  begin
    PLikeTerm := @TermArrayOfConst[TermIdx];
    case TVarData(aTermList[TermIdx]).VType of
      varString, varUString:
        begin
          TermLiteralArray[TermIdx] := VariantToUtf8(aTermList[TermIdx]);
          PLikeTerm^.VType := vtAnsiString;
          PLikeTerm^.VAnsiString := Pointer(TermLiteralArray[TermIdx]);
        end;
      varByte:
        begin
          PLikeTerm^.VType := vtInteger;
          PLikeTerm^.VInteger := TVarData(aTermList[TermIdx]).VByte;
        end;
    end;
  end;
  Result := BuildLikeExpression(TermArrayOfConst);
end;

With best regards
Thomas

ab

Administrator

From: France

Registered: 2010-06-21

Posts: 14,934

Website

Re: Unexpected behaviour

Using vtVariant as VariantToVarRec does looked much safer and easier than a transient RawUtf8 array.