Adding upstream version 1:10.11.6.upstream/1%10.11.6upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1542 insertions, 0 deletions

diff --git a/storage/connect/filamfix.cpp b/storage/connect/filamfix.cpp
new file mode 100644
index 00000000..3298a833
--- /dev/null
+++ b/storage/connect/filamfix.cpp
@@ -0,0 +1,1542 @@
+/*********** File AM Fix C++ Program Source Code File (.CPP) ***********/
+/* PROGRAM NAME: FILAMFIX                                              */
+/* -------------                                                       */
+/*  Version 1.6                                                        */
+/*                                                                     */
+/* COPYRIGHT:                                                          */
+/* ----------                                                          */
+/*  (C) Copyright to the author Olivier BERTRAND          2005-2015    */
+/*                                                                     */
+/* WHAT THIS PROGRAM DOES:                                             */
+/* -----------------------                                             */
+/*  This program are the FIX/BIN file access method classes.           */
+/*                                                                     */
+/***********************************************************************/
+
+/***********************************************************************/
+/*  Include relevant sections of the System header files.              */
+/***********************************************************************/
+#include "my_global.h"
+#if defined(_WIN32)
+#include <io.h>
+#include <fcntl.h>
+#include <errno.h>
+#if defined(__BORLANDC__)
+#define __MFC_COMPAT__                   // To define min/max as macro
+#endif   // __BORLANDC__
+//#include <windows.h>
+#else   // !_WIN32
+#if defined(UNIX)
+#include <errno.h>
+#include <unistd.h>
+#else   // !UNIX
+#include <io.h>
+#endif  // !UNIX
+#include <sys/stat.h>
+#include <fcntl.h>
+#endif  // !_WIN32
+
+#include <m_string.h>
+
+/***********************************************************************/
+/*  Include application header files:                                  */
+/*  global.h    is header containing all global declarations.          */
+/*  plgdbsem.h  is header containing the DB application declarations.  */
+/*  filamfix.h  is header containing the file AM classes declarations. */
+/***********************************************************************/
+#include "global.h"
+#include "plgdbsem.h"
+#include "filamfix.h"
+#include "tabdos.h"
+#include "tabfix.h"
+#include "osutil.h"
+
+#ifndef INVALID_SET_FILE_POINTER
+#define INVALID_SET_FILE_POINTER  0xFFFFFFFF
+#endif
+
+extern int num_read, num_there, num_eq[2];               // Statistics
+
+/* --------------------------- Class FIXFAM -------------------------- */
+
+/***********************************************************************/
+/*  Constructors.                                                      */
+/***********************************************************************/
+FIXFAM::FIXFAM(PDOSDEF tdp) : BLKFAM(tdp)
+  {
+  Blksize = tdp->GetBlksize();
+  Padded = tdp->GetPadded();
+
+  if (Padded && Blksize)
+    Nrec = Blksize / Lrecl;
+  else {
+    Nrec = (tdp->GetElemt()) ? tdp->GetElemt() : DOS_BUFF_LEN;
+    Blksize = Nrec * Lrecl;
+    Padded = false;
+    } // endelse
+
+  } // end of FIXFAM standard constructor
+
+FIXFAM::FIXFAM(PFIXFAM txfp) : BLKFAM(txfp)
+  {
+  } // end of FIXFAM copy constructor
+
+/***********************************************************************/
+/*  SetPos: Replace the table at the specified position.               */
+/***********************************************************************/
+bool FIXFAM::SetPos(PGLOBAL g, int pos)
+  {
+  if (pos < 0) {
+    strcpy(g->Message, MSG(INV_REC_POS));
+    return true;
+    } // endif recpos
+
+  CurBlk = pos / Nrec;
+  CurNum = pos % Nrec;
+#if defined(_DEBUG)
+  num_eq[(CurBlk == OldBlk) ? 1 : 0]++;
+#endif
+
+  // Indicate the table position was externally set
+  Placed = true;
+  return false;
+  } // end of SetPos
+
+/***********************************************************************/
+/*  Initialize CurBlk and CurNum for indexed DELETE.                   */
+/***********************************************************************/
+int FIXFAM::InitDelete(PGLOBAL, int fpos, int)
+  {
+  CurBlk = fpos / Nrec;
+  CurNum = fpos % Nrec;
+  return RC_OK;
+  } // end of InitDelete
+
+/***********************************************************************/
+/*  Allocate the block buffer for the table.                           */
+/***********************************************************************/
+bool FIXFAM::AllocateBuffer(PGLOBAL g)
+  {
+  Buflen = Blksize;
+  To_Buf = (char*)PlugSubAlloc(g, NULL, Buflen);
+
+  if (UseTemp || Tdbp->GetMode() == MODE_DELETE) {
+    if (Padded) {
+      strcpy(g->Message, MSG(NO_MODE_PADDED));
+      return true;
+      } // endif Padded
+
+    // Allocate a separate buffer so block reading can be kept
+    Dbflen = Nrec;
+    DelBuf = PlugSubAlloc(g, NULL, Blksize);
+  } else if (Tdbp->GetMode() == MODE_INSERT) {
+    /*******************************************************************/
+    /*  For Insert the buffer must be prepared.                        */
+    /*******************************************************************/
+    if (Tdbp->GetFtype() == RECFM_BIN) {
+      // The buffer must be prepared depending on column types
+      int     n = 0;
+      bool    b = false;
+      PBINCOL colp;
+
+      // Prepare the first line of the buffer
+      memset(To_Buf, 0, Buflen);
+
+#if 0
+      for (cdp = defp->GetCols(); cdp; cdp = cdp->GetNext()) {
+        if (!IsTypeNum(cdp->GetType())) {
+          memset(To_Buf + cdp->GetOffset(), ' ', cdp->GetClen()); 
+          b = true;
+          } // endif not num
+
+        n = MY_MAX(n, cdp->GetOffset() + cdp->GetClen());
+        } // endfor cdp
+#endif // 0
+
+      for (colp = (PBINCOL)Tdbp->GetColumns(); colp; 
+           colp = (PBINCOL)colp->GetNext())
+        if (!colp->IsSpecial()) {
+          if (!IsTypeNum(colp->GetResultType())) {
+            memset(To_Buf + colp->GetDeplac(), ' ', colp->GetLength()); 
+            b = true;
+            } // endif not num
+      
+          n = MY_MAX(n, colp->GetDeplac() + colp->GetFileSize());
+          } // endif !special
+
+      // We do this for binary table because the lrecl can have been
+      // specified with additional space to include line ending.
+      if (n < Lrecl && Ending) {
+        To_Buf[Lrecl - 1] = '\n';
+
+        if (n < Lrecl - 1 && Ending == 2)
+          To_Buf[Lrecl - 2] = '\r';
+
+        } // endif n
+
+      if (b)
+        // Now repeat this for the whole buffer
+        for (int len = Lrecl; len <= Buflen - Lrecl; len += Lrecl)
+          memcpy(To_Buf + len, To_Buf, Lrecl);
+
+    } else {
+      memset(To_Buf, ' ', Buflen);
+  
+      if (!Padded)
+        // The file is physically a text file.
+        for (int len = Lrecl; len <= Buflen; len += Lrecl) {
+          if (Ending == 2)
+            To_Buf[len - 2] = '\r';
+  
+          To_Buf[len - 1] = '\n';
+          } // endfor len
+
+    } // endif Ftype
+
+    Rbuf = Nrec;                     // To be used by WriteDB
+    } // endif Insert
+
+  return false;
+  } // end of AllocateBuffer
+
+/***********************************************************************/
+/*  Reset buffer access according to indexing and to mode.             */
+/*  >>>>>>>>>>>>>> TO BE RE-VISITED AND CHECKED <<<<<<<<<<<<<<<<<<<<<< */
+/***********************************************************************/
+void FIXFAM::ResetBuffer(PGLOBAL g)
+  {
+  /*********************************************************************/
+  /*  If access is random, performances can be much better when the    */
+  /*  reads are done on only one row, except for small tables that can */
+  /*  be entirely read in one block.                                   */
+  /*********************************************************************/
+  if (Tdbp->GetKindex() && ReadBlks != 1 && !Padded) {
+    Nrec = 1;                       // Better for random access
+    Rbuf = 0;
+    Blksize = Lrecl;
+    OldBlk = -2;                    // Has no meaning anymore
+    Block = Tdbp->Cardinality(g);   // Blocks are one line now
+    } // endif Mode
+
+  } // end of ResetBuffer
+
+/***********************************************************************/
+/*  WriteModifiedBlock: Used when updating.                            */
+/***********************************************************************/
+int FIXFAM::WriteModifiedBlock(PGLOBAL g)
+  {
+  /*********************************************************************/
+  /*  The old block was modified in Update mode.                       */
+  /*  In Update mode we simply rewrite the old block on itself.        */
+  /*********************************************************************/
+  int  rc = RC_OK;
+  bool moved = false;
+
+  // Using temp copy any intermediate lines.
+  if (UseTemp && MoveIntermediateLines(g, &moved))
+    rc = RC_FX;
+
+  // Fpos is last position, Headlen is DBF file header length
+  else if (!moved && fseek(Stream, Headlen + Fpos * Lrecl, SEEK_SET)) {
+    snprintf(g->Message, sizeof(g->Message), MSG(FSETPOS_ERROR), 0);
+    rc = RC_FX;
+  } else if (fwrite(To_Buf, Lrecl, Rbuf, T_Stream) != (size_t)Rbuf) {
+    snprintf(g->Message, sizeof(g->Message), MSG(FWRITE_ERROR), strerror(errno));
+    rc = RC_FX;
+  } else
+    Spos = Fpos + Nrec;           // + Rbuf ???
+
+  if (Closing || rc != RC_OK) {   // Error or called from CloseDB
+    Closing = true;               // To tell CloseDB about error
+    return rc;
+    } // endif Closing
+
+  // NOTE: Next line was added to avoid a very strange fread bug.
+  // When the fseek is not executed (even the file has the good
+  // pointer position) the next read can happen anywhere in the file.
+  OldBlk = -2;            // This will force fseek to be executed
+  Modif = 0;
+  return rc;
+  } // end of WriteModifiedBlock
+
+/***********************************************************************/
+/*  ReadBuffer: Read one line for a FIX file.                          */
+/***********************************************************************/
+int FIXFAM::ReadBuffer(PGLOBAL g)
+  {
+  int n, rc = RC_OK;
+
+  /*********************************************************************/
+  /*  Sequential reading when Placed is not true.                      */
+  /*********************************************************************/
+  if (Placed) {
+    Tdbp->SetLine(To_Buf + CurNum * Lrecl);
+    Placed = false;
+  } else if (++CurNum < Rbuf) {
+    Tdbp->IncLine(Lrecl);                // Used by DOSCOL functions
+    return RC_OK;
+  } else if (Rbuf < Nrec && CurBlk != -1) {
+    return RC_EF;
+  } else {
+    /*******************************************************************/
+    /*  New block.                                                     */
+    /*******************************************************************/
+    CurNum = 0;
+    Tdbp->SetLine(To_Buf);
+
+ next:
+    if (++CurBlk >= Block)
+      return RC_EF;
+
+    /*******************************************************************/
+    /*  Before reading a new block, check whether block indexing       */
+    /*  can be done, as well as for join as for local filtering.       */
+    /*******************************************************************/
+    switch (Tdbp->TestBlock(g)) {
+      case RC_EF:
+        return RC_EF;
+      case RC_NF:
+        goto next;
+      } // endswitch rc
+   } // endif's
+
+  if (OldBlk == CurBlk) {
+    IsRead = true;            // Was read indeed
+    return RC_OK;             // Block is already there
+    } // endif OldBlk
+
+  // Write modified block in mode UPDATE
+  if (Modif && (rc = WriteModifiedBlock(g)) != RC_OK)
+    return rc;
+
+  // This could be done only for new block. However note that FPOS
+  // is used as block position when updating and as line position
+  // when deleting so this has to be carefully checked.
+  Fpos = CurBlk * Nrec;         // Fpos is new line position
+
+  // fseek is required only in non sequential reading
+  if (CurBlk != OldBlk + 1)
+    // Note: Headlen is for DBF tables
+    if (fseek(Stream, Headlen + Fpos * Lrecl, SEEK_SET)) {
+      snprintf(g->Message, sizeof(g->Message), MSG(FSETPOS_ERROR), Fpos);
+      return RC_FX;
+      } // endif fseek
+
+  if (trace(2))
+    htrc("File position is now %d\n", ftell(Stream));
+
+  if (Padded)
+    n = fread(To_Buf, (size_t)Blksize, 1, Stream);
+  else
+    n = fread(To_Buf, (size_t)Lrecl, (size_t)Nrec, Stream);
+
+  if (n) {
+    rc = RC_OK;
+    Rbuf = (Padded) ? n * Nrec : n;
+    ReadBlks++;
+    num_read++;
+  } else if (feof(Stream)) {
+    rc = RC_EF;
+  } else {
+#if defined(_WIN32)
+    snprintf(g->Message, sizeof(g->Message), MSG(READ_ERROR), To_File, _strerror(NULL));
+#else
+    snprintf(g->Message, sizeof(g->Message), MSG(READ_ERROR), To_File, strerror(errno));
+#endif
+
+    if (trace(1))
+      htrc("%s\n", g->Message);
+
+    return RC_FX;
+  } // endelse
+
+  OldBlk = CurBlk;              // Last block actually read
+  IsRead = true;                // Is read indeed
+  return rc;
+  } // end of ReadBuffer
+
+/***********************************************************************/
+/*  WriteBuffer: File write routine for FIX access method.             */
+/*  Updates are written into the (Temp) file in ReadBuffer.            */
+/***********************************************************************/
+int FIXFAM::WriteBuffer(PGLOBAL g)
+  {
+  if (trace(2))
+    htrc("FIX WriteDB: Mode=%d buf=%p line=%p Nrec=%d Rbuf=%d CurNum=%d\n",
+         Tdbp->GetMode(), To_Buf, Tdbp->GetLine(), Nrec, Rbuf, CurNum);
+
+  if (Tdbp->GetMode() == MODE_INSERT) {
+    /*******************************************************************/
+    /*  In Insert mode, blocs are added sequentialy to the file end.   */
+    /*******************************************************************/
+    if (++CurNum != Rbuf) {
+      Tdbp->IncLine(Lrecl);            // Used by DOSCOL functions
+      return RC_OK;                    // We write only full blocks
+      } // endif CurNum
+
+    if (trace(2))
+      htrc(" First line is '%.*s'\n", Lrecl - 2, To_Buf);
+
+    //  Now start the writing process.
+    if (fwrite(To_Buf, Lrecl, Rbuf, Stream) != (size_t)Rbuf) {
+      snprintf(g->Message, sizeof(g->Message), MSG(FWRITE_ERROR), strerror(errno));
+      Closing = true;      // To tell CloseDB about a Write error
+      return RC_FX;
+      } // endif size
+
+    CurBlk++;
+    CurNum = 0;
+    Tdbp->SetLine(To_Buf);
+
+    if (trace(2))
+      htrc("write done\n");
+
+  } else {                           // Mode == MODE_UPDATE
+    // T_Stream is the temporary stream or the table file stream itself
+    if (!T_Stream) {
+      if (UseTemp) {
+        if (OpenTempFile(g))
+          return RC_FX;
+        else if (CopyHeader(g))           // For DBF tables
+          return RC_FX;
+
+      } else
+        T_Stream = Stream;
+
+      } // endif T_Stream
+
+    if (Nrec > 1)
+      Modif++;                         // Modified line in blocked mode
+    else if (WriteModifiedBlock(g))    // Indexed update
+      return RC_FX;
+
+  } // endif Mode
+
+  return RC_OK;
+  } // end of WriteBuffer
+
+/***********************************************************************/
+/*  Data Base delete line routine for FIXFAM access method.            */
+/***********************************************************************/
+int FIXFAM::DeleteRecords(PGLOBAL g, int irc)
+  {
+  bool moved;
+
+  /*********************************************************************/
+  /*  There is an alternative here:                                    */
+  /*  1 - use a temporary file in which are copied all not deleted     */
+  /*      lines, at the end the original file will be deleted and      */
+  /*      the temporary file renamed to the original file name.        */
+  /*  2 - directly move the not deleted lines inside the original      */
+  /*      file, and at the end erase all trailing records.             */
+  /*  This will be experimented.                                       */
+  /*********************************************************************/
+  if (trace(2))
+    htrc("DOS DeleteDB: rc=%d UseTemp=%d Fpos=%d Tpos=%d Spos=%d\n",
+         irc, UseTemp, Fpos, Tpos, Spos);
+
+  if (irc != RC_OK) {
+    /*******************************************************************/
+    /*  EOF: position Fpos at the end-of-file position.                */
+    /*******************************************************************/
+    Fpos = Tdbp->Cardinality(g);
+
+    if (trace(2))
+      htrc("Fpos placed at file end=%d\n", Fpos);
+
+  } else    // Fpos is the deleted line position
+    Fpos = CurBlk * Nrec + CurNum;
+
+  if (Tpos == Spos) {
+    /*******************************************************************/
+    /*  First line to delete.                                          */
+    /*******************************************************************/
+    if (UseTemp) {
+      /*****************************************************************/
+      /*  Open temporary file, lines before this will be moved.        */
+      /*****************************************************************/
+      if (OpenTempFile(g))
+        return RC_FX;
+
+    } else {
+      /*****************************************************************/
+      /*  Move of eventual preceding lines is not required here.      */
+      /*  Set the target file as being the source file itself.         */
+      /*  Set the future Tpos, and give Spos a value to block moving.  */
+      /*****************************************************************/
+      T_Stream = Stream;
+      Spos = Tpos = Fpos;
+    } // endif UseTemp
+
+    } // endif Tpos == Spos
+
+  /*********************************************************************/
+  /*  Move any intermediate lines.                                     */
+  /*********************************************************************/
+  if (MoveIntermediateLines(g, &moved))
+    return RC_FX;
+
+  if (irc == RC_OK) {
+    /*******************************************************************/
+    /*  Reposition the file pointer and set Spos.                      */
+    /*******************************************************************/
+    Spos = Fpos + 1;          // New start position is on next line
+
+    if (moved) {
+      if (fseek(Stream, Spos * Lrecl, SEEK_SET)) {
+        snprintf(g->Message, sizeof(g->Message), MSG(FSETPOS_ERROR), 0);
+        return RC_FX;
+        } // endif fseek
+
+      OldBlk = -2;  // To force fseek to be executed on next block
+      } // endif moved
+
+    if (trace(2))
+      htrc("after: Tpos=%d Spos=%d\n", Tpos, Spos);
+
+  } else {
+    /*******************************************************************/
+    /*  Last call after EOF has been reached.                          */
+    /*******************************************************************/
+    if (UseTemp) {
+      /*****************************************************************/
+      /*  Ok, now delete old file and rename new temp file.            */
+      /*****************************************************************/
+      if (RenameTempFile(g))
+        return RC_FX;
+
+    } else {
+      /*****************************************************************/
+      /*  Because the chsize functionality is only accessible with a   */
+      /*  system call we must close the file and reopen it with the    */
+      /*  open function (_fopen for MS ??) this is still to be checked */
+      /*  for compatibility with Text files and other OS's.            */
+      /*****************************************************************/
+      char filename[_MAX_PATH];
+      int  h;
+
+      /*rc= */PlugCloseFile(g, To_Fb);
+      PlugSetPath(filename, To_File, Tdbp->GetPath());
+
+      if ((h= global_open(g, MSGID_OPEN_STRERROR, filename, O_WRONLY)) <= 0)
+        return RC_FX;
+
+      /*****************************************************************/
+      /*  Remove extra records.                                        */
+      /*****************************************************************/
+#if defined(UNIX)
+      if (ftruncate(h, (off_t)(Tpos * Lrecl))) {
+        snprintf(g->Message, sizeof(g->Message), MSG(TRUNCATE_ERROR), strerror(errno));
+        close(h);
+        return RC_FX;
+        } // endif
+#else
+      if (chsize(h, Tpos * Lrecl)) {
+        snprintf(g->Message, sizeof(g->Message), MSG(CHSIZE_ERROR), strerror(errno));
+        close(h);
+        return RC_FX;
+        } // endif
+#endif
+
+      close(h);
+
+    if (trace(2))
+      htrc("done, h=%d irc=%d\n", h, irc);
+
+    } // endif UseTemp
+
+  } // endif irc
+
+  return RC_OK;                                      // All is correct
+  } // end of DeleteRecords
+
+/***********************************************************************/
+/*  Move intermediate deleted or updated lines.                        */
+/*  This works only for file open in binary mode.                      */
+/***********************************************************************/
+bool FIXFAM::MoveIntermediateLines(PGLOBAL g, bool *b)
+  {
+  int   n;
+  size_t req, len;
+
+  for (*b = false, n = Fpos - Spos; n > 0; n -= req) {
+    /*******************************************************************/
+    /*  Non consecutive line to delete. Move intermediate lines.       */
+    /*******************************************************************/
+    if (!UseTemp || !*b)
+      if (fseek(Stream, Headlen + Spos * Lrecl, SEEK_SET)) {
+        snprintf(g->Message, sizeof(g->Message), MSG(READ_SEEK_ERROR), strerror(errno));
+        return true;
+        } // endif
+
+    req = (size_t)MY_MIN(n, Dbflen);
+    len = fread(DelBuf, Lrecl, req, Stream);
+
+    if (trace(2))
+      htrc("after read req=%d len=%d\n", req, len);
+
+    if (len != req) {
+      snprintf(g->Message, sizeof(g->Message), MSG(DEL_READ_ERROR), (int) req, (int) len);
+      return true;
+      } // endif len
+
+    if (!UseTemp)         // Delete mode, cannot be a DBF file
+      if (fseek(T_Stream, Tpos * Lrecl, SEEK_SET)) {
+        snprintf(g->Message, sizeof(g->Message), MSG(WRITE_SEEK_ERR), strerror(errno));
+        return true;
+        } // endif
+
+    if ((len = fwrite(DelBuf, Lrecl, req, T_Stream)) != req) {
+      snprintf(g->Message, sizeof(g->Message), MSG(DEL_WRITE_ERROR), strerror(errno));
+      return true;
+      } // endif
+
+    if (trace(2))
+      htrc("after write pos=%d\n", ftell(Stream));
+
+    Tpos += (int)req;
+    Spos += (int)req;
+
+    if (trace(2))
+      htrc("loop: Tpos=%d Spos=%d\n", Tpos, Spos);
+
+    *b = true;
+    } // endfor n
+
+  return false;
+  } // end of MoveIntermediate Lines
+
+/***********************************************************************/
+/*  Table file close routine for FIX access method.                    */
+/***********************************************************************/
+void FIXFAM::CloseTableFile(PGLOBAL g, bool abort)
+  {
+  int rc = RC_OK, wrc = RC_OK;
+  MODE mode = Tdbp->GetMode();
+
+  Abort = abort;
+
+  // Closing is True if last Write was in error
+  if (mode == MODE_INSERT && CurNum && !Closing) {
+    // Some more inserted lines remain to be written
+    Rbuf = CurNum--;
+    wrc = WriteBuffer(g);
+  } else if (mode == MODE_UPDATE) {
+    if (Modif && !Closing) {
+      // Last updated block remains to be written
+      Closing = true;               // ???
+      wrc = WriteModifiedBlock(g);
+      } // endif Modif
+
+    if (UseTemp && T_Stream && wrc == RC_OK) {
+      if (!Abort) {
+        // Copy any remaining lines
+        bool b;
+    
+        Fpos = Tdbp->Cardinality(g);
+        Abort = MoveIntermediateLines(g, &b) != RC_OK;
+        } // endif Abort
+
+      // Delete the old file and rename the new temp file.
+      RenameTempFile(g);
+      goto fin;
+      } // endif UseTemp
+
+  } // endif's mode
+
+  // Finally close the file
+  rc = PlugCloseFile(g, To_Fb);
+
+ fin:
+  if (trace(1))
+    htrc("FIX CloseTableFile: closing %s mode=%d wrc=%d rc=%d\n",
+         To_File, mode, wrc, rc);
+
+  Stream = NULL;           // So we can know whether table is open
+  } // end of CloseTableFile
+
+/* ------------------------- Class BGXFAM ---------------------------- */
+
+/***********************************************************************/
+/*  Implementation of the BGXFAM class.                                */
+/*  This is the FAM class for FIX tables of more than 2 gigabytes.     */
+/***********************************************************************/
+BGXFAM::BGXFAM(PDOSDEF tdp) : FIXFAM(tdp)
+  {
+  Hfile = INVALID_HANDLE_VALUE;
+  Tfile = INVALID_HANDLE_VALUE;
+  } // end of BGXFAM constructor
+
+BGXFAM::BGXFAM(PBGXFAM txfp) : FIXFAM(txfp)
+  {
+  Hfile = txfp->Hfile;
+  Tfile = txfp->Tfile;
+  } // end of BGXFAM copy constructor
+
+/***********************************************************************/
+/*  Set current position in a big file.                                */
+/***********************************************************************/
+bool BGXFAM::BigSeek(PGLOBAL g, HANDLE h, BIGINT pos, int org)
+  {
+#if defined(_WIN32)
+  char          buf[256];
+  DWORD         drc;
+  LARGE_INTEGER of;
+
+  of.QuadPart = pos;
+  of.LowPart = SetFilePointer(h, of.LowPart, &of.HighPart, org);
+
+  if (of.LowPart == INVALID_SET_FILE_POINTER &&
+           (drc = GetLastError()) != NO_ERROR) {
+    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
+                  FORMAT_MESSAGE_IGNORE_INSERTS, NULL, drc, 0,
+                  (LPTSTR)buf, sizeof(buf), NULL);
+    snprintf(g->Message, sizeof(g->Message), MSG(SFP_ERROR), buf);
+    return true;
+    } // endif
+#else   // !_WIN32
+  if (lseek64(h, pos, org) < 0) {
+    snprintf(g->Message, sizeof(g->Message), "lseek64: %s", strerror(errno));
+    printf("%s\n", g->Message);
+    return true;
+    } // endif
+#endif  // !_WIN32
+
+  return false;
+  } // end of BigSeek
+
+/***********************************************************************/
+/*  Read from a big file.                                              */
+/***********************************************************************/
+int BGXFAM::BigRead(PGLOBAL g __attribute__((unused)), 
+                    HANDLE h, void *inbuf, int req)
+  {
+  int rc;
+
+#if defined(_WIN32)
+  DWORD nbr, drc, len = (DWORD)req;
+  bool  brc = ReadFile(h, inbuf, len, &nbr, NULL);
+
+  if (trace(2))
+    htrc("after read req=%d brc=%d nbr=%d\n", req, brc, nbr);
+
+  if (!brc) {
+    char buf[256];  // , *fn = (h == Hfile) ? To_File : "Tempfile";
+
+    drc = GetLastError();
+    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
+                  FORMAT_MESSAGE_IGNORE_INSERTS, NULL, drc, 0,
+                  (LPTSTR)buf, sizeof(buf), NULL);
+    snprintf(g->Message, sizeof(g->Message), MSG(READ_ERROR), To_File, buf);
+
+    if (trace(2))
+      htrc("BIGREAD: %s\n", g->Message);
+
+    rc = -1;
+  } else
+    rc = (int)nbr;
+#else   // !_WIN32
+  size_t  len = (size_t)req;
+  ssize_t nbr = read(h, inbuf, len);
+
+  rc = (int)nbr;
+#endif  // !_WIN32
+
+  return rc;
+  } // end of BigRead
+
+/***********************************************************************/
+/*  Write into a big file.                                             */
+/***********************************************************************/
+bool BGXFAM::BigWrite(PGLOBAL g, HANDLE h, void *inbuf, int req)
+  {
+  bool rc = false;
+
+#if defined(_WIN32)
+  DWORD nbw, drc, len = (DWORD)req;
+  bool  brc = WriteFile(h, inbuf, len, &nbw, NULL);
+
+  if (trace(2))
+    htrc("after write req=%d brc=%d nbw=%d\n", req, brc, nbw);
+
+  if (!brc || nbw != len) {
+		char buf[256];
+		PCSZ fn = (h == Hfile) ? To_File : "Tempfile";
+
+    if (brc)
+      strcpy(buf, MSG(BAD_BYTE_NUM));
+    else {
+      drc = GetLastError();
+      FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
+                    FORMAT_MESSAGE_IGNORE_INSERTS, NULL, drc, 0,
+                    (LPTSTR)buf, sizeof(buf), NULL);
+      } // endelse brc
+
+    snprintf(g->Message, sizeof(g->Message), MSG(WRITE_STRERROR), fn, buf);
+
+    if (trace(2))
+      htrc("BIGWRITE: nbw=%d len=%d errno=%d %s\n",
+           nbw, len, drc, g->Message);
+
+    rc = true;
+    } // endif brc || nbw
+#else   // !_WIN32
+  size_t  len = (size_t)req;
+  ssize_t nbw = write(h, inbuf, len);
+
+  if (nbw != (ssize_t)len) {
+    const char *fn = (h == Hfile) ? To_File : "Tempfile";
+
+    snprintf(g->Message, sizeof(g->Message), MSG(WRITE_STRERROR), fn, strerror(errno));
+
+    if (trace(2))
+      htrc("BIGWRITE: nbw=%d len=%d errno=%d %s\n",
+           nbw, len, errno, g->Message);
+
+    rc = true;
+    } // endif nbr
+#endif  // !_WIN32
+
+  return rc;
+  } // end of BigWrite
+
+#if 0
+/***********************************************************************/
+/*  Reset: reset position values at the beginning of file.             */
+/***********************************************************************/
+void BGXFAM::Reset(void)
+  {
+  FIXFAM::Reset();
+  Xpos = 0;
+  } // end of Reset
+#endif // 0
+
+/***********************************************************************/
+/*  OpenTableFile: opens a huge file using Windows/Unix API's.         */
+/***********************************************************************/
+bool BGXFAM::OpenTableFile(PGLOBAL g)
+  {
+  char    filename[_MAX_PATH];
+  MODE    mode = Tdbp->GetMode();
+  PDBUSER dbuserp = PlgGetUser(g);
+
+  if ((To_Fb && To_Fb->Count) || Hfile != INVALID_HANDLE_VALUE) {
+    snprintf(g->Message, sizeof(g->Message), MSG(FILE_OPEN_YET), To_File);
+    return true;
+    } // endif
+
+  PlugSetPath(filename, To_File, Tdbp->GetPath());
+
+  if (trace(1))
+    htrc("OpenTableFile: filename=%s mode=%d\n", filename, mode);
+
+#if defined(_WIN32)
+  DWORD rc, access, creation, share = 0;
+
+  /*********************************************************************/
+  /*  Create the file object according to access mode                  */
+  /*********************************************************************/
+  switch (mode) {
+    case MODE_READ:
+      access = GENERIC_READ;
+      share = FILE_SHARE_READ;
+      creation = OPEN_EXISTING;
+      break;
+    case MODE_DELETE:
+      if (!Tdbp->GetNext()) {
+        // Store the number of deleted rows
+        DelRows = Cardinality(g);
+
+        // This will delete the whole file and provoque ReadDB to
+        // return immediately.
+        access = GENERIC_READ | GENERIC_WRITE;
+        creation = TRUNCATE_EXISTING;
+        Tdbp->ResetSize();
+        Headlen = 0;
+        break;
+        } // endif
+
+      // Selective delete, pass thru
+    case MODE_UPDATE:
+      if ((UseTemp = Tdbp->IsUsingTemp(g)))
+        access = GENERIC_READ;
+      else
+        access = GENERIC_READ | GENERIC_WRITE;
+
+      creation = OPEN_EXISTING;
+      break;
+    case MODE_INSERT:
+      access = GENERIC_WRITE;
+      creation = OPEN_ALWAYS;
+      break;
+    default:
+      snprintf(g->Message, sizeof(g->Message), MSG(BAD_OPEN_MODE), mode);
+      return true;
+    } // endswitch
+
+  Hfile = CreateFile(filename, access, share, NULL, creation,
+                               FILE_ATTRIBUTE_NORMAL, NULL);
+
+  if (Hfile == INVALID_HANDLE_VALUE) {
+    rc = GetLastError();
+    snprintf(g->Message, sizeof(g->Message), MSG(OPEN_ERROR), rc, mode, filename);
+    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
+                  FORMAT_MESSAGE_IGNORE_INSERTS, NULL, rc, 0,
+                  (LPTSTR)filename, sizeof(filename), NULL);
+  } else
+    rc = 0;
+
+  if (trace(2))
+    htrc(" rc=%d access=%p share=%p creation=%d handle=%p fn=%s\n",
+         rc, access, share, creation, Hfile, filename);
+
+  if (mode == MODE_INSERT)
+    /*******************************************************************/
+    /* In Insert mode we must position the cursor at end of file.      */
+    /*******************************************************************/
+    if (BigSeek(g, Hfile, (BIGINT)0, FILE_END))
+      return true;
+
+#else   // UNIX
+  int    rc = 0;
+  int    oflag = O_LARGEFILE;         // Enable file size > 2G
+  mode_t tmode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
+
+  /*********************************************************************/
+  /*  Create the file object according to access mode                  */
+  /*********************************************************************/
+  switch (mode) {
+    case MODE_READ:
+      oflag |= O_RDONLY;
+      break;
+    case MODE_DELETE:
+      if (!Tdbp->GetNext()) {
+        // This will delete the whole file and provoque ReadDB to
+        // return immediately.
+        oflag |= (O_RDWR | O_TRUNC);
+        Tdbp->ResetSize();
+        break;
+        } // endif
+
+      // Selective delete
+      /* fall through */
+    case MODE_UPDATE:
+      UseTemp = Tdbp->IsUsingTemp(g);
+      oflag |= (UseTemp) ? O_RDONLY : O_RDWR;
+      break;
+    case MODE_INSERT:
+      oflag |= (O_WRONLY | O_CREAT | O_APPEND);
+ //   tmode = S_IREAD | S_IWRITE;
+      break;
+    default:
+      snprintf(g->Message, sizeof(g->Message), MSG(BAD_OPEN_MODE), mode);
+      return true;
+    } // endswitch
+
+  Hfile= global_open(g, MSGID_OPEN_ERROR_AND_STRERROR, filename, oflag, tmode);
+
+  if (Hfile == INVALID_HANDLE_VALUE) {
+    rc = errno;
+  } else
+    rc = 0;
+
+  if (trace(2))
+    htrc(" rc=%d oflag=%p tmode=%p handle=%p fn=%s\n",
+         rc, oflag, tmode, Hfile, filename);
+
+#endif  // UNIX
+
+  if (!rc) {
+    if (!To_Fb) {
+      To_Fb = (PFBLOCK)PlugSubAlloc(g, NULL, sizeof(FBLOCK));
+      To_Fb->Fname = To_File;
+      To_Fb->Type = TYPE_FB_HANDLE;
+      To_Fb->Memory = NULL;
+      To_Fb->Length = 0;
+      To_Fb->Mode = mode;
+      To_Fb->File = NULL;
+      To_Fb->Next = dbuserp->Openlist;
+      dbuserp->Openlist = To_Fb;
+      } // endif To_Fb
+
+    To_Fb->Count = 1;
+    To_Fb->Mode = mode;
+    To_Fb->Handle = Hfile;
+
+    /*******************************************************************/
+    /*  Allocate the block buffer.                                     */
+    /*******************************************************************/
+    return AllocateBuffer(g);
+  } else
+    return (mode == MODE_READ && rc == ENOENT)
+            ? PushWarning(g, Tdbp) : true;
+
+  } // end of OpenTableFile
+
+/***********************************************************************/
+/*  BIGFIX Cardinality: returns table cardinality in number of rows.   */
+/*  This function can be called with a null argument to test the       */
+/*  availability of Cardinality implementation (1 yes, 0 no).          */
+/***********************************************************************/
+int BGXFAM::Cardinality(PGLOBAL g)
+  {
+  if (g) {
+    char   filename[_MAX_PATH];
+    int   card = -1;
+    BIGINT fsize;
+
+    PlugSetPath(filename, To_File, Tdbp->GetPath());
+
+#if defined(_WIN32)  // OB
+    LARGE_INTEGER len;
+    DWORD         rc = 0;
+
+    len.QuadPart = -1;
+
+    if (Hfile == INVALID_HANDLE_VALUE) {
+      HANDLE h = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ,
+                   NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+
+      if (h == INVALID_HANDLE_VALUE)
+        if ((rc = GetLastError()) != ERROR_FILE_NOT_FOUND) {
+          snprintf(g->Message, sizeof(g->Message), MSG(OPEN_ERROR), rc, 10, filename);
+          FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
+                        FORMAT_MESSAGE_IGNORE_INSERTS, NULL, rc, 0,
+                        (LPTSTR)filename, sizeof(filename), NULL);
+          safe_strcat(g->Message, sizeof(g->Message), filename);
+          return -1;
+        } else
+          return 0;                     // File does not exist
+
+      // Get the size of the file (can be greater than 4 GB)
+      len.LowPart = GetFileSize(h, (LPDWORD)&len.HighPart);
+      CloseHandle(h);
+    } else
+      len.LowPart = GetFileSize(Hfile, (LPDWORD)&len.HighPart);
+
+    if (len.LowPart == 0xFFFFFFFF && (rc = GetLastError()) != NO_ERROR) {
+      snprintf(g->Message, sizeof(g->Message), MSG(FILELEN_ERROR), "GetFileSize", filename);
+      return -2;
+    } else
+      fsize = len.QuadPart;
+
+#else    // UNIX
+    if (Hfile == INVALID_HANDLE_VALUE) {
+      int h = open64(filename, O_RDONLY, 0);
+
+      if (trace(1))
+        htrc(" h=%d\n", h);
+
+      if (h == INVALID_HANDLE_VALUE) {
+        if (trace(1))
+          htrc("  errno=%d ENOENT=%d\n", errno, ENOENT);
+
+        if (errno != ENOENT) {
+          snprintf(g->Message, sizeof(g->Message), MSG(OPEN_ERROR_IS),
+                              filename, strerror(errno));
+          return -1;
+        } else
+          return 0;                      // File does not exist
+
+        } // endif h
+
+      // Get the size of the file (can be greater than 4 GB)
+      fsize = lseek64(h, 0, SEEK_END);
+      close(h);
+    } else {
+      BIGINT curpos = lseek64(Hfile, 0, SEEK_CUR);
+
+      fsize = lseek64(Hfile, 0, SEEK_END);
+      lseek64(Hfile, curpos, SEEK_SET);
+    } // endif Hfile
+
+    if (fsize < 0) {
+      snprintf(g->Message, sizeof(g->Message), MSG(FILELEN_ERROR), "lseek64", filename);
+      return -2;
+      } // endif fsize
+
+#endif   // UNIX
+
+    // Check the real size of the file
+    if (Padded && Blksize) {
+      if (fsize % (BIGINT)Blksize) {
+        snprintf(g->Message, sizeof(g->Message), MSG(NOT_FIXED_LEN),
+                            filename, (int)fsize, Lrecl);
+        return -3;
+      } else
+        card = (int)(fsize / (BIGINT)Blksize) * Nrec;
+
+    } else if (fsize % (BIGINT)Lrecl) {
+      snprintf(g->Message, sizeof(g->Message), MSG(NOT_FIXED_LEN), filename, (int)fsize, Lrecl);
+      return -3;
+    } else
+      card = (int)(fsize / (BIGINT)Lrecl); // Fixed length file
+
+    if (trace(1))
+      htrc(" Computed max_K=%d fsize=%lf lrecl=%d\n",
+           card, (double)fsize, Lrecl);
+
+    // Set number of blocks for later use
+    Block = (card + Nrec - 1) / Nrec;
+    return card;
+  } else
+    return -1;
+
+  } // end of Cardinality
+
+/***********************************************************************/
+/*  WriteModifiedBlock: Used when updating.                            */
+/***********************************************************************/
+int BGXFAM::WriteModifiedBlock(PGLOBAL g)
+  {
+  /*********************************************************************/
+  /*  The old block was modified in Update mode.                       */
+  /*  In Update mode we simply rewrite the old block on itself.        */
+  /*********************************************************************/
+  int  rc = RC_OK;
+  bool moved = false;
+
+  if (UseTemp)                // Copy any intermediate lines.
+    if (MoveIntermediateLines(g, &moved))
+      rc = RC_FX;
+
+  if (rc == RC_OK) {
+    // Set file position to OldBlk position (Fpos)
+    if (!moved && BigSeek(g, Hfile, (BIGINT)Fpos * (BIGINT)Lrecl))
+      rc = RC_FX;
+    else if (BigWrite(g, Tfile, To_Buf, Lrecl * Rbuf))
+      rc = RC_FX;
+
+    Spos = Fpos + Nrec;       // + Rbuf ???
+    } // endif rc
+
+  if (Closing || rc != RC_OK) // Error or called from CloseDB
+    return rc;
+
+  // NOTE: Next line was added to avoid a very  strange fread bug.
+  // When the fseek is not executed (even the file has the good
+  // pointer position) the next read can happen anywhere in the file.
+  OldBlk = CurBlk;       // This will force fseek to be executed
+  Modif = 0;
+  return rc;
+  } // end of WriteModifiedBlock
+
+/***********************************************************************/
+/*  ReadBuffer: Read Nrec lines for a big fixed/binary file.           */
+/***********************************************************************/
+int BGXFAM::ReadBuffer(PGLOBAL g)
+  {
+  int nbr, rc = RC_OK;
+
+  /*********************************************************************/
+  /*  Sequential reading when Placed is not true.                      */
+  /*********************************************************************/
+  if (Placed) {
+    Tdbp->SetLine(To_Buf + CurNum * Lrecl);
+    Placed = false;
+  } else if (++CurNum < Rbuf) {
+    Tdbp->IncLine(Lrecl);                // Used by DOSCOL functions
+    return RC_OK;
+  } else if (Rbuf < Nrec && CurBlk != -1) {
+    return RC_EF;
+  } else {
+    /*******************************************************************/
+    /*  New block.                                                     */
+    /*******************************************************************/
+    CurNum = 0;
+    Tdbp->SetLine(To_Buf);
+
+ next:
+    if (++CurBlk >= Block)
+      return RC_EF;
+
+    /*******************************************************************/
+    /*  Before reading a new block, check whether block optimization   */
+    /*  can be done, as well as for join as for local filtering.       */
+    /*******************************************************************/
+    switch (Tdbp->TestBlock(g)) {
+      case RC_EF:
+        return RC_EF;
+      case RC_NF:
+        goto next;
+      } // endswitch rc
+
+   } // endif's
+
+  if (OldBlk == CurBlk) {
+    IsRead = true;       // Was read indeed
+    return RC_OK;        // Block is already there
+    } // endif OldBlk
+
+  // Write modified block in mode UPDATE
+  if (Modif && (rc = WriteModifiedBlock(g)) != RC_OK)
+    return rc;
+
+  Fpos = CurBlk * Nrec;
+
+  // Setting file pointer is required only in non sequential reading
+  if (CurBlk != OldBlk + 1)
+    if (BigSeek(g, Hfile, (BIGINT)Fpos * (BIGINT)Lrecl))
+      return RC_FX;
+
+  if (trace(2))
+    htrc("File position is now %d\n", Fpos);
+
+  nbr = BigRead(g, Hfile, To_Buf, (Padded) ? Blksize : Lrecl * Nrec);
+
+  if (nbr > 0) {
+    Rbuf = (Padded) ? Nrec : nbr / Lrecl;
+    rc = RC_OK;
+    ReadBlks++;
+    num_read++;
+  } else
+    rc = (nbr == 0) ? RC_EF : RC_FX;
+
+  OldBlk = CurBlk;             // Last block actually read
+  IsRead = true;               // Is read indeed
+  return rc;
+  } // end of ReadBuffer
+
+/***********************************************************************/
+/*  WriteBuffer: File write routine for BGXFAM access method.          */
+/*  Updates are written into the (Temp) file in ReadBuffer.            */
+/***********************************************************************/
+int BGXFAM::WriteBuffer(PGLOBAL g)
+  {
+  if (trace(2))
+    htrc("BIG WriteDB: Mode=%d buf=%p line=%p Nrec=%d Rbuf=%d CurNum=%d\n",
+         Tdbp->GetMode(), To_Buf, Tdbp->GetLine(), Nrec, Rbuf, CurNum);
+
+  if (Tdbp->GetMode() == MODE_INSERT) {
+    /*******************************************************************/
+    /*  In Insert mode, blocks are added sequentialy to the file end.  */
+    /*******************************************************************/
+    if (++CurNum != Rbuf) {
+      Tdbp->IncLine(Lrecl);            // Used by DOSCOL functions
+      return RC_OK;                    // We write only full blocks
+      } // endif CurNum
+
+    if (trace(2))
+      htrc(" First line is '%.*s'\n", Lrecl - 2, To_Buf);
+
+    //  Now start the writing process.
+    if (BigWrite(g, Hfile, To_Buf, Lrecl * Rbuf))
+      return RC_FX;
+
+    CurBlk++;
+    CurNum = 0;
+    Tdbp->SetLine(To_Buf);
+
+    if (trace(2))
+      htrc("write done\n");
+
+  } else {                           // Mode == MODE_UPDATE
+    // Tfile is the temporary file or the table file handle itself
+    if (Tfile == INVALID_HANDLE_VALUE) {
+      if (UseTemp /*&& Tdbp->GetMode() == MODE_UPDATE*/) {
+        if (OpenTempFile(g))
+          return RC_FX;
+
+      } else
+        Tfile = Hfile;
+
+      } // endif Tfile
+
+    if (Nrec > 1)
+      Modif++;                         // Modified line in blocked mode
+    else if (WriteModifiedBlock(g))    // Indexed update
+      return RC_FX;
+
+  } // endif Mode
+
+  return RC_OK;
+  } // end of WriteBuffer
+
+/***********************************************************************/
+/*  Data Base delete line routine for BGXFAM access method.            */
+/***********************************************************************/
+int BGXFAM::DeleteRecords(PGLOBAL g, int irc)
+  {
+  bool moved;
+
+  /*********************************************************************/
+  /*  There is an alternative here:                                    */
+  /*  1 - use a temporary file in which are copied all not deleted     */
+  /*      lines, at the end the original file will be deleted and      */
+  /*      the temporary file renamed to the original file name.        */
+  /*  2 - directly move the not deleted lines inside the original      */
+  /*      file, and at the end erase all trailing records.             */
+  /*  This will be experimented.                                       */
+  /*********************************************************************/
+  if (trace(2))
+    htrc("BGX DeleteDB: rc=%d UseTemp=%d Fpos=%d Tpos=%d Spos=%d\n",
+         irc, UseTemp, Fpos, Tpos, Spos);
+
+  if (irc != RC_OK) {
+    /*******************************************************************/
+    /*  EOF: position Fpos at the end-of-file position.                */
+    /*******************************************************************/
+    Fpos = Tdbp->Cardinality(g);
+
+    if (trace(2))
+      htrc("Fpos placed at file end=%d\n", Fpos);
+
+  } else    // Fpos is the deleted line position
+    Fpos = CurBlk * Nrec + CurNum;
+
+  if (Tpos == Spos) {
+    /*******************************************************************/
+    /*  First line to delete. Move of eventual preceding lines is     */
+    /*  not required here if a temporary file is not used, just the    */
+    /*  setting of future Spos and Tpos.                               */
+    /*******************************************************************/
+    if (UseTemp) {
+      /*****************************************************************/
+      /*  Open the temporary file, Spos is at the beginning of file.   */
+      /*****************************************************************/
+      if (OpenTempFile(g))
+        return RC_FX;
+
+    } else {
+      /*****************************************************************/
+      /*  Move of eventual preceding lines is not required here.      */
+      /*  Set the target file as being the source file itself.         */
+      /*  Set the future Tpos, and give Spos a value to block copying. */
+      /*****************************************************************/
+      Tfile = Hfile;
+      Spos = Tpos = Fpos;
+    } // endif UseTemp
+
+    } // endif Tpos == Spos
+
+  /*********************************************************************/
+  /*  Move any intermediate lines.                                     */
+  /*********************************************************************/
+  if (MoveIntermediateLines(g, &moved))
+    return RC_FX;
+
+  if (irc == RC_OK) {
+    if (trace(1))
+      assert(Spos == Fpos);
+
+    Spos++;          // New start position is on next line
+
+    if (moved) {
+      if (BigSeek(g, Hfile, (BIGINT)Spos * (BIGINT)Lrecl))
+        return RC_FX;
+
+      OldBlk = -2;  // To force fseek to be executed on next block
+      } // endif moved
+
+    if (trace(2))
+      htrc("after: Tpos=%d Spos=%d\n", Tpos, Spos);
+
+  } else if (irc != RC_OK) {
+    /*******************************************************************/
+    /*  Last call after EOF has been reached.                          */
+    /*******************************************************************/
+    if (UseTemp) {
+      /*****************************************************************/
+      /*  Ok, now delete old file and rename new temp file.            */
+      /*****************************************************************/
+      if (RenameTempFile(g))
+        return RC_FX;
+
+    } else {
+      /*****************************************************************/
+      /*  Remove extra records.                                        */
+      /*****************************************************************/
+#if defined(_WIN32)
+      if (BigSeek(g, Hfile, (BIGINT)Tpos * (BIGINT)Lrecl))
+        return RC_FX;
+
+      if (!SetEndOfFile(Hfile)) {
+        DWORD drc = GetLastError();
+
+        snprintf(g->Message, sizeof(g->Message), MSG(SETEOF_ERROR), drc);
+        return RC_FX;
+        } // endif error
+#else   // !_WIN32
+      if (ftruncate64(Hfile, (BIGINT)(Tpos * Lrecl))) {
+        snprintf(g->Message, sizeof(g->Message), MSG(TRUNCATE_ERROR), strerror(errno));
+        return RC_FX;
+        } // endif
+#endif  // !_WIN32
+
+    } // endif UseTemp
+
+  } // endif irc
+
+  return RC_OK;                                      // All is correct
+  } // end of DeleteRecords
+
+/***********************************************************************/
+/*  Open a temporary file used while updating or deleting.             */
+/***********************************************************************/
+bool BGXFAM::OpenTempFile(PGLOBAL g)
+  {
+  char   *tempname;
+  PDBUSER dup = PlgGetUser(g);
+
+  /*********************************************************************/
+  /*  Open the temporary file, Spos is at the beginning of file.       */
+  /*********************************************************************/
+  tempname = (char*)PlugSubAlloc(g, NULL, _MAX_PATH);
+  PlugSetPath(tempname, To_File, Tdbp->GetPath());
+  PlugRemoveType(tempname, tempname);
+  safe_strcat(tempname, _MAX_PATH, ".t");
+  remove(tempname);       // Be sure it does not exist yet
+
+#if defined(_WIN32)
+  Tfile = CreateFile(tempname, GENERIC_WRITE, 0, NULL,
+                     CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
+
+  if (Tfile == INVALID_HANDLE_VALUE) {
+    DWORD rc = GetLastError();
+    snprintf(g->Message, sizeof(g->Message), MSG(OPEN_ERROR), rc, MODE_INSERT,
+             tempname);
+    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
+              FORMAT_MESSAGE_IGNORE_INSERTS, NULL, rc, 0,
+              (LPTSTR)tempname, _MAX_PATH, NULL);
+    safe_strcat(g->Message, sizeof(g->Message), tempname);
+    return true;
+    } // endif Tfile
+#else    // UNIX
+  Tfile = open64(tempname, O_WRONLY | O_TRUNC, S_IWRITE);
+
+  if (Tfile == INVALID_HANDLE_VALUE) {
+    int rc = errno;
+    snprintf(g->Message, sizeof(g->Message), MSG(OPEN_ERROR)" %s", rc,
+             MODE_INSERT, tempname, strerror(errno));
+    return true;
+    } //endif Tfile
+#endif   // UNIX
+
+  To_Fbt = (PFBLOCK)PlugSubAlloc(g, NULL, sizeof(FBLOCK));
+  To_Fbt->Fname = tempname;
+  To_Fbt->Type = TYPE_FB_HANDLE;
+  To_Fbt->Memory = NULL;
+  To_Fbt->Length = 0;
+  To_Fbt->File = NULL;
+  To_Fbt->Next = dup->Openlist;
+  To_Fbt->Count = 1;
+  To_Fbt->Mode = MODE_INSERT;
+  To_Fbt->Handle = Tfile;
+  dup->Openlist = To_Fbt;
+  return false;
+  } // end of OpenTempFile
+
+/***********************************************************************/
+/*  Move intermediate deleted or updated lines.                        */
+/***********************************************************************/
+bool BGXFAM::MoveIntermediateLines(PGLOBAL g, bool *b)
+  {
+  int n, req, nbr;
+
+  for (*b = false, n = Fpos - Spos; n > 0; n -= req) {
+    /*******************************************************************/
+    /*  Non consecutive line to delete. Move intermediate lines.       */
+    /*******************************************************************/
+    if (!UseTemp || !*b)
+      if (BigSeek(g, Hfile, (BIGINT)Spos * (BIGINT)Lrecl))
+        return true;
+
+    req = MY_MIN(n, Dbflen) * Lrecl;
+
+    if ((nbr = BigRead(g, Hfile, DelBuf, req)) != req) {
+      snprintf(g->Message, sizeof(g->Message), MSG(DEL_READ_ERROR), req, nbr);
+      return true;
+      } // endif nbr
+
+    if (!UseTemp)
+      if (BigSeek(g, Tfile, (BIGINT)Tpos * (BIGINT)Lrecl))
+        return true;
+
+    if (BigWrite(g, Tfile, DelBuf, req))
+      return true;
+
+    req /= Lrecl;
+    Tpos += (int)req;
+    Spos += (int)req;
+
+    if (trace(2))
+      htrc("loop: Tpos=%d Spos=%d\n", Tpos, Spos);
+
+    *b = true;
+    } // endfor n
+
+  return false;
+  } // end of MoveIntermediateLines
+
+/***********************************************************************/
+/*  Data Base close routine for BIGFIX access method.                  */
+/***********************************************************************/
+void BGXFAM::CloseTableFile(PGLOBAL g, bool abort)
+  {
+  int rc = RC_OK, wrc = RC_OK;
+  MODE mode = Tdbp->GetMode();
+
+  Abort = abort;
+
+  // Closing is True if last Write was in error
+  if (mode == MODE_INSERT && CurNum && !Closing) {
+    // Some more inserted lines remain to be written
+    Rbuf = CurNum--;
+    wrc = WriteBuffer(g);
+  } else if (mode == MODE_UPDATE) {
+    if (Modif && !Closing) {
+      // Last updated block remains to be written
+      Closing = true;
+      wrc = WriteModifiedBlock(g);
+      } // endif Modif
+
+    if (UseTemp && Tfile && wrc == RC_OK) {
+      if (!Abort) {
+        // Copy any remaining lines
+        bool b;
+    
+        Fpos = Tdbp->Cardinality(g);
+        Abort = MoveIntermediateLines(g, &b) != RC_OK;
+        } // endif Abort
+
+      // Delete the old file and rename the new temp file.
+      RenameTempFile(g);
+      goto fin;
+      } // endif UseTemp
+
+  } // endif's mode
+
+  // Finally close the file
+  rc = PlugCloseFile(g, To_Fb);
+
+ fin:
+  if (trace(1))
+    htrc("BGX CloseTableFile: closing %s mode=%d wrc=%d rc=%d\n",
+         To_File, mode, wrc, rc);
+
+  Hfile = INVALID_HANDLE_VALUE; // So we can know whether table is open
+  } // end of CloseTableFile
+
+/***********************************************************************/
+/*  Rewind routine for huge FIX access method.                         */
+/*  Note: commenting out OldBlk = -1 has two advantages:               */
+/*  1 - It forces fseek on  first block, thus suppressing the need to  */
+/*      rewind the file, anyway unuseful when second pass if indexed.  */
+/*  2 - It permit to avoid re-reading small tables having only 1 block.*/
+/*      (even very unlikely for huge files!)                           */
+/***********************************************************************/
+void BGXFAM::Rewind(void)
+  {
+#if 0    // This is probably unuseful because file is accessed directly
+#if defined(_WIN32)  //OB
+  SetFilePointer(Hfile, 0, NULL, FILE_BEGIN);
+#else    // UNIX
+  lseek64(Hfile, 0, SEEK_SET);
+#endif   // UNIX
+#endif // 0
+  CurBlk = -1;
+  CurNum = Rbuf;
+//OldBlk = -1;
+//Rbuf = 0;        commented out in case we reuse last read block
+  Fpos = 0;
+  } // end of Rewind