Inoffizielles deutsches Xbase-Forum

Code: Alles auswählen

DbeInfo(COMPONENT_DATA, DBFDBE_LIFETIME, 0)                                                        // Verweildauer von Records im lokalen Cache
DbeInfo(COMPONENT_ORDER, DBE_LOCKMODE, LOCKING_EXTENDED)                                           // Macht das die Massenabfertigung schneller? (29.10.2008)

DbeInfo(COMPONENT_DATA, FOXDBE_LIFETIME, 0)                                                        // Verweildauer von Records im lokalen Cache
DbeInfo(COMPONENT_ORDER, FOXDBE_LOCKMODE, LOCKING_EXTENDED)                                        // Macht das die Massenabfertigung schneller? (29.10.2008)
DbeInfo(COMPONENT_ORDER, CDXDBE_LOCKRETRY, 1000000)                                                // Lt. Aussage Till Warweg 26.08.2015 sinnvoll im Netzwerk

DbeInfo(COMPONENT_DATA, ADSDBE_LOCK_MODE, ADSDBE_PROPRIETARY_LOCKING)                              // dbf nur über ADS bearbeitbar
DbeInfo(COMPONENT_DATA, ADSDBE_TBL_MODE, ADSDBE_CDX)
DbeInfo(COMPONENT_ORDER, ADSDBE_TBL_MODE, ADSDBE_CDX)
DbeInfo(COMPONENT_DATA, ADSDBE_RIGHTS_MODE, ADSDBE_IGNORERIGHTS)
DbeInfo(COMPONENT_DATA, ADSDBE_TABLENAME_IS_ALIAS, .T.)

DbeSetDefault("ADSDBE")

Code: Alles auswählen

#include "Common.ch"
#include "foxdbe.ch"

PROCEDURE DbeSys()
  DbeLoad("FOXDBE")
  DbeSetDefault("FOXDBE")
RETURN

PROCEDURE Main
   LOCAL aStru := {}, x, cX

   SET CHARSET TO ANSI

   SET ALTERNATE TO test.txt
   SET ALTERNATE ON

   ?
   ? "Wie groß kann eine Standard FOXDBE DBF exclusive werden ?"
   ?
   ? "Start des Testes"

   * $TODO: place your application code here */

  AAdd( aStru , { "NAME"    ,"C", 50 ,  0 } )
  AAdd( aStru , { "Strasse" ,"C", 50 ,  0 } )
  AAdd( aStru , { "PLZ"     ,"C", 10 ,  0 } )
  AAdd( aStru , { "ORT"     ,"C", 50 ,  0 } )
  AAdd( aStru , { "CUST_ID" ,"N",  8 ,  0 } )

  DbCreate("TEST",aStru,"FOXDBE")
  USE TEST EXCLUSIVE

  x := 1

  DO WHILE .T.
     cX := str(x,18,0)
     DbAppend()
     FIELD->CUST_ID := x
     FIELD->NAME    := "Name   "+cX
     FIELD->STRASSE := "Strasse"+cX
     FIELD->ORT     := "Ort    "+cX
    //  dbcommit() // das bremst extrem
    IF right(cX,3)="000" .OR. x=1
        dbcommit() // das reicht völlig
        ? transform(x,"999,999,999,999,999,999"),trim(FIELD->NAME),transform(fsize("test.dbf"),"999,999,999,999,999,999")
        IF fsize("test.dbf") > 99999999999
           ? "Abbruch des erfolgreichen Tests !"
           ? transform(x,"999,999,999,999,999,999"),trim(FIELD->NAME),transform(fsize("test.dbf"),"999,999,999,999,999,999")
           exit
        ENDIF
     ENDIF
     x++

  ENDDO

  ? "Ende ohne Abbruch"

  SET ALTERNATE TO

  inkey(0)

RETURN

Code: Alles auswählen

SECTION Instance Request handling

   STATIC FUNCTION InstanceSocketHandlerFunc(clientAddr,socket)

      LOCAL command
      LOCAL data,retData
      LOCAL fileHandle

      * No handle coming in? Let's die
      IF .NOT. ReceiveDataFromSocket(socket,@fileHandle)
         RETURN NIL
      ENDIF

      DebugMessage(SVI("Instance request connection established with client &1 and handle &2",clientAddr,fileHandle))

      DO WHILE ReceiveDataFromSocket(socket,@data)

         command := data[1]

         DO CASE

            CASE command == FMRI_CMD_READ
                 SendDataToSocket(socket,HandleRead(fileHandle,data))

            CASE command == FMRI_CMD_WRITE
                 SendDataToSocket(socket,HandleWrite(fileHandle,data))

            CASE command == FMRI_CMD_SETPOINTER
                 SendDataToSocket(socket,HandleSetPointer(fileHandle,data))

            CASE command == FMRI_CMD_CLOSE
                 SendDataToSocket(socket,HandleClose(@fileHandle,data))

            CASE command == FMRI_CMD_GETSIZE
                 SendDataToSocket(socket,HandleGetSize(fileHandle,data))

            CASE command == FMRI_CMD_LOCK
                 SendDataToSocket(socket,HandleLock(fileHandle,data))

            CASE command == FMRI_CMD_UNLOCK
                 SendDataToSocket(socket,HandleUnlock(fileHandle,data))

            CASE command == FMRI_CMD_SETEND
                 SendDataToSocket(socket,HandleSetEnd(fileHandle,data))

            OTHERWISE
                 SysError(SVI("Unknown command &1 received.",command))

         ENDCASE

      ENDDO

      socket:Close()

      IF ValType(fileHandle) == "N"
         fm:PassOnCloseHandle(fileHandle)
      ENDIF

      DebugMessage(SVI("Instance request connection with client &1 closed.",clientAddr))

   RETURN NIL


   STATIC FUNCTION HandleRead(fileHandle,data)

      LOCAL buffer := LockNullString(data[2])
      LOCAL lpBytesRead := LockNullString(4)
      LOCAL rc

      rc := fm:PassOnReadFile(fileHandle,buffer,data[2],lpBytesRead,0)

   RETURN {rc,Bin2L(UnlockString(lpBytesRead)),UnlockString(buffer)}



   STATIC FUNCTION HandleWrite(fileHandle,data)

      LOCAL lpBuffer := LockString(data[2],STRINGTYPE_BINARY)
      LOCAL lpNumberOfBytesWritten := LockNullString(4)
      LOCAL rc

      * Pass on to the O/S
      rc := fm:PassOnWriteFile(fileHandle,lpBuffer,data[3],lpNumberOfBytesWritten,0)

      * Release the buffer
      ReleaseLockString(lpBuffer)

   RETURN {rc,Bin2L(UnlockString(lpNumberOfBytesWritten))}



   STATIC FUNCTION HandleSetPointer(fileHandle,data)

   RETURN fm:PassOnSetFilePointer(fileHandle,data[2],0,data[3])



   STATIC FUNCTION HandleClose(fileHandle)

      LOCAL rc := fm:PassOnCloseHandle(fileHandle)

      filehandle := "Handle has already been closed!"

   RETURN rc



   STATIC FUNCTION HandleGetSize(fileHandle)

      LOCAL rc := fm:PassOnGetFileSize(fileHandle,0)

   RETURN rc



   STATIC FUNCTION HandleLock(fileHandle,data)

   RETURN fm:PassOnLockFile(fileHandle,data[2],0,data[3],0)



   STATIC FUNCTION HandleUnlock(fileHandle,data)

   RETURN fm:PassOnUnlockFile(fileHandle,data[2],0,data[3],0)



   STATIC FUNCTION HandleSetEnd(fileHandle)

   RETURN fm:PassOnSetEndOfFile(fileHandle)



ENDSECTION