#include "hbsxdef.ch" 
 ... 
    leto_HrbLoad() 
  
    IF ! EMPTY( oApp:cTrigger ) 
       WrLog( "Trigger "+oApp:cTrigger+" "+_u2s(leto_Driver( oApp:nDriver )) ) 
       HB_RddInfo( RDDI_TRIGGER, oApp:cTrigger, leto_Driver( oApp:nDriver ) ) 
    ENDIF 
    IF ! EMPTY( oApp:cPendingTrigger ) 
       WrLog( "pendingTrigger "+oApp:cTrigger+" "+_u2s(leto_Driver( oApp:nDriver )) ) 
       HB_RddInfo( RDDI_PENDINGTRIGGER, oApp:cPendingTrigger, leto_Driver( oApp:nDriver ) ) 
    ENDIF 
 ... 
 ///////////////////////////////////////////////////////////////////////////////    
 FUNCTION tst_Trigger( nEvent, nArea, nPos, xTrigVal ) 
 LOCAL i := nEvent, j := '', k 
  
  k := _u2s(nEvent)+':'+_u2s(nArea)+':'+_u2s(nPos)+':'+_u2s(xTrigVal) 
  WrLog(procname()+':'+k) 
  
  IF     nEvent == EVENT_POSTUSE                                        // 2 
     dbInfo(DBI_TRIGGER, .F.)  
     j := 'EVENT_POSTUSE' 
     k := _u2s(nEvent)+':'+j+':'+_u2s(nArea)+':'+_u2s(nPos)+':'+_u2s(xTrigVal) 
     WrLog(procname()+':'+k) 
     dbInfo(DBI_TRIGGER, .T.)  
     RETURN .T. 
  ELSEIF nEvent == EVENT_PRECLOSE                                       // 11 
     dbInfo(DBI_TRIGGER, .F.)  
     j := 'EVENT_PRECLOSE' 
     k := _u2s(nEvent)+':'+j+':'+_u2s(nArea)+':'+_u2s(nPos)+':'+_u2s(xTrigVal) 
     WrLog(procname()+':'+k) 
     dbInfo(DBI_TRIGGER, .T.)  
     RETURN .T. 
  ELSEIF nEvent < EVENT_UPDATE .or. nEvent > EVENT_ZAP 
     dbInfo(DBI_TRIGGER, .F.)  
     j := 'EVENT_UPDATE-EVENT_ZAP' 
     k := _u2s(nEvent)+':'+j+':'+_u2s(nArea)+':'+_u2s(nPos)+':'+_u2s(xTrigVal) 
     WrLog(procname()+':'+k) 
     dbInfo(DBI_TRIGGER, .T.)  
     RETURN .T. 
  ENDIF 
  
  dbInfo(DBI_TRIGGER, .F.)  
  DO CASE 
     CASE nEvent == EVENT_UPDATE                                        // 3 
     j := 'EVENT_UPDATE' 
     CASE nEvent == EVENT_APPEND                                        // 4 
     j := 'EVENT_APPEND' 
     CASE nEvent == EVENT_DELETE                                        // 5 
     j := 'EVENT_DELETE' 
     CASE nEvent == EVENT_RECALL                                        // 6 
     j := 'EVENT_RECALL' 
     CASE nEvent == EVENT_PACK                                          // 7 
     j := 'EVENT_PACK' 
     CASE nEvent == EVENT_ZAP                                           // 8 
     j := 'EVENT_ZAP' 
  ENDCASE 
  
  k := _u2s(nEvent)+':'+j+':'+_u2s(nArea)+':'+_u2s(nPos)+':'+_u2s(xTrigVal) 
  WrLog(procname()+':'+k) 
  
 *    CASE nEvent == EVENT_PREUSE                                        // 1 
 *    CASE nEvent == EVENT_POSTUSE                                       // 2 
 *    CASE nEvent == EVENT_PACK                                          // 7 
 *    CASE nEvent == EVENT_ZAP                                           // 8 
 *    CASE nEvent == EVENT_PUT                                           // 9 
 *    CASE nEvent == EVENT_GET                                           // 10 
 *    CASE nEvent == EVENT_PRECLOSE                                      // 11 
 *    CASE nEvent == EVENT_POSTCLOSE                                     // 12 
 *    CASE nEvent == EVENT_PREMEMOPACK                                   // 13 
 *    CASE nEvent == EVENT_POSTMEMOPACK                                  // 14 
  
  dbInfo(DBI_TRIGGER, .T.)  
  
 RETURN .T. 
 ///////////////////////////////////////////////////////////////////////////////    
 STATIC FUNCTION _u2s( uValue ) 
 LOCAL cType := ValType( uValue ) 
  
    IF     cType == "L" 
       RETURN iif( uValue, ".T.", ".F." ) 
    ELSEIF cType == "N" 
       RETURN AllTrim( Str( uValue ) ) 
    ELSEIF cType == "D" 
       RETURN Dtoc( uValue ) 
    ELSEIF cType == "A" 
       RETURN 'ARRAY['+AllTrim( Str( len(uValue) ) )+']' 
    ELSEIF cType == "C" 
       RETURN trim(uValue) 
    ELSEIF cType == "U" 
       RETURN 'NIL' 
    ELSE 
       uValue := 'VALTYPE='+cType 
    ENDIF 
  
 RETURN uValue 
  
 letodb.ini: 
 [Main] 
 Port           = 2812 
 DataPath       = . 
 EnableFileFunc = 1 
 Trigger = tst_Trigger 
 ;PendingTrigger = tst_Trigger 
  
 

 
 #include "wvtwin.ch" 
 #include "hbgtinfo.ch" 
 #include "rddleto.ch" 
 #include "dbinfo.ch" 
  
 REQUEST HB_GT_WVT 
 REQUEST HB_GT_WVT_DEFAULT 
  
 REQUEST HB_CODEPAGE_LV866 
 REQUEST LETO, DBFCDX 
  
 Function Main( cPath ) 
 Local aNames := { "Petr", "Ivan", "Alexander", "Pavel", "Alexey", "Fedor", ; 
    "Konstantin", "Vladimir", "Nikolay", "Andrey", "Dmitry", "Sergey" } 
 Local i, aStru 
 Local cFont 
  
 Field NAME, NUM, INFO, DINFO 
  
  hb_gtInfo( HB_GTI_CODEPAGE, 866) 
  hb_setCodePage( "LV866" ) 
  hb_setTermCP( "LV866" ) 
   
  hb_GtInfo( HB_GTI_FONTNAME   , cFont ) 
  hb_gtInfo( HB_GTI_FONTQUALITY, 3     ) 
  
    RDDSETDEFAULT( "LETO" ) 
  
    SET DATE FORMAT "dd/mm/yy" 
  
    cPath := "//127.0.0.1:2812/temp/" 
  
    ? "Connect to " + cPath + " - " 
    IF ( leto_Connect( cPath ) ) == -1 
       nRes := leto_Connect_Err() 
       IF nRes == LETO_ERR_LOGIN 
          ?? "Login failed" 
       ELSEIF nRes == LETO_ERR_RECV 
          ?? "Recv Error" 
       ELSEIF nRes == LETO_ERR_SEND 
          ?? "Send Error" 
       ELSE 
          ?? "No connection" 
       ENDIF 
       Return Nil 
    ELSE 
       ?? "Ok" 
    ENDIF 
  
    dbCreate( cPath+"test1", { {"NAME"  , "C", 10, 0},  ; 
                               {"NUM"   , "N",  4, 0},  ; 
                               {"INFO"  , "C", 32, 0},  ; 
                               {"DINFO" , "D",  8, 0},  ; 
                               {"TM"    , "@",  8, 0},  ; 
                               {"TS"    , "=",  8, 0},  ; 
                               {"VM"    , "^",  8, 0},  ; 
                               {"ID"    , "+",  4, 0}   ; 
                             } ) 
    ? "File has been created" 
  
    USE ( cPath+"test1" ) New 
    ? "File has been opened", used(), alias() 
    aStru := dbStruct() 
    ? "Fields:", Len( aStru ) 
    FOR i := 1 TO Len( aStru ) 
       ? i, padr(aStru[i,1], 10), aStru[i,2], aStru[i,3], aStru[i,4], hb_FieldType(i) 
    NEXT 
    inkey(0) 
  
    FOR i := 1 TO Len( aNames ) 
       APPEND BLANK 
       REPLACE NAME WITH aNames, NUM WITH i+1000, ; 
          INFO WITH "This is a record number "+Ltrim(Str(i)), ; 
          DINFO WITH Date()+i-1 
 //       dbCommit() 
 //      dbGoto(RecNo()) 
 //      dbSkip(0) 
       dbGoto(RecNo()) 
       ? str(RecNo(), 3), NAME, NUM, TM, TS, VM, ID 
    NEXT 
    ? 
    ? "Records has been added", LastRec() 
    ? "Press any key to finish..." 
    Inkey(0) 
  
 Return Nil 
  
 получаем letodb.log: 
 02/23/15 12:03:17: Leto DB Server has been started. 
  
  
 Leto DB Server v.2.15 ! INIT: DataPath=., ShareTables=0, MaxUsers=500, MaxTables=5000, CacheRecords=10 
  
 02/23/15 12:03:17: Trigger tst_Trigger DBFCDX 
  
 02/23/15 12:18:09: Send STOP to server... 
  
 02/23/15 12:18:12: Server has been closed. 
 

 
 ... 
  // таблица LETO открыта exclusive 
  nLenRec := ...    // длина записи передаваемой на сервер 
  nKolBuf := 500  // кол-во записей в буфере транзакции 
  nMaxBuf := (nKolBuf+1) * nLenRec  // размер буфера транзакции 
  nKol := 0  // счетчик записей для транзакции 
  nCnt := 0  // общий счетчик записей 
  nDel := 0  // счетчик удаленных 
  // текущий alias это LETO таблица 
  leto_BeginTransaction(nMaxBuf) 
  DO WHILE ! ( nInp )->( EOF() ) 
     IF nKol >= nKolBuf 
        nKol := 0 
        IF leto_InTransaction(); leto_CommitTransaction() 
        ENDIF 
        leto_BeginTransaction(nMaxBuf) 
     ENDIF 
     nCnt++ 
     nKol++ 
     dbAppend() 
     IF ! NetErr() 
         // из ( nInp )-> .... переносим данные Fields 
        IF ( nInp )->( deleted() )    // на входе запись удаленная 
             dbDelete() 
             nDel++ 
        ENDIF 
     ENDIF 
  
     ( nInp )->dbSkip(1) 
  ENDDO 
  
  IF leto_InTransaction(); leto_CommitTransaction() 
  ENDIF 
  dbCommit() 
 ... 
 

 
 STATIC lLetoConnect := .F. 
  
 FUNCTION MAIN() 
 LOCAL cTable, cAlias, nSkip, hBrowse 
 LOCAL cFileDbf 
 .... 
  
  IF ! myConnnect() 
     RETURN NIL 
  ENDIF 
  
  cFileDbf := cPathLocal + "test866.dbf" 
  cTable   := cPathServer+"test1251.dbf" 
  cAlias   := "TEST_1251" 
 // ------ я выношу проверку и создание таблиц в отдельный модуль 
  aStru  := {                              ; 
              { "FIO"      , "C", 25, 0 }, ; 
              { "STATUS"   , "C", 10, 0 }, ; 
              { "CLASS"    , "C",  4, 0 }, ; 
              { "ID"       , "+",  4, 0 }  ; 
            } 
  
  aIndex := {                              ; 
              {'FIO', 'UPPER(FIO)', .F.}   ; 
            } 
  
  
  IF ! file(cFileDbf) 
 // ... 
 // создаем файл cFileDbf !!! 
 // ... 
  ENDIF 
  
  IF ! Table_Create( cTable, aStru, aIndex) 
     MsgStop('Table not create :'+ chr(10))+cTable, 'ERROR') 
     RETURN NIL 
  ENDIF 
 // ------ 
  
  IF ! Table_Open(cTable, cAlias, .T.) 
     MsgStop('Table not open :'+ chr(10))+cTable, 'ERROR') 
     RETURN NIL 
  ENDIF 
  
   DEFINE WINDOW Form_6             ; 
      ... 
  
    @ 55, 10 BROWSE Browse_1 WIDTH 575 HEIGHT 130 ; 
       HEADERS { '№№', 'ФИО/FIO', 'Статус/Status', 'Класс/Class' } ; 
       WORKAREA &cAlias ; 
       WIDTHS  { 60, 280, 110, 100 }     ; 
       FIELDS  {"ID", "FIO", "STATUS", "CLASS"} ; 
       FONT "Tahoma" SIZE 10 BOLD ; 
       BACKCOLOR aGrColor                ; 
       DYNAMICFORECOLOR { fColor , fColor, fColor, fColor }   ; 
       DYNAMICBACKCOLOR { fColor2, fColor2, fColor2, fColor2 } 
  
 // ставим размер skip buffer (можно в on init это сделать) 
       hBrowse := Form_6.Browse_1.Handle  // GetControlHandle("Browse_1", ThisWindow.Name) 
       nSkip   := ListViewGetCountPerPage(hBrowse)          // строк на browse 
       ( cAlias )->( LETO_SETSKIPBUFFER( nSkip ) )          //  
 //      
       ... 
   END WINDOW 
   ... 
  
 RETURN NIL 
  
 /////////////////////////////////////////////////////////////////////////// 
 FUNC myConnect() 
 LOCAL nRes 
     
  IF ( leto_Connect( cPathServer ) ) == - 1 
     nRes := leto_Connect_Err() 
     IF nRes == LETO_ERR_LOGIN 
        cMsg := "Login failed to LetoDB" 
     ELSEIF nRes == LETO_ERR_RECV 
        cMsg := "Recv Error to LetoDB" 
     ELSEIF nRes == LETO_ERR_SEND 
        cMsg := "Send Error to LetoDB" 
     ELSE 
        cMsg := "No connection to LetoDB" 
     ENDIF 
     MsgStop( cMsg , "Error" ) 
     RETURN .F. 
  ENDIF 
  
  lLetoConnect := .T.            // connect есть 
  
 RETURN .T. 
  
 /////////////////////////////////////////////////////////////////////////// 
 FUNC Table_Open( cTable, cAlias, lShared )                 // открываем таблицу 
 LOCAL lRet 
   
  IF ! lLetoConnect; RETURN .F. 
  ENDIF 
  
  Default lShared := .T. 
  
  lRet := UseArea( cTable, cAlias, lShared, 'LETO') 
  
  IF lRet .and. OrdCount() > 0  // есть индекс подключаем 
     OrdSetFocus(1) 
     dbGotop() 
  ENDIF 
  
 RETURN  lRet 
  
 /////////////////////////////////////////////////////////////////////////// 
 FUNC Table_Create( cTable, aStru, aIndex )                 // создание таблицы 
 LOCAL lTable, cPath, cFile, cExt, cTag, cKey, lUnique, i,j,k 
   
  IF ! lLetoConnect; RETURN .F. 
  ENDIF 
  
  hb_FNameSplit(cTable, @cPath, @cFile, @cExt) 
  
  IF empty(cExt); cTable += '.dbf' 
  ENDIF 
  
  lTable := leto_file(cTable) 
  
  IF ! lTable 
     leto-fErase(cPath+cFile+'.cdx') 
     dbCreate(cTable, aStru, 'LETO', .T., "")  // можно задать алиас вместо "" 
     IF hb_IsArray(aIndex) 
        k := len(aIndex) 
        FOR i := 1 TO k 
            cTag := aIndex[ i ][1]       // Tag Name 
            cKey := aIndex[ i ][2]       // Tag Key 
            lUnq := aIndex[ i ][3]       // Tag Unique 
            OrdCreate( , cTag, cKey, &( "{||" + cKey + "}" ), lUnq ) 
        NEXT 
     ENDIF 
     dbCloseArea() 
     lTable := .T. 
  ENDIF 
  
 RETURN lTable 
  
 FUNC Dbf_2_Table( cFileDbf, cTable, lZap )          // load dbf 866 в таблицу 
 LOCAL nInp, nKol, nCnt, nDel, nAdd, i, k 
 LOCAL nLenRec, nMaxBuf, nKolBuf 
  
  IF ! file(cFileDbf) 
     MsgStop('File not found !'+chr(10)+cFileDbf, "ERROR") 
     RETURN .F. 
  ENDIF 
  
  USE ( cFileDbf )  ALIAS TEMP866 CODEPAGE "RU866" VIA "DBFCDX" //NEW SHARED 
  
  IF ! Used() 
     MsgStop('File not open !'+chr(10)+cFileDbf, "ERROR") 
     RETURN .F. 
  ENDIF 
  
  nInp := select()  
  
  IF ! Table_Open(cTable, , .T.)   // exclusive 
     ( nInp )->( dbClosearea() ) 
     MsgStop('Table not open !'+chr(10)+cTable, "ERROR") 
     RETURN .F. 
  ENDIF 
  
  IF OrdCount() > 0            // есть индекс отключаем 
     OrdSetFocus(0) 
     dbGotop() 
  ENDIF 
  
  IF ! empty(lZap)             // очистим таблицу 
     ZAP 
  ENDIF 
  
  k := fCount() - 1   // последнее поле (ID) не учитываем - заполняет rdd 
  
 // таблица LETO открыта exclusive 
   nLenRec := RecSize()+1    // длина записи передаваемой на сервер (Как считать ?) = кол-ву символов полей в БД ? 
   nKolBuf := 1000  // кол-во записей в буфере транзакции 
   nMaxBuf := (nKolBuf+1) * nLenRec  // размер буфера транзакции 
   nKol := 0  // счетчик записей для транзакции 
   nCnt := 0  // общий счетчик записей 
   nDel := 0  // счетчик удаленных 
   nAdd := 0  // счетчик реально добавленных 
   // текущий alias это LETO таблица - 
  
 // ------ здесь уст. начальную позицию бегунка - индикатора      
  
   leto_BeginTransaction(nMaxBuf) 
   DO WHILE ! ( nInp )->( EOF() ) 
      IF nKol >= nKolBuf 
         nKol := 0 
         IF leto_InTransaction(); leto_CommitTransaction() 
         ENDIF 
 // ------ здесь меняем позицию бегунка - индикатора      
         DO EVENTS 
 // ------ 
         leto_BeginTransaction(nMaxBuf) 
      ENDIF 
      nCnt++ 
      nKol++ 
      dbAppend() 
      IF ! NetErr() 
         nAdd++ 
         FOR i := 1 TO k          // из ( nInp )-> .... переносим данные Fields 
             FieldPut( i, ( nInp )->FieldGet(i) ) 
         NEXT 
  
         IF ( nInp )->( deleted() )    // на входе запись удаленная 
              dbDelete() 
              nDel++ 
         ENDIF 
      ENDIF 
  
      ( nInp )->dbSkip(1) 
   ENDDO 
  
   IF leto_InTransaction(); leto_CommitTransaction() 
   ENDIF 
   dbCommit() 
   dbGotop() 
  
   IF OrdCount() > 0           // есть индекс 
      REINDEX 
      OrdSetFocus(1) 
      dbGotop() 
   ENDIF 
  
   ( nInp )->( dbCloseArea() ) 
  
 // ------ здесь завершаем позицию бегунка - индикатора      
  
   Form_6.Browse_1.Refresh 
  
 RETURN .T. 
 /////////////////////////////////////////////////////////////////////////// 
 FUNC UseArea( cFile, cAls, lShare, cRdd, nWhl )   // Открыть таблицу или DBF 
 LOCAL w := 10, lRet, oError, bOldError, lAuto, lLeto 
 LOCAL cPth, cFil, cExt 
  
  IF hb_IsNumeric(nWhl) .and. nWhl > 0; w := nWhl 
  ENDIF 
  IF ! hb_IsChar(cRdd); cRdd := RddSetDefault() 
  ENDIF 
  
  lLeto := ( cRdd == 'LETO' ) 
  
  IF lLeto; lAuto := Set( _SET_AUTOPEN, .T. ) 
  ENDIF 
  
  select 0 
  
  IF empty(cAls) .or. ! hb_IsChar(cAls)       // алиас не задан - формируем сами 
     hb_FNameSplit(cFile, @cPth, @cFil, @cExt) 
     cAls := upper(cFil) 
     IF select(cAls) > 0; cAls := '_XYZ_'+hb_ntos(select()) 
     ENDIF 
  ENDIF 
  
  IF ! hb_IsLogical(lShare); lShare := .T. 
  ENDIF 
  
  NetErr( .F. ) 
  bOldError := ErrorBlock({ |oErr| break(oErr) }) 
  
  DO WHILE w-- > 0 
     BEGIN SEQUENCE 
        lRet := DbUseArea(.F., cRdd, cFile, cAls, lShare, .F.) 
     RECOVER USING oError 
        lRet := .F. 
     END SEQUENCE 
  
     IF lRet .AND. ! NetErr() 
        lRet := Used() 
        EXIT 
     ENDIF 
     hb_IdleSleep(0.2) 
  ENDDO 
  
  ErrorBlock( bOldError ) 
  
  IF lLeto; Set( _SET_AUTOPEN, lAuto ) 
  ENDIF 
  
 RETURN lRet