ユーザー定義関数で日付時刻やBLOBを扱う

wmudflib.c(47)
char* EXPORT fn_blob_substr(ARG(BLOB, sourceBlob), ARG(long*, startPos), ARG(long*, endPos), ARG(char*, sResult))
ARGLIST(BLOB sourceBlob)
ARGLIST(long *startPos)
ARGLIST(long *endPos)
ARGLIST(char *sResult) {
  char *pbuffer, *pOffset, *pResultOffset;
  long i = 0;
  long curr_bytecount = 0;
  long startChar, endChar; 
  long length, actual_length;
  *sResult = 0;
  if (!sourceBlob->blob_handle) {
    return sResult;
  }
  length = sourceBlob->blob_max_segment;
  if (*startPos > *endPos || *startPos < 1L || *endPos < 1L)  {
    return sResult;
  }
  if (sourceBlob->blob_total_length < (long)*startPos) {
    return sResult;
  }
  startChar = *startPos;
  if (sourceBlob->blob_total_length < (long)*endPos) {
    endChar = sourceBlob->blob_total_length;
  } else {
    endChar = *endPos;
  }
  pbuffer = (char *) malloc (length + 1L); 
  pResultOffset = sResult;
  while ((*sourceBlob->blob_get_segment) (sourceBlob->blob_handle, pbuffer, length, &actual_length)) {    
//    pbuffer [actual_length] = 0;
    pOffset = pbuffer;
    while (*pOffset && (curr_bytecount < endChar)) {
      curr_bytecount++;
      if (curr_bytecount >= startChar) {
        *pResultOffset++ = *pOffset;
      }
      pOffset++;
    }
    if (curr_bytecount >= endChar) {
      *pResultOffset = 0;
      break;
    }
  }
  free (pbuffer);
  return sResult;
}

wmudflib.c(153)
   BLOB EXPORT fn_string_blob(ARG(char*, sourceString), ARG(BLOB, sResult))
   ARGLIST(char *sourceString) 
   ARGLIST(BLOB sResult) {
 (*sResult->blob_put_segment) (sResult->blob_handle, sourceString, strlen(sourceString));
 return sResult;
 }

library UDF_sample3;

uses
  SysUtils,
  IBExternals;

{$R *.res}

function Tomneko_Blob_Length(SourceBlob:PBlob):Integer;stdcall;
begin
  Result := 0;
  if (SourceBlob^.BlobHandle^ = 0) then
    Exit
  else
    Result := SourceBlob^.TotalSize;
end;

Procedure Tomneko_Blob_substr(SourceBlob:PBlob; var startPos, endPos:Integer; sResult:PAnsiChar);stdcall;
var
  pbuffer, pResultOffset, pOffset:PAnsiChar;
  curr_bytecount, startChar, endChar, length, actual_length:Integer;
begin
  curr_bytecount := 0;
  sResult^ := #0;
  if (sourceBlob^.BlobHandle^ = 0) then
  begin
    Exit;
  end;
  length := sourceBlob^.MaxSegmentLength;

  if ((startPos > endPos) or (startPos < 1) or (endPos < 1)) then
  begin
    exit;
  end;
  if (sourceBlob^.TotalSize < startPos) then
  begin
    exit;
  end;
  startChar := startPos;

  if (sourceBlob^.TotalSize < endPos) then
  begin
    endChar := sourceBlob^.TotalSize;
  end else
  begin
    endChar := endPos;
  end;

  GetMem(pbuffer, length + 1);

  pResultOffset := sResult;
  while (sourceBlob^.GetSegment(sourceBlob^.BlobHandle, PByte(pbuffer), length, actual_length) <> 0) do
  begin
    pOffset := pbuffer;
    while ((pOffset <> #0) and (curr_bytecount < endChar )) do
    begin
      Inc(curr_bytecount);
      if (curr_bytecount >= startChar ) then
      begin
        pResultOffset^ := pOffset^;
        inc(pResultOffset);
      end;
      Inc(pOffset);
      if (curr_bytecount = actual_length) then Break;
    end;

    if (curr_bytecount >= endChar) then
    begin
      pResultOffset^ := #0;
      break;
    end;
  end;
  freeMem(pbuffer);
  exit;
end;

Procedure Tomneko_Blob_string(sourceBlob:PBlob; sResult:PAnsiChar);stdcall;
var
  startPos, endPos:Integer;
begin
  startPos := 1;
  endPos := Tomneko_blob_length(sourceBlob);
  Tomneko_blob_substr(sourceBlob, startPos, endPos, sResult);
end;

Procedure Tomneko_string_Blob(sourceString:PAnsiChar; sResult:PBlob);stdcall;
begin
  sResult^.PutSegment(sResult^.BlobHandle, PByte(sourceString), strlen(PChar(sourceString)));
end;

exports
  Tomneko_Blob_Length,
  Tomneko_Blob_substr,
  Tomneko_Blob_string,
  Tomneko_string_Blob;

end.