                            TURBO PASCAL + CLIPPER

                    +-----------------------------------+
                    |          .. 㧮          |
                    | "+ணࠬ", 1(2)/1993 |
                    +-----------------------------------+

------------------------------------------------------------------------------
  筮 ந  ࠧ     뫮
ᯮᮡ ਠ, 㡫  饬 , ᪠ ⮫쪮
 쬥 ࠧ襭  "+ணࠬ". ;)))))))))))))
------------------------------------------------------------------------------

     প           ॡ ॠ樨 筮
᫮  ⬮, ਥ஢  ᯮ짮 ᫮  ,
᪮   ,   ⢨      ࢨᮬ  樮  ⥬.
設⢮   ⥬   ࠢ        ()    ।⠢
ணࠬ   ⠪   ⥩.      ᫮   ᯥ䨪   몮
㫨஢   묨   ()   ,         ⠢   樨
⢨         .    襭  ⠪  ஡  室
몮 䥩 -  몮    㭨ᠫ 몮, 
஬ ணࠬ  䥪⨢ ॠ ॡ㥬 樨.


                        ᮡ ॠ樨 䥩
                        -----------------------------

      䥩  ᭮ 믮 ᫥騬 ᯮᮡ:
 - ⢨  譨 ᮬ ( ᠬ⥫쭮 );
 - ⢨   ꥪ묨 ﬨ, ࠧࠡ⠭묨  ;
 - ⢨  譥 몠  ஬ .
        ࢮ   砥   ਫ,  ࠧࠡ뢠    ࠬ    (
⥣஢  ।,    饩  ),  뢠 譨 -, 
    ந쭮  ।.  ।  맮  室 ⮢  
ᯮ짮.  -  ࠡ뢠     ନ १
騥  ,    ᯮ  ᭮  ᮬ. ਢ ᯮᮡ
।        ᯮ짮  ⥪⮢  䠩    ࠭  
ᮢ  ଠ⮬.   ⠪ 奬  ⢨ 室 筮
  ६     (᪮  ⨢).     ꥬ
।      ࠢ  ꥬ  ,  ⠢ 
ᮬ 楫 ᮮࠧ ⢨  ⠪  奬.
       ஬ 砥   묨 쬠 ᫮. ꥪ ,
ᠭ    -    몥 ணࠬ஢,     
    ணࠬ,  ᠭ  . ᫨    ,
室  ⢨  ।  筮 ࢮ .  
⢨    ன 奬       . ᫨ 
ନ஢ - ਫ  ᯮ ⠯    
⠭   騪,    ॠ      ⠪  奬  ⢨
.    ⮬  ,   모 ணࠬ஢ ஦ ⠭ 
ꥪ  㫨, ਬ. Turbo Pascal.
     ⫨⥫쭮  ⮩  쥩  奬    ⢨   , 
᭮   ணࠬ              몮  ணࠬ஢ 
  ஬  ,  ।⠢  ணࠬ   ன
⥪         㭪権.   楤 ॠ ।
  㯠      .   ⠪ 奬  ।  
⢥  ࠬ஢  楤  㭪権.  ᮦ,  設⢠   
뤥      㯭  ᥬ  몠  ணࠬ஢   ⥪.  ⠪
  ணࠬ  ࠧࠡ  ᮡ⢥ ⥪ 楤, ॠ
   ॡ㥬  㭪樨    .            ᢥ
⢨,  ..    ⠪  ᫮ ᯥ稢  
⢨  ਫ  ,  ᠭ    㭨ᠫ 몠 ணࠬ஢, 
 ,  ন묨 -ਫﬨ.


                    ⢨ Turbo Pascal  Clipper
                    -------------------------------------

     ᬮਬ   ᯮᮡ   ࣠樨           ,
।⠢    ଠ    ⥬  Clipper,   ணࠬ, ࠧࠡ뢠 
Turbo Pascal.
     ࢠ  奬,    ᮡ⢥  ⪮,  ਮ⠥     
७    堭  ।  ᪮     Turbo Pascal.
-ਫ        Pascal-ਫ-         ॡ      
ᥪ    ⥩,   ⢥ ࠭ 㯭   
ਫ  .
     ᯮ짮 ண 室 ਭ樯쭮 , .. Turbo Pascal
 ᮡ⢥ ଠ ।⠢ ꥪ⭮ .
     ᮮࠧ ਥ஢  ⨩   ⢨. 뢠
 䠪,  Clipper   ⤥쭮 뤥  , ଫ  
⥪    Turbo  Pascal,  室    ஢    ࠧࠡ
ᮡ⢥  ⥪.    ⥪  ࠧࠡ  ⠭ ஬  ᬠ
  饩 .  ⮬ ᫥ ᫥騥 楫:
     -  㤨  ॡ   ᪮ ⥪, 믮饩 㭪樨
  Clipper;
     -  ᬮ    DEFILE  ⢥ ⮢ த, 믮饣
⠪ 㭪樨.


                   㭪樨 ⥪ প  
                   ---------------------------------------

     ᬮਬ,      Clipper  楫ᮮ  ࠧ  ।  ⠢
ணࠬ⠬,  ࠡ騬    Turbo  Pascal.    ⮣  室 業
ॡ Pascal-ਫ  㭪 ⢨     ().
       Turbo  Pascal   ࠧࠡ뢠  樮 ⥬, ᫨
ࠡ⪠  ॡ:
     -ᯮ짮  筮  ᫮  ᫨⥫ 楤,  
室  ᮪ ᪮ ᫮ 権, ᯮ짮 ᫮ 
, ࠢ ᪮   ..;
     -  ஥  ᯥ樠஢ (,  ) 䥩 
짮⥫;
     -ࠧࠡ⪨   ⥬   楤,  ॡ  אַ  ⢨ 
ࢨᮬ 樮 ⥬;
     - ⥣樨 ࠧ 몮 ࠣ⮢  ࠬ Turbo Pascal.
     ᮮࠧ  ⠪  筮  ਫ,  ஦
Clipper.   Clipper-ਫ-         ᥡ   ᮤন        
 , 室  饣 ० 믮 ਫ
.    室        ⪨, ⠪  ⮨⢠.  ⭮,
  騩  ०      ন  쬠 㤮  堭
ய⠭.
      筮  ਫ , ᪫稢  ᬮ७ 
ࠪ⨢       , ॡ騥 樨.  
    Clipper         㤮  . ᮮࠧ
࣠  Call-䥩  ⠪  ࠧ, ⮡    
ᮮ⢥⢮  ।  楤    㭪    ࠬ ᯥ樠쭮
    Turbo  Pascal.    ⢥  ⠪     쭥襬 㤥 
ᬠਢ DBFILE.
       Clipper  ࠧ  ᫥騥 㯯:
     -  ᮧ    ८࣠樨      (create,  modify.  Index oil,
reindex, copy structure);
     -   ⮢          ᯮ짮    ਫ,  
࣠  㠫    ।⠢  (use,  set  index,  set filter, set
relation);
     -   묨  䨪樨    (append (blank), replace,
delete, recall, pack, zap);
     -  㯠    䨧᪮  ᪮ ஢ (go to, go top, go
bottom, skip, fin d).
     楯  ࠡ  ⥩, 筮  ᯮ㥬  ࠬ 
Clipper,   Pascal-ਫ-  㤥  祭 㤮  ᮢᥬ 來.
 ⮬  䨪 䠩-࠭      믮 
ᨬ쭮    ⮣ 䠩 .
        ᬮਬ   ॠ     প      DBFILE.
ணࠬ,  騥  ࠧ  ࠡ ᮡ⢥  த, ᬮ
    ⮨⢠  ⪨ (  窨 ७)   ࠧࠡ⪠ 
Turbo   Pas   cal      ࠧࠡ⪠    㣨  몮  ணࠬ஢.


                         ।⠢   
                         ---------------------------

         ᬠਢ    ⢮   ᪨ 易
 ᮡ 䠩     ᮢ.
         -ଠ, ন ,  Clipper,
  ⥬  dBase,  Foxbase,  FoxPro    㣨.  ᪨  䠩  
      䠩  ⢠ ᥩ, ।⠢  ᨬ쭮
ଠ.      䠩  ᮤন  ।    ᥩ 䠩,
          (ਡ⮢).     ࠬ 䠩
  䨪஢.    । ᨬ   ⨯
᢮ 祭.  ᪠ ᯮ짮    ᫥騬 ⨯:
- ᨬ (Character);
- ᫮ (Numeric);
- ᪨ (Logical);
-  (Date);
- ⥪⮢ (mo).
       ᯮ짮  ⥪⮢       DBF-䠩 ন
  䠩        , ᮤঠ騩 祭 ⥪  
६  .  祭  ⥪⮢     ࠬ DBF-䠩 -  
祭   -䠩.  ࠬ DBT-䠩  ।   512
⮢.  祭  ⥪⮢       ᪮쪮 ᫥⥫쭮
ᯮ .
       ࠬ  Turbo  PascaL   DBF-䠩   ᠭ
᫥騬 ࠧ:

     type
         _FILE_HEADER = record {32}
              Version      : byte; {03h dBase-III
                                    83h dBase-III   DBT-䠩}
              DateUpdate   : record Y,M,D : byte end;
                             { ᫥ 䨪樨}
              NumOfRecords : longint; {᫮ ᥩ  䠩}
              HeaderSize   : word; {ࠧ ᥣ  䠩
                                   ( ᠭ )}
              RecordSize   : longint; {ࠧ }
              Ignored      : array [1..18] of byte;
         end; {_FILE_HEADER}

         _MEMO_HEADER = record {512-  DBT-䠩}
              FreePage     : longint; {ࠧ 䠩}
              Ignored      : array [1..508] of byte;
         end; {_MEMO_HEADER}

         _FIELD_HEADER= record {32}
              FiName       : array [1..10] of char; { }
              FiEnd        : char; {00h}
              FiType       : char; {  C/N/D/L/M}
              FiOfs        : longint; {饭   }
              FiLength     : byte; { 祭 }
              FiDecimals   : byte; { }
              Ignored      : array [1..14] of Byte;
         end; {_FIELD_HEADER}

         _FIELD_LIST       : array [1..256] of _FIELD_HEADER

         _DBF_HEADER  = record
              FileHeader   : _FILE_HEADER;
              MemoHeader   : _MEMO_HEADER;
              Fields       : ^_FIELD_HEADER;
         end; {_DBF_HEADER}

       䠩 ᮤন 32  饩  樨  । ,
稢饥  ᨬ    ODh.  ।    32 .
  ࠧ, ࠧ  䠩 HeaderSlze = 32 + ( ᫮ ) * 32 +
1.  ᮧ 䠩 祭 ⮣  뢠  ᭮ ᫠ 
  䠩.    饣  䠩      ᫮     
⭮      ᭮  . ࠣ 㧪 
DBF-䠩    :

     var
         DBF               : _DBF_HEADER;
         F                 : file;
     begin
         {$I-} Reset (F,1); {$I+}
         if IOResult <> 0 then ...
         {$I-} BlockRead (F, DBF,32); {$I+}
         if IOResult <> 0 then ...
         with DBF, DBF.FileHeader do begin
              GetMem (Fields, HeaderSize-33);
              {$I-} BlockRead (F, Fields^, HeaderSize-33);
              if IOResult <> 0 then ...

       砫      䠩  ন    -  ⮢ 
᪮  㤠    (" "  "*" -  㤠  㤠). ⮬
ᬥ饭  (FiOfs) 祭 ࢮ    ࠢ ,   
(RecordSlze)    㬬    (FiLength). ਬ, 
⮣,  ⮡     ஬ RecNo, 室 믮 ᫥騥
⢨:

     {$I-}
     with DBF, DBF.FileHeader do begin
          Seek (F, HeaderSize+Pred(RecNo)*RecordSize);
          if IOResult <> 0 then ...
          BlockRead (F, RecBuf^, RecordSize);
          if IOResult <> 0 then ...
     end; {with}
     {$I+}

          ஬ No ,   㪠⥫:

        Ptr(Seg(RecBuf^),Ofs(RecBuf^)+FiOfs[No])^

       䠩 ᥣ  ᨬ 1Ah.   ࠧ,  䠩
 ࠢ:

        HeaderSize + RecordSize*NumOfRecords+1.

       ᪠       㠫쭮 㯮冷祭 ᥩ 
 ᯮ  䠩 - ᪮   ᭮ -ॢ쥢.
     Clipper  ন  NTX-ଠ    䠩.    ⮨ 
  ᥩ-㧫 ࠧ ஬ 1024 .
         ᠭ  Turbo Pascal ᫥騬 ࠧ:

     type
          _NTX_HEADER = record {1024}
                _0600       : word; {0600h}
                Stay        : word; {ﭨ  
                         (室  ⥢ ࠡ⪨ ᮢ)}
                RootNode    : longint; {饭 ୥ 㧫}
                FFNode      : longint; {饭 ࢮ 㧫  ᯨ᪥
                         ᢮ ᥩ-㧫 ॢ}
                ItemLength  : word; {  㧫}
                KeyLength   : word; { 祭 }
                _0000       : word; {0000h}
                MaxNumOfKey : word; {max ᫮ 祩  㧫}
                MinNumOfKey : word; {min ᫮ 祩  㧫}
                Expression  : array [0..255] of char;
                         {ࠦ ࠧ , ਬ:
                         'field1+field2+field3+field4+field5'}
                Unique      : boolean;
                         { 㭨쭮 祭   }
                Ignored     : array [1..761] of byte;
          end; {_NTX_HEADER}

         ⮨    ⠡ ᬥ饭 - ⮢  㧫  ᯨ ᪠
ᮡ⢥ ⮢.
      㧫  ⮨   :
     - ᬥ饭  㧫-⮬ (4 );
     -   䠩 , ᮤঠ饩  (4 );
     - 祭  (KeyLength ⮢).

        㧥,   ஬   ,      ᮤঠ     MinNumOfKey  
MaxNumOfKey=2*MlnNumOfKey 祩.
       㧫-⨪  (  騥  ⮬) ᯮ    ஢ 
ॢ.  ,    騩 ⨪  ᮤঠ騩 m 祩,  (m+l) -
⮬.  ⮬    㧫,  ᮤঠ饬  m  祩, ᥣ ⢮ (m+l)
⮢.
       㧫 㯮冷祭  ⠭ 祭. 祭  
  祭    DBF-䠩      ⠪    ଠ  ।  ⠢.
祭  祩    㧫  ॢ  ᥣ  㯮冷祭  ⠪ ࠧ,  
祭      ॢ  ண        ॢ 祭 
.
       㧫  㤮  ।      ᪮ ⨯,  
  楤   㭪権, ᯥ稢  樨  ⠬  ﬨ
⮢ 㧫.
      ᪠ 祭  (  ᮥ⢥饩   䠩 )
 ᯮ짮 ᫥ 奬:

     function FindRecNo (var NTX : _NTX_HEADER;
                         var F : file; Key : string) : longint;
                         {頥   䠩 ,
                         ᮤঠ騩 祭  Key.
         function GetKey - 頥 祭  
         function GetRecNo - 頥   䠩 
         function GetNodeOfs - 頥 ᬥ饭 㧫-⮬}
     type
         NTX_NODE = array [0..511] of word;
     var
         NodeRec : _NTX_NODE; { -㧫}
         NodeOfs : longint;   {饭 -㧫}
         L, R, ItemNo : word;
     begin
         FindRecNo := 0; {祭 Key  }
         NodeOfs   := NTX.RootNode; {    ⢨}
         while NodeOfs > 0 do begin { 㧥- ⨪}
               {$I-} Seek (F, NodeOfs); {$I+ ⠥ 㧥}
               if IOResult = 0 then begin
                  {$I-} BlockRead (F, NodeRec,1024); {$I+}
                  if (IOResult=0) and (NodeRec[0]>0) then begin
                  {ᯮ  , 饬   㧫}
                  L := 1;
                  R := NodeRec[0];
                  repeat
                    ItemNo := (L+R) shr 1;
                    if Key = GetKey (NodeRec, ItemNo) then begin
                       FindRecNo := GetRecNo (NodeRec, ItemNo);
                       exit
                     end else if Key < GetKey (NodeRec, ItemNo) then
                         R := Pred (ItemNo)
                     else L := Succ (ItemNo);
                  until L < R;
                  NodeOfs := GetNodeOfs (NodeRec, ItemNo);
               end else NodeOfs := 0;
                  {$I+}
         end; {while}
     end; {FindRecNo}

Ŀ
   ᬥ饭 ⮢  㧫 ᮤন 祭 ᬥ饭 ⮢   
                                ࠬ 㧫                                 
                                                                            
    +0       dw         ᫮ 祩  㧫 (=n)                            
    +2       dw         饭 祭 ࢮ   㧫 (=i1)     
    +2n      dw         饭 祭 n-   㧫 (=in)        
    +2n+2    dw         饭 祭 (n+1)-   㧫 (=ix)    
    +i1+0    dd         饭 㧫-⮬  1-                 
    +i1+4    dd           䠩   1-             
    +i1+8    db ? dup   祭 1-                                  
    +i2+0    dd         饭 㧫-⮬  2-                 
    ............                                                            
    +in+0    dd         饭 㧫-⮬  n-                 
    +in+4    dd           䠩   n-             
    +in+8    db ? dup   祭 n-                                  
    +ix+0    dd         饭 㧫-⮬ ( ॢ,             
                        ᮤঠ饣 祭 祩                         


       ࠧࠡ⪨  CALL-䥩    祭  ࠢ쭮   
롮   ஢   ।⠢       ,  室    筮  
짮⥫   ࠧࠡ⪥ ਫ. ⠫ ஢ । ⠢  
।  ᤥ  㯭묨  ணࠬ     ਯ஢ 䠩
    ᮢ.     ࠧࠡ뢠 ਫ, 祭 䥪⨢
ࠡ騥    .    ⠪   ॡ  ணࠬ  
⮭⥩    ⢨     ⮫쪮  ஭ Pascal,    ஭
Clipper,  ⮡    ࠧࠡ⪨ ਫ,  ।७ ࠧ
.
       ࠧࠡ⪨    ਫ   ࠬ Turbo Pascal ணࠬ
楫ᮮࠧ  ।⠢  筮 ⠪  樨  ஢ ।⠢ 
,    ࠬ Clipper.


                       ८࣠  
                     ------------------------------------

        ᮧ     ८࣠権  䠩    室  ।
ॡ㥬    䠩    -  । ࠪ⨪ .
 䠩  ।    ᨢ:
     - ᨢ   (array [1 ..] of string [10]);
     - ᨢ ⨯  (array [1 ..] of char);
     - ᨢ   (array [1 ..] of byte);
     - ᨢ ᫠   ஡   ᫮ 
       (array 1 1 . . 1 of byte).

       ᨢ   ஬ ।  ࠬ   .
楤  ᮧ 䠩  (Create)  ⢥ ࠬ஢ । 
䠩 , ᫮   㪠⥫  ᫥ ᨢ.

     var
     MyStructure = record
                 NumOfFi : word;
                 FiName : array [1..MaxFields] of string [10];
                 FiType : array [1..MaxFields] of Char;
                 FiLength : array [1..MaxFields] of Byte;
                 FiDecimals : array [1..MaxFields] of byte;
     end; {MyStructure}

     begin
     ... { 䠩 ।  MyStructure}
     with MyStructure do
     Create ('C:\MYDIR\MYFILE.DBF', NumOfFi,
              @FiName, @FiType, @FiLength, @FiDecimals);
     if dbf_error <> Ok then ...
     Use ('MYFILE',ExlusiveOff);
     ...........

        ᮧ   䠩  뢠    ࠬ    䠩,
ᮧ  DBF-  ,    稨  Memo-  ,  DBF-䠩  ⮩ ன
(⮫쪮 ).
     ࣠ 䠩  ।   㤠 
      ࠬ஢  . 祭   ⮬ ࠭  䠩
    ଠ樨.
       ८࣠  樨 䠩  室  ⥫쭮 ।
ᨢ  室     . ..    䠩   
  祭,  ᫨    室   । . ᫨ 室 
  ।,    祭         ᪮஢  祭
室.  ᫨  饥    䠩      -   
,      㤥  㤠.   ⠢ DBFILE 楤 ८࣠樨
䠩  ᠭ, :

     procedure Modify (DBFPath : string;
                       NF      : word;
                       AFNPtr, ASFNPtr,
                       AFTPtr, ALFPtr, ADPPtr : pointer);

       ᮧ    (CreateIndex)  筮  ।,  
䠩  ᮧ ,  ࠦ ࠧ 祭    
᪠   ࠭ 㭨 祭 .

    ... (* CreateIndex *)
    Use('MYFILE',ExlusiveOff);
    if dbf_error <> Ok then ...
    CreateIndex('MYFILE','MYINDEX','NAME+BIRTHDAY',UniqueOn);
    if dbf_error <> Ok then ...

     ந  騩           楤 Relndex,
㪠  䠩    ࠨ .
     楤  ஢     筮 让 ᪮.
⮤  ᪮⭮    ஢  ᯥ     ॠ ⠢
   ஡.  ஢  믮    ᯮ    筮
讣   ⨢   ( 㬮砭  DBFILE - 64).
       ࢮ  ⠯    ६  䠩 ⠫  㯮冷祭 
祭  祩   뫪  ᮮ⢥騥  䠩 . 
⠪   ६ 䠩 믮   ᬮ 䠩  .  ⮬
 㧪 ᥩ 䠩  ᯮ   ᠬ .
        ஬      믮  ᫨ﭨ        䠩 
㯮冷祭묨  祭ﬨ .  믮 ᫨ﭨ ।  祭
  ⠫      㧫  饣 -ॢ.    ( ⮬ 
)  ࠭  㧫    饩    ⢨  ॢ .  
। 㧫 砬  ⠫  䠩 ᪮ .
     ਬ,  믮 ஢  । Foxbase ꥬ 権 
⠯ ⮡ࠦ  ᯫ,  ' key generated'  ' key Indexed'.


   ⮢    ࠡ  ࠧ 㠫 ।⠢
   -----------------------------------------------------------------------

       ⮢        ᯮ짮     ஬ ਫ
室  ॡ㥬 䠩    .
       Clipper:

     use <file> [indexes <index-list>][exclusive]

       ࠬ  DBFILE  ࠧ    楤 -  䠩  (Use),
      䠩    (UseIndex)   ⠭   
ᮢ  ⢥  (SetIndex):

     (* Use *)
     ...
     Use('C:\MYDIR\MYFILE.DBF',ExclusiveOff);
     if dbf_error <> Ok then ...
     UseIndex('MYFILE','MYINDEX1');
     if dbf_error <> Ok then ...
     UseIndex('MYFILE','MYINDEX2');
     if dbf_error <> Ok then ...
     SetIndex('MYFILE','MYINDEX1',false,false);

     Be    ⮬᪨    ᥩ
  䠩      .   ᯥ稢  ᥩ 
    ।  ᪨  冷  ᫥ ᥩ  䠩  
ᮮ⢥⢨  㯮冷祭 祭   .
       㠫  ।⠢   ᮢ㯭 ।
ࠧ  易    ᮡ  䠩  .     䠩 
⠭  䨫      .  䠩  裡   ᭮
ᮢ.
      ⠭ 䨫  ,  㤮⢮騥 ᫮ 䨫,
᪫  ᬮ७.   CLIPPER ᫮ 䨫 . 
ࠬ  TURBO  PASCAL    ⢥  䨫    ᯮ짮  㭪 ⨯
boolean,    祭  true  ⮬ 砥, ᫨  㤮⢮
䨫.  㧪 ।  䠩  ⮬᪨ 訢
䨫-㭪. ,  㤮⢮ 䨫-㭪樨, ய᪠.
     -㭪    :

     {$F+}
     function MyFilter : boolean;
     var
         BirthDay : string[8]; {date}
     begin
         GetField ('MYFILE','BIRTHDAY',BirthDay);
         { 祭  BIRTHDAY ⥪饩 }
         if BirthDay = '21.06.63' then MyFilter := true
         else MyFilter := false;
     end; {MyFilter}

     ⠭ 䨫  䠩 MYFILE 筮 :

     (* SetFilter *)
     ...
     Use('C:\MYDIR\MYFILE.DBF',ExclusiveOff);
     if dbf_error <> Ok then ...
     SetFilter('MYFILE',@@MyFilter,false);
     ...

       쭥襬    饭    䠩    㯭  ⮫쪮 
,    BIRTHDAY = '21.06.63'.
      DBFILE ॠ 筮 ⠪  堭 প 䠩 痢,
      CLIPPER.    뢠    㪠  祢  ࠦ
室  䠩      ᨬ  䠩.   ⮬ ।, 
 ࠦ  ࠦ  ᮢ  .

     (*  SetRelation  *)
     Use('C:\MYDIR\MYFILE1.DBF',ExclusiveOff):
     if dbf_error <> OK then ...
     Use ('C:\MYDIR\MYFILE2.DBF',ExclusiveOff);
     if dbf_error <> OK then ...
     ...
     SetRelation('MYFILE2','NAME+BIRTHDAY','MYFILE1','MYINDEX1',false);
     ...

      쭥襬  ६饭   䠩 MYFILE2 ⮬᪨ 㤥
᪨  ᮥ  塞   䠩 MYFILE1 .  ⮣  祭
⥪饩    MYFILE2    ᭮ ࠦ NAME+BIRTHDAY 㤥 ନ஢
   ᮥ塞      䠩  MYFILE1,    㤥    
ᯮ짮  MYINDEXI ( 䠩 MYFILE 1 ).


                                 
                               ---------------

           ⮣  䠩  ন  㪠⥫ ⥪饩
,  祭  ண      㦥  䠩 
 .  ⥪饩  䠩  㯭  ਫ .
     ⢨    䠩      ਫ  믮  १
 ⥪饩 ,    뤥 ⮬᪨  ⨨
䠩 .
         ଠ樥    ६묨  PASCAL-ਫ   ﬨ
⥪饩    䠩     DBFILE ।  楤 GetField (
  ६)  PutField ( ६  ).  ⮬ ⨯ ६
 ஫஢ ணࠬ⮬  㤮⢮ ᫥騬 ᮣ襭:

  Ŀ
                     ஡          ६ 
  Ĵ
   Character       1                 -                    char           
   Character       2..255            -                    string[2..255] 
   Numeric         1..9              0                    longint        
   Numeric         9..13             0                    real           
   Numeric         1..13             1..11                real           
   Date            -                 -                    string[8]      
   Logica          -                 -                    boolean        
   Memo            -                 -                    pointer        
  

           䠩   ᢮  ६饭 㪠⥫ ⥪饩
.
     ᪨  ⢫   :

        var                                         (*Go*)
           Birthday  :  string[8];
           Go('MYFILE',15); {    ஬ 15 }

           if dbf_error <> OK  then  ...
           GetField('MYFILE','BIRTHDAY',Birthday);
           Write('#15',Birthday);
           .....

     ᪨    믮    祭      浪 
⠭/뢠  祭          楤 (Find,
GoTop, GoBottom, Skip).
           室 ।  祭  祢 
 .

                                                    (*Find*)
           ...
           SetIndex ('MYFILE','MYINDEX',false,false);
           ...
           ReadLn(Name);
           PutField ('MYFILE','NAME',Name);
           Find ('MYFILE');

           if dbf_error <> Ok then ...
           GetField ('MYFILE','BIRTHDAY',BirthDay);
           GetField ('MYFILE','PHONE',Phone);
           Write (Name,':',BirthDay,' ',Phone);
           ...

     ᫥⥫ ᬮ ᥩ 䠩  믮 筮 
Clipper.

                                                (*GoTop/Skip*)
           GoTop('MYFILE'):
           while dbf_error  =  OK  do  begin
                 GetField('MYFILE','NAME',Name);
                 GetField('MYFILE','PHONE',Phone);
                 Writel(Name,'  ',Phone);
                 Skip('MYFILE',1):
           end; {while}

       ᫥⥫쭮  ᪮  㯥      䠩   
, 祭  㤠,   㤮⢮騥 䨫, ய᪠.
     ᫨  䠩  易    ᮡ      SetRelallon,  楤
GetFleld  ᬮ७ ਬ  ਬ    易 䠩.


                              䨪 
                              ------------------

               䠩   室 ।  
   PutField    楤  Append.

                                                        (* Append*)
             Readt(Name);
             PutField('MYFILE','NAME',Name);
             Readln(Phone);
             PutField('MYFILE','PHONE',Phone);
             ....
             Append('MYFILE');
             if dbf_error <> OK then ...
             
           ⥪饩  䠩  ᯮ ⠪ 
奬  楤 Replace.
         ⠭  ⥪     楤 Delete,
Recall.  ᪮  㤠    祭  㤠 ᥩ 믮
楤ன k.
       䨪樨  ᥩ  䠩   ᪨  
   䠩.


                            ⥢ ⢨
                            ----------------------


     न  ࠡ          ஭  ᪮쪨 ਫ
ᯥ稢  堭  ஢.  ஢ 믮  ⢠ 
⥢  ࢨ  MS  DOS  (㭪 5Ch 뢠 21h). 設⢮ । 
⥢  ணࠬ  ᯥ祭  ন  䥩  室 
 ⮬ CLIPPER ࠡᯮᮡ ࠪ᪨    ⥩.
     堭  ஢   ন   㭪権 FLock (஢
䠩),  Rlock  (஢ ⥪  ),  true  㤠筮 
. ஢ 䠩      楤ன Unlock.
       ࠬ MS DOS ᯮ ᮫⭠ ஢ (   ⥭).
  쬠  㤮.    CLIPPER  ஢  믮  ⮫쪮   
(),    ⥭  ஢  /䠩  믮 ᢮.
믮    筮  ਣ쭮.  ஢   ஬ N
஢  MS  DOS    䠩  ᬥ饭 1 ,000,000,000 + N.
  䠩      ﬨ, ᯮ묨  䠩  1,000,000,000 
뢠  㯭  ⥭.  㣮 Clipper-ਫ ஢
    ஬ N ( ᯮ짮 ⠪  室) .
       ।⠢  ⠪      ஡    ᯮ짮 
㠫쭮       ᮢ.      ਫ    ᢮  
ন    ࠭ ᥩ 㧫 - . ᯮ짮 ⠪ 
      ⮬ 砥,  ﭨ    ᮮ⢥ 
ﭨ      䠩  .    ᯮ    ⠪  樨 
     ࠭    ﭨ  Stay.      
-    ਫ    ﭨ    稢   . ⮣
뢠  筮       ᯮ짮 㠫쭮
     ਫ.
     ਫ,  ᠭ    ᯮ짮  DBFILE,   Clipper-ਫ
   ⨬  ᯮ짮    .
     楯  ⥢  ⢨,  ॠ    Clipper, 
⪮,    易    ⥬,  ࠢ ஢  
ॠ       ਫ ਪ묨  ࠬ⠬.  ࠢ
஢  ,  筮  殮  樨, ⭮  
"㯨".

          FLock('FILE1')               FLock('FILE2')  믮
                                                         ਫ 1

        
         FLock('FILE2')               FLock('FILE1')  믮
                                                        ਫ 2
        
        
        
          ࠫ쭮 믮 ਫ
        
        
        
         ᯥ稢 " ᠭ"  ਫ  ᪮筮
  ப.  ਫ  1 ᬮ ஢ FILE2 ⮫쪮 ᫥ ⮣, 
ਫ  2  ᢮    䠩.    ⮣       ⮬, 
ਫ 2 室   筮 .
          ⠪    権  ४      㯯
஢      䠩, ॡ   믮 ன 饩
  樨.  㯯  ஢ 蠥 㤠筮,    䠩 㤠
஢.  ᫨          䠩  㤠  , 
室    ࠧ஢    㤠筮   ஢   १ 
ਮ ६  ୮ 믮   㯯 ஢.


              ⢥⢨   Clipper  楤 DBFILE
              -------------------------------------------------

     ࠪ᪨        Clipper   ॠ ।⢠
DBFILE.    ਢ  ⠡,  뢠,    ᭮  楤 
㭪権  DBFILE    ⨣   १⮢,    ᯮ짮
   Clipper.

             Ŀ
                CLIPPER                 DBFILE                 
             Ĵ
                AFIELD()                FIELDINFO+FIELDSINFO   
                APPEND BLANK            CLEARFIELDS+APPEND     
                APPEND FROM             APPENDFROM             
                CANCEL                  QUIT                   
                CLOSE INDEXES           UNUSEINDEXES           
                COPY STRUCTURE TO       COPYSTRUCTURE          
                COPY TO                 COPYTO                 
                CREATE                  CREATE                 
                DELETE                  DELETE                 
                DELETED()               DELETED()              
                EOF()                   EOF()                  
                FCOUNT()                FILEINFO               
                FIELD/FIELDNAME()       FIELDSINFO             
                FIND                    FIND                   
                FLOCK                   FLOCK                  
                FOUND()                 NOT EOF()              
                GO/GOTO                 GO                     
                GOBOTTOM                GOBOTTOM               
                GOTOP                   GOTOP                  
                INDEX ON                CREATEINDEX            
                INDEXKEY()              INDEXINFO              
                PACK                    PACK                   
                QUIT                    QUIT                   
                RECALL                  RECALL                 
                RECNO()                 RECNO()                
                REINDEX                 REINDEX                
                REPLACE                 REPLACE                
                RLOCK()/LOCK()          RLOCK()                
                SET FILTER TO           SETFILTER              
                SET INDEX TO            USEINDEX+SETINDEX      
                SET ORDER TO            SETINDEX               
                SET RELATION TO         SETRELATION            
                SET UNIQUE ON/OFF       SETINDEX               
                SKIP                    SKIP                   
                UNLOCK                  UNLOCK                 
                USE                     USE+USEINDEX UNUSE     
                ZAP                     ZAP                    
             


                             ࠢ ࠧ
                             --------------------

       DBFILE      ᨩ  Turbo  Pascal (Turbo Pascal 7.0 
Borland     Pascal     7.0)     楫ᮮࠧ     ନ         
ꥪ⭮-ਥ஢ 室    ᪨ 砥 ⥪
(DLL, Dinamic Link Library).
       ⮫쪮  䥪⨢ ᯮ짮   DOS-ਫ 
Windows-ਫ,      ᯥ    ᯮ짮  DBFILE  
㣨 몮 ணࠬ஢, ਬ  C++.
     室  ⠪  ᯥ  প  ଠ⮢  䠩,
ᯮ㥬  Clipper ᨨ 5.0  .
