A Paradox Table Survival Guide for C++Builder and Delphi Developers

Introduction	4
Key Points	4
What are Paradox Tables?	4
Paradox is Not Client/Server.	4
Paradox Is Fast.	4
Why use Paradox Tables	4
When speed is important.	4
For local data storage	4
As Front End storage for Client Server applications	4
For Workgroup application	4
It’s low Cost	5
It’s easy	5
Great for Prototyping	5
Why to not use Paradox tables	5
Paradox is not Client/Server	5
Multi-user Paradox Applications can get slow	5
Paradox Tables corrupt easily!	5
Some History	5
Where Paradox Tables come from	5
The Database Desktop	5
Table Levels	6
The Paradox Engine	6
Table Structure and Field Types	6
Paradox Field Types	7
The BLOb Fields	9
Naming rule for Paradox Fields	9
Paradox File Extensions	10
Paradox Table Internals	10
Locking Protocols	11
Directory Locks	11
Working/Shareable Directories	11
Private/Exclusive Directories	11
Table Locks	11
Concurrency	12
Network Control File	12
Configuring 16 bit Database Engine / IDAPI.CFG	12
Configuring 32 bit Database Engine / IDAPI32.CFG	12
Finally, How the Paradox Table is Accessed	13
The VCL access	13
Paradox on the network	13
The NET file revisited	13
Peer-To-Networks vs dedicated File Servers	13
Setup for 32Bit Only Applications	14
Setup for 16Bit and 32Bit BDE Applications	15
Paradox Tables on a Network Summary	15
How tables get damaged	16
Improper Application Exit, Badly written programs, and Power Supply Problems,	16
Improper Setup	16
Disk Errors and RAM Problems	16
Network Problems	16
When Client is Win95 OSR2 and Tables are on an NT Server	17
Also on Windows 95 with Tables on NT.	17
Windows 95 & 98 running Novell software	17
Opportunistic locking (Windows NT Only)	17
Tables with a large number of Indexes and Referential Integrity	17
Green Devices	18
Write-Behind Caching	18
And a bit more esoteric …	18
Unverified Voodoo	18
How to Minimize Table Damage	18
BACKUP YOUR TABLES REGULARLY	18
Train your users	19
Configure your Environment Correctly	19
Check your Hardware	19
Flush your Buffers	19
Post un-posted records onClose	19
Don’t Use the DOS SUBST command or the Root Dir	19
Win3.1 Applications	19
Common Error Messages and Causes	20
"Multiple Paradox net file found"	20
"Index out of Date"	20
"Blob has been modified"	20
"Lock file has grown too large"	20
“Unknown Internal Operating System”	20
“Sharing Violation”	21
“Duplicate value in unique key”	22
Fixing Corrupt Tables	22
Two Goals	22
Repair steps	22
Broken Auto Increment field	24
Miscellaneous FAQ	24
I have a paradox table that uses a password.  How do I make it so that the form that uses the table comes up without prompting the user for the password?	24
I have referential integrity set on my Paradox how do I do a cascading delete of my child records?	24
I am attempting to add data to my Paradox table but I'm getting the Error "Table is Full". What is the cause of this and how can I add more records?	26
How can I check the LOCAL SHARE setting from my code?	26
How do I pack a Paradox Table?	27
Accessing the PDOXUSRS.NET file on Novell drive takes 7-10 seconds with Windows 95 Client for Novell. Occurs with any BDE client.	27
I need to distribute my Paradox tables on a CD-ROM, how do I do that?	28
References	29
Borland Technical Articles www.borland.com	29
Corel www.corel.com	29
Other	29
Introduction
Professional and Enterprise versions of C++Builder and Delphi come with the ability to create, modify and manipulate Paradox, Xbase (DBase) and ASCII database tables. The purpose of this paper is to discuss Paradox tables and provide the information necessary to create robust applications using this table format.
The information here goes into as much detail as possible. The goal is to provide the reader with all the information needed to understand why things are the way they are with Paradox tables. In some cases its more information than you probably want or need. What’s written here is the result of a number of years of personal experience with Paradox tables, the experiences and observations of customers of our Paradox Table Repair Component Set (see www.o2a.com/tu.htm), and various articles from magazines, the Borland and Corel websites. At the end of this paper you will find an extensive bibliography of the sources.
Key Points
Here are some key points to keep in mind.
What are Paradox Tables?
Paradox tables offer a fast, easy to use relational database with native support in BDE. Applications that use Paradox tables can run either standalone on a single system or on a network as a multi-user application.
Paradox is Not Client/Server.
Paradox (like DBase) is not a client server database system. This means, there is no separation of the server application from the client application. It is all one. That is to say, an application that uses Paradox tables is both client and server at one time. Believe it or not, in the olden days, this was the norm. Do not take this to mean that Paradox will not run over it network, in fact, Paradox table applications work fine over a network as long as some rules (discussed later) are followed.
Paradox Is Fast.
Because the Paradox scheme is not client/server record access and manipulation is extremely fast. In cases where the application and the tables are on the same system performance is generally orders of magnitude faster than the client/server case. This can even be the case when the application is accessing tables over a network but here other factors come into play, like network traffic, database size, the number of people sharing the tables, and table hit frequency..
In fact, because of Paradox’s extremely rapid access it’s used internally by the VCL to store and manage all cached updates.
Why use Paradox Tables
When speed is important. 
Paradox is a good bet for real time data collection and retrieval.
For local data storage
Paradox is ideal for applications that only require local data storage and where the cost or overhead of Client/Server is unnecessary.
As Front End storage for Client Server applications
Paradox tables can provide much the same functionality as TClientData sets but with more flexibility.
For Workgroup applications
Paradox tables provide a good platform workgroup (peer to peer) applications where the number of concurrent users is expected to be few (less than 12). Tables can be stored on any machine in the workgroup and shared by all. The data can then be periodically synchronized with a master Client/Server database.
It’s low Cost
Lets face it. It comes as part of the Professional and Enterprise versions so there’s nothing else to buy. 
It’s easy
Paradox tables have none of the configuration issues associated with client/server databases. You can start designing and using table in the Database Desktop immediately after installing Delphi of C++Builder. 
Great for Prototyping
Also, since Paradox supports many client/server features like SQL (limited), and transactions its ideal for prototyping client/server applications. The programmer can just go without worrying about server side configuration issues.
Why to not use Paradox tables
As expected, many of the reasons for using Paradox tables are same reason for not using them.
Paradox is not Client/Server
Client/Server architecture has been adopted by the IS industry for good reasons mostly involving data integrity, control and security much of this is sacrificed for the speed and simplicity of the Paradox table format.
Multi-user Paradox Applications can get slow
Depending on the application, Paradox table access response times degrade very quickly somewhere between 8 and 14 users.
Paradox Tables corrupt easily!
Yes its true, in fact, this aspect of Paradox tables is the focus of much of this paper. Read on.
Some History
This section is especially important if you have legacy Paradox Applications.
Where Paradox Tables come from
Before going on, a little should be said on where the Paradox table comes from. 
Paradox tables come from the Paradox Database Application originally developed by Ansa Software way back in 1985. It was then purchased by Borland International (now Inprise) in 1987 and then in 1996 was licensed to Corel Corporation who owns exclusive marketing and distribution rights (rights to the Paradox Application but not the table format).
The Paradox Database Application is currently sold by Corel as part of their Corel Office Suite and as a stand-alone product. For more information about Corel’s.Paradox Database Application visit www.corel.com.
The Database Desktop
The Database Desktop is essentially a severely stripped down version of the Paradox Application circa version 7.0. When working with Paradox files it is an extremely useful tool and you should become familiar with it. 
Table Levels
The default table type created using the Database Desktop and the BDE (Borland Database Engine) is a Paradox 4.0 although the default can be changed using the BDE administrator to Paradox table level 3, 4, 5 or 7. (On the configuration tab navigate to Drivers | Native | PARADOX and change the LEVEL field).
The table level is important because each major release of Paradox implemented improvements to table structures. That is, table level determines the features you have available Here’s what you need to know on this;
•	All Paradox table levels from 1.0 through 3.5 are compatible with each other.
•	Level 4.0 added the new Binary Large Object, (BLObs) data type as well as new types of Secondary Indices.  Level 4.0 supports two types of BLOb fields (Memo and Binary).  Attempts to read, write or manipulate level 4 or greater tables with applications that only read lower level tables will return an error that the table is password protected.
•	Paradox 5.0 added several new data types including; Long Integer, Time, TimeStamp, Logical, Autoincrement, BCD, and Bytes.  
•	Paradox 7.0 added a descending secondary index  
Any table created or modified to include any of these newer features will be automatically advanced by the BDE to the appropriate table level. 
The BDE can read, write, and create Paradox table levels that are compatible with levels 1.0 through Paradox 7.0. So, for example, the BDE (or Database Desktop) can read and write a level 1.0 Paradox table but if the Database desktop is used to Restructure the table so one of the indexes is descending then the table structure is automatically updated to Level 7 and the table will no longer be accessible by level one only applications.
Note that the BDE will not change the table level when only reading or writing data.  The table level is only changed when a Restructure is performed on the table.
The Paradox Engine
Prior to IDAPI and the Borland Database Engine (BDE) the only way for C++ and Turbo Pascal programmers to directly access Paradox Tables was through the Paradox Engine. The Paradox Engine is the collective name of a tool kit containing some DLLs and an API that let C++ and Pascal use Paradox Tables. This tool kit was also sometimes known in the biz as the “Database framework” because along with Turbo Vision  it was one of the few really good OOP libraries around. 
The Paradox Engine product lived through version 3 which matched up with Paradox level 4 and was then replaced with IDAPI and the BDE.
Beware (TI-239B)
Old applications that use the Paradox Engine may have problems on systems greater than 486 CPUs. TI239B gives this warning;  
The Paradox Engine has NOT been certified on the following chipsets:
1.	Intel Pentium (any speed)
2.	Cyrex
3.	AMD

The Paradox engine relies on timing for some operations.  The speed of some CPUs can cause file lock contentions in multi-user environments.
You’ve been warned. 
Actually, it’s really to bad, since the Paradox Engine could have been a really nice lite replacement to the BDE for those just wanting Paradox functionality.
Table Structure and Field Types
This section covers the field types available in Paradox tables. Use the Database Desktop Tools | Utilities | Restructure to explore the structure of existing Paradox tables and to create and modify existing tables.
Paradox Field Types
Paradox tables are like any traditional relational database tables in that they have records (rows) and these records have fields (columns). Like other database platforms Paradox has field types that are unique to Paradox. These map into Delphi and C++ data types as expected based on the field size and description. The valid Paradox field types follow.
Alpha Fields
Alpha Fields are up to 255 characters long and consist of letters,  numbers,  special symbols like %, &, #, or = and other printable ASCII characters. These show up in the DB Desktop as symbol A. And map to the TStringField type in the VCL.
Number Fields
Only numbers. Number fields can hold positive or negative values. The range of values possible for a number field is from -10307 to 10308 with 15 significant digits. Use number fields when you plan to perform calculations on the values in the fields. Number fields are best used when you want to perform calculations on the values in the field. It is a good idea to use an alpha field rather than a number field for phone numbers or zip codes. In an alpha field, you can include parentheses and hyphens. This is the N field type in the DB Desktop and maps to the TFloatField in the VCL.
Money Fields
These are only numbers with positive or negative values. But by default, money fields are formatted to display decimal places and a money symbol. Regardless of the number of decimal places displayed, the BDE recognizes up to six decimal places when performing internal calculations on money fields. This is the $ symbol in the DB Desktop and maps to the TCurrencyField in the VCL.
Short Fields
These are whole numbers in the range -32,767 to 32,767. Short fields require less disk storage than ordinary number fields. The S symbol in the DB Desktop and TSmallIntField in the VCL.
LongInteger Fields
A 32-bit signed integer that contain whole numbers (nonfractional) with complete accuracy in the range -2147483648 to 2147483647 (plus or minus 2 to the 31st). Long integer fields require more space to store than short fields. This is symbol I in the DB Desktop and maps into the TIntegerField type in the VCL.
BCD Fields
This is numeric data in a BCD (Binary Coded Decimal) format. Use BCD fields when you want to perform calculations with a higher level of precision than that available with the use of other numeric fields. The BDE uses the Currency type to work with data from BCD fields, and limits the precision of the BCD values it can support to 4 decimal places and 20 significant digits. Calculations on BCD fields are not performed as quickly as those on other numeric fields. The BCD field type is provided primarily for compatibility with other database types that use BCD data. The BCD encoding scheme will talk use 0 to 32 bytes of data depending on the number of digits. This is the # symbol in the DB Desktop and maps to the TBCDField type in the VCL.
Date Fields
Any valid date from January 1, 9999 BC to December 31, 9999 AD. The BDE correctly handles leap years and leap centuries and checks all dates for validity. The BDE treats all BC years as leap years. The D symbol in the DB Desktop and TDateField in the VCL.
Time Fields
Times of day, stored in milliseconds since midnight, and are limited to 24 hours. This is the T symbol in the DB Desktop and maps to the TTimeField type in the VCL.
TimeStampFields
Contains both the time and date values. Rules for this field type are the same as those for date fields and time fields. Internally the data is stored as a Double with the date encoded in the data to the left for the decimal and the time encoded in the data to the right of the decimal. The @ symbol in the DB Desktop and the TDateTmeField in the VCL.
Memo Fields 
Use memo fields for text strings that are too long to store in an alpha field. Memo fields can be virtually any length. Memo fields are BLObs and you should read the section on BLObs that follows. Memo fields can contain letters, numbers, special symbols (such as %, &, #, and =), or any other printable ASCII character (except null). You can enter line breaks, tabs and other print control characters in memo fields. Memo fields use the symbol M in the DB Desktop and are the Type TMemoField in the VCL.
Formatted Memo Fields
Paradox formatted memo fields are also BLOb fields (see below) and are like memo fields except the text can be formatted. Paradox recognizes text attributes (typeface, style, color and size) and stores them with the text. To define a field as a formatted memo field, use the Create Paradox Table dialog box or the Restructure Paradox Table dialog box in DB Desktop. FormattedMemo fields can cause problems with the Table Repair functionality in the TUTIL32.DLL see the information in the BLOb section below for details. This is field type symbol F in the DB Desktop and maps to the TMemoField
Graphic Fields
Paradox graphic fields contain pictures. Graphic fields are BLOb fields (see below). Its possible to specify a field size for Graphic fields but do not. The size should be 0 so the graphic data is not stored in the table, but in the separate MB file. 
Symbol G in the DB Desktop and TGraphicField in the VCL. 
OLE Fields
The OLE field type is used to store different kinds of data, such as images, sound, documents, and so on in the Paradox application. This is also a BLOb type field. It has no equivalent field type in the VCL and the Database Desktop does not support OLE data. This is the O field type in the DB Desktop and is not supported in the VCL.
Logical Fields
Paradox logical fields contain values representing true or false (yes or no). By default, valid entries include "True" and "False" (case is not important).
Symbol L in the DB Desktop and TBooleanField field type in the VCL.
Autoincrement Fields
Paradox autoincrement fields contain long integer, read-only (non-editable) values. The BDE begins with the number 1 and adds one number for each record in the table. Deleting a record does not change the field values of other records.
When creating a Paradox table in DB Desktop, you can specify the starting number of an autoincrement field by specifying a minimum value for it. 
Be sure to read the notes on the Autoincrement field type under the section on repairing Paradox tables. This is symbol + in the DB Desktop and TAutoIncField in the VCL.
Binary Fields
These are yet another type of BLOb field (see below). Only advanced users who need to work with custom data that the BDE cannot directly interpret should use binary fields. The BDE cannot display or interpret binary fields directly. A common use of a binary field is to store sound information.
Do not specify a size when creating a Binary field since they are stored in a separate file (the .MB file), not in the table (.DB file). This is symbol B in the DB Desktop. The advanced user using this field type would create a TBlobField descendent and extend the VCL for her specific needs.
Bytes Fields
Bytes fields should be used only by advanced users who need to work with data that Database Desktop cannot interpret. A common use of a bytes field is to store bar codes or magnetic strips.Unlike binary fields, bytes fields are stored in the Paradox table (rather than in the .MB file), allowing for faster access. The size of this field must be specified when the table is created and is limited to 255 bytes. This is symbol Y in the DB Desktop. This maps to the TBytesField in the VCL. It’s up to the programmer to make sense of this unformatted data. 

The BLOb Fields
The Memo, Formatted Memo, Binary, Graphic, and OLE fields are all considered to be what’s called Binary Large Objects (or BLObs). BLOb fields a stored outside the primary table file (.DB) in the .MB file. With these fields it is possible to store a copy of a part of the data in the DB file. This can provide faster access if the BLOb data is small and is a good idea for the Memo field type. The size value you assign in the Database Desktop refers to the amount of the memo Database Desktop stores in the table’s main DB file. This can be from 1 to 240 characters. Database Desktop stores the whole memo outside the table (in the .MB file). So, for example, if you define the size in DB Desktop as 45 then the first 45 characters of the memo will be stored in the DB file while the MB file will still contain the whole memo. Database Desktop retrieves the data from the .MB file as you scroll through the records of the table. The amount of data a memo field contains is limited only by the disk space available on your system (well actually, it does have a theoretical maximum limit is 2GB).
For the field types other than the Memo type it is not considered a good idea to store any of the data (size > 0) in the DB file. The reason is that if the table is checked for corruption using the Table Repair API’s (TUTIL32.DLL) TUVerifyTable method it will generally falsely report that the table is corrupt because it will likely find non-printable ascii data in the field.  More on the Table Repair API comes later in this paper.

Naming rule for Paradox Fields
Follow these rules when specifying field names for Paradox tables:
•	The maximum length of a field name is 25 characters.
•	A field name cannot start with a blank space (unless it is enclosed in quotation marks), but it can contain blank spaces.
•	Each field name in a table must be unique. (You cannot have two identical field names.) You cannot make a name unique by adding a blank space at the end of the name or by 
	changing the capitalization of the name.
•	A field name should not contain certain characters if you plan to use the table in a query, because these characters have special significance. These characters are the comma (,), the pipes (|), and the exclamation point (!). Avoid using SQL keywords, such as SELECT and COUNT.

Paradox File Extensions
The following lists the various file extensions of files typically found in a Paradox Table directory.
.DB 	Paradox table. This contains all of the tables data except for what is in the MB file.	
.FAM 	Database Desktop’s listing of related files (like a table's .TV file). (not used by the BDE).	
.LCK	Lock file	
.MB 	BLOb file. This is were a BLOb data is kept for Memo, Formatted Memo, Graphic, OLE and Binary field types.	
.PX 	The Primary index	
.TV 	Table view settings (not used by BDE)	
.VAL 	Validity checks and referential integrity.	
.Xnn 	Secondary single-field index, numbered.	
.Ynn 	Secondary single-field index, numbered.	
.XGn 	Composite secondary index, numbered.	
.YGn 	Composite secondary index, numbered.	

Paradox Table Internals
Most of the following information is quite unofficial. As a matter of policy, Borland does not discuss Paradox internals. All information about internal structures is based on our experience and experimentation and from articles written by 3rd parties. This information really isn’t very useful for practical purposes. 
DB File Structure
The DB file is the central file of a Paradox table. It contains most of the data (except BLOb data which is in the MB file) as well as critical header information. 
DB File Header Block
The header block is the first block in a DB file and contains information about the table like block size, the first and last block, the number of records, the next autoincrement value etc. Here’s what we’ve discovered (or have been told) about the header block.
Byte Offset	Use	
0-1h	Record buffer size	
2-3h	Block Size	
4h	We believe this is Table type (00 for paradox)	
6-7h	Number of records	
21h	Number of fields in the table	
49-50h	Next AutoIncrement Value	
We don’t recommend directly manipulating any of these values. They are here if illustration purposes only. 
Improper exits and hardware errors can cause the header to get trashed when written (or fail to be written) to disk.
DB File Data Blocks
The blocks following the header contain the table data. Paradox tables are aligned on kilobyte boundries (so a table with a 2048 block size has its first datablock starts at 800h). A table with one record contains at least two blocks (one for the header and one for the data) and will by 4 k long (if 2048 block size).
Data can be garbled for many reasons. Even if the BDE doesn’t understand the data, it will try to display  whatever it finds, displaying garbage or “hanging”.
Each data block reserves the first 4 bytes as the data block header. The first two bytes point to the next data block and the second two bytes point to the previous data block. If any of these bytes are corrupted you will have block link damage resulting in any one of 4 possible situations. 
Bulge – A block is inserted in only one strand of the chain. There are two variations, a bulge can go forwards or backwards.
Cycle – A block points to itself or a block earlier in the chain.
Dead end – The chain suddenly ends, leaving the following block stranded.
Invalid end – A block points completely out of the file having the same effect as Dead end. 
To correctly insert or delete a block, the BDE has to change links in three blocks. Any interruption in this link update process will corrupt the table. This kind of corruption is among the most frequent due to improper exits, or hardware failures (see How Tables Get Damaged below).
Index Files (PX, Xnn, Ynn, XGn and YGn)
Just like a DB file the PX, Xnn, Ynn, XGn and Ygn index files have a header block and data blocks. If the header is corrupt the BDE complains about invalid sort order or other index-related problems. Just like with DB files index file blocks can become garbled resulting in an error, garbage in returned records or a freeze. 
Like DB files index file blocks are connected by pretty much the same double-link scheme using the first four bytes of each block and can suffer the same link problems. In addition indexes can get “out of date” with the data file, like if the DB file is written to disk but the computer is turned off before all of the index files are updated. 
Locking Protocols
Historically there have been two different Paradox locking protocols: the protocol introduced with Paradox 2.0 and the protocol introduced with Paradox 4.0.  These two protocols are not compatible. The locking protocol has no bearing on which type of table a program can work with. That is, the locking protocol is not tied to the table structure in any way. So, we will only focus on the 4.0 locking protocol since it’s the one the BDE uses.
This section and the following section Paradox on the Netwrok contain purposeful repetition in the hope of making the concepts clearer.
Directory Locks
The BDE places a locking file, PDOXUSRS.LCK, in each directory where tables are accessed.  This locking file regulates concurrent access to files in the directory.  The lock file references PDOXUSRS.NET, so every user must map to the data directory the same way.  It also places an exclusive PARADOX.LCK file in the directory as well.  It does this to prevent versions of Paradox or the Paradox Engine using the older locking system from inadvertently accessing tables.
Working/Shareable Directories
When the BDE needs to access Paradox tables in a directory, it places both a "Shareable" PDOXUSRS.LCK file and an "Exclusive" PARADOX.LCK file in that directory. This designation means that other BDE users can access tables in that directory.  The exclusive PARADOX.LCK file is placed in this directory to keep the older, incompatible locking protocol from putting data at risk.  In Paradox speak, this is known as a "Working" directory. In the VCL the working directory is specified in the TDatabase.Directory property.
Private/Exclusive Directories
The BDE also needs a directory to store temporary files, such as the Answer table from a query.  When the BDE starts, it also places both an "Exclusive" PDOXUSRS.LCK file and an "Exclusive" PARADOX.LCK files in a directory, designating that directory as the location for temporary files.  This designation means that other BDE users/applications cannot access tables in that directory.  This is known as a "Private" directory. In the VCL the private directory can be specified by setting the TSession.PrivateDir property.
Table Locks
The BDE places each table lock in the directory locking file (PDOXUSRS.LCK).  The older locking protocol used separated table lock files.  For example, if three users are viewing the CUSTOMER.DB table and one user is restructuring the ORDERS.DB table, the PDOXUSRS.LCK file will have a shareable lock listed for each of those three users who are viewing the CUSTOMER.DB table, and an exclusive lock on ORDERS.DB for the user who is restructuring that table.
Concurrency
In a multi-user environment, the Paradox 4.0 locking protocol maintains concurrency (the simultaneous use of applications) through the PDOXUSRS.NET file.  All users who want to share Paradox tables must map to the same PDOXUSRS.NET file in the same way using the same path, but not necessarily the same drive letter. The BDE places a PDOXUSRS.LCK and an exclusive PARADOX.LCK file in each directory where tables are being accessed preventing applications using the older locking protocol from accessing files in the same directory.  Each user who wants to share tables in that directory must map that directory the same way using the same drive letter and path.  Paradox then places all of the locking information for that table in the PDOXUSRS.LCK file, reducing the number of files needed.
Network Control File
The Paradox network control file, PDOXUSRS.NET, serves as the reference point for all lock files created by Paradox.  The net file contains the users currently using the BDE and which table they're accessing.  Each lock file references the network control file and contains information regarding the locks on the table and by which user, so each user must map to the same network control file in the same way, but not necessarily with the same drive letter.
For example, if you are using volume DATA on server SERVER_1 and the network control file is in the directory \PDOXDATA each user must map \\SERVER_1\DATA:\PDOXDATA the same way, however, each user should, but is not required to use the same drive letter.  If the network you are using does not have volumes, then DATA would be a directory off the root of SERVER_1.
If you are mapping \\SERVER_1\DATA to the root of drive P: then each Paradox system would specify the location of PARADOX.NET as P:\PDOXDATA\.  However, other users could map \\SERVER_1\DATA to the root of drive O: and specify O:\PDOXDATA\ as the location of the network control file.
Configuring 16 bit Database Engine / IDAPI.CFG
(Delphi 1 only)  The Database Engine configuration file holds the network specific information and the list of database aliases, as well as other information. You can configure IDAPI using the Database Engine configuration program, BDECFG.EXE, to  set the location of the network control file. Also add, delete, modify database aliases including which driver or type of alias used and whether IDAPI will share local tables with other programs using the Paradox 4.0 locking protocol as well as some other specifics regarding the  tables and how data is displayed.  
 Local Settings 16 bit
The WIN.INI file holds the locations of the IDAPI.CFG file, the "Working" directory, and the "Private" directory.  You can use any text editor to change these designations in the WIN.INI file.  The location of the IDAPI.CFG file is CONFIGFILE= or  CONFIGFILE01= in the [IDAPI] group.
The locations of the Database Desktop "Working" and "Private" directories are in the [DBD] group as WORKDIR=, and PRIVDIR=. 

Configuring 32 bit Database Engine / IDAPI32.CFG
(Delphi 2+ and C++Builder) Depending on the version of C++Builder or Delphi use either the BDE Configuration, BDECFG32.EXE, or the BDE Administrator BDEADMIN.EXE, to configure IDAPI32.CFG.  Optionally you can store the information in the registry or in both the registry and IDAPI32.CFG.
 Local Settings 32 bit
The registry holds the locations of the IDAPI32.CFG, the "Working", and "Private" directories.  
The location of IDAPI32.CFG file is stored in HKEY_LOCAL_MACHINE\Software\Borland\Database Engine value CONFIGFILE01 
The location of the BDE’s. default "Working" directory is stored in HKEY_CURRENT_USER\Software\Borland\DBD\7.0\Configuration\WorkDir 
The location of the BDE’s. default  "Private” directory is stored in "HKEY_CURRENT_USER\Software\Borland\DBD\7.0\Configuration\PrivDir 
Finally, How the Paradox Table is Accessed
The BDE will first try to access the PDOXUSRS.NET file. If a PDOXUSRS.NET file is not found, the BDE will create a new PDOXUSRS.NET file and continue with the startup procedure. If the PDOXUSRS.NET file is found but the owner of this net file used a different path, i.e. mapped to the server differently, an exception of "Multiple net files in use" will be raised and the BDE will shutdown. After the net is successfully opened an exclusive lock, PARADOX.LCK, is placed in the temporary, private, directory. If it fails to place the lock the BDE will shut down.  This can fail if some other user has an exclusive lock in this directory or the lock files are using different net files. After it secures a directory for private use it will place a shareable PARADOX.LCK in the working directory. Initialization Complete!
The VCL access
You can also specify the Network, Working, and Private directories in code from the VCL. Specifically the TSession properties NetFileDir and PrivateDir specify the network and private directories and the TDatabase property Directory specifies the working directory.
Paradox on the network
The most common problems with applications that use Paradox tables arise from improper network setup. This section deals with proper network setup. Note that the redundancy in this section over the previous is intentional to help make things clear.
The NET file revisited
When using Paradox type tables with the BDE, a Paradox net file is used to keep track of the number of users.  Each user is given one count.  So, for example, if three Paradox application and three BDE users use the same Paradox net file, the user count would be six (one for each Paradox user, and one for each BDE user).
The net file also regulates access to tables.  Table access is enforced through the use of lock files, which (as mentioned above) are written out to the directories containing Paradox tables.  A lock file points to a particular net file, which has exclusive control over the table.  This means that any user wanting access to the table must use the net file that controls the table.
The message "Multiple Paradox net file found" (Error 0x2C06 or 11270: DBIERR_NETMULTIPLE) indicates that these rules have not been followed.  If you are certain that all current users have the same net path, this message usually indicates that an old lock file exists that points to a different net file. Old lock files can be deleted if care is taken to ensure that no one is currently using them.  Deleting active lock files can produce unpredictable results and could cause loss of data.
Peer-To-Networks vs dedicated File Servers
A Peer-To-Peer network is a network where each machine acts as both a client and as a server. The most common are Windows 95/98, and Windows NT although some people are still using Lantastic and Netware Lite. Applications that use Paradox Tables over a network are usually peer-to-peer. If the Paradox Tables are located on a Novell Netware file server then this is not considered a peer-to-peer network but a File Server Network. Note that a Windows NT Server  with Paradox Files is still considered Peer-To-Peer network because the NT Server can still be used as a workstation.

The BDE automatically detects when tables reside on a network drive, but it cannot detect whether the tables are on a dedicated server or a server’s client.  Dedicated servers notify client applications that a file has been modified or locked.  This functionality is not present in Peer-To-Peer (non-dedicated) networks.  To achieve this functionality with Peer-To-Peer networks set "LOCAL SHARE" to TRUE in the BDE Configuration Utility on the System page or in the BDE Administrator’s Configuration Tab, System | INIT. Node. This must be done on all BDE clients that access the tables on a peer-to-peer network. This is not necessary when the Paradox Tables are on a Novell dedicated File Server.

As mentioned above, Paradox tables also require a directory used for network control.  This directory must also reside on the network for all client applications to use.  It is good practice to have a separate directories for the application, network, and tables. For our example we have a computer system named FooMachine, which has a shared directory called FooShare with subdirectories FooTables, FooExe and FooNetwork

FooMachine
(Shared Directory) FooShare
        |
        |--- (Tables Directory) FooTables
        |--- (EXE Directory) FooExe
        |--- (Network Directory) FooNetwork

There are two different BDE environments that must also be considered:
1)  Using only BDE 32Bit applications.
2)  Using BDE 32Bit applications along with BDE 16Bit applications.

Setup for 32Bit Only Applications
The 32Bit BDE fully supports the UNC naming convention along with long file names. It is recommended that the UNC convention is used for all BDE network connections.  

UNC stands for Universal Naming Convention and is defined as the system of naming files among computers on a network so that a file on a given computer will have the same path when it is accessed from any of the other computers on the network. That is, UNC provides a machine-independent means of locating the file. A UNC name will usually include a reference to a shared folder and file name accessible over a network rather than specifying a drive letter and path. UNC has the following syntax:
  \\(server name)\(share name)\(path)+(file name)

In our example the FooMachine would be configured to share files with others on the network. Then on FooMachine a directory would be created and then marked as shared and given a share name of FooShare. Then as sub directories to FooShare the directories FooTables, FooExe and FooNetwork would be created (and shared).
 
To access our FooTables shared folder you could use the UNC name:
\\ FooMachine\FooShare\FooTables

Note the double slash to start. 

UNC removes the need for mapped drives.  This will allow access to the tables and network directory without the user being mapped to the drive.  

Here is a simple example of a standard BDE alias using UNC:

Alias: MyUNCAlias
     Type: STANDARD
     Path: \\FooMachine\FooShare\FooTables
     Default Driver: Paradox

The network directory for the Native Paradox Driver is setup in the same fashion:
      NET DIR: \\FooMachine\FooShare\FooNetwork

Note that the network directory can also be set at runtime using Session.netfiledir property (which calls BDE method DbiSetProp).

If for some reason UNC cannot be used with the 32Bit application, follow directions for using BDE 32Bit and 16Bit applications.

Setup for 16Bit and 32Bit BDE Applications
Since the 16Bit Windows API does not support UNC, neither does the 16Bit BDE.  To allow applications to share the paradox tables, all clients must be mapped to the same directory on the machine hosting the tables.  If the hosting machine is also used as a client, all other clients must be mapped to the root of the drive containing the tables.  Drive letters from client to client do not have to be identical. Here are some examples of what will and will not work:
Client1: 
    Path: X:\ShareDir\Tables
Client2: 
    Path: X:\ShareDir\Tables
  This is OK

Client1: (Also the machine with the tables):
    Path: C:\ShareDir\Tables
Client2:
    Path: X:\ShareDir\Tables
  This is OK

Client1: (Also the machine with the tables):
    Path: C:\ShareDir\Tables
Client2:
    Path: X:\ShareDir\Tables
Client3:
    Path: R:\ShareDir\Tables
This is OK

Client1: 
    Path: X:\ShareDir\Tables 
Client2: 
    Path: X:\Tables (Where X:\Tables is actually 
X:\ShareDir\Tables, but shared on the ShareDir directory)
  This will not work.  The BDE must be able to make the same entry into the Network Control file.

Paradox Tables on a Network Summary
16 and / or 32Bit Applications:
1) Turn "LOCAL SHARE" to TRUE in the BDE Configuration Utility for Peer-to-peer networks or FALSE if the Tables are on a Novel file server.
2) Do not use the UNC naming convention.
3) Do not use tables with long file names.
4) Make sure that all clients are mapped to the same directory on the server.

32Bit Only Applications on Peer-to-Peer networks:
1) Turn "LOCAL SHARE" to TRUE in the BDE Configuration Utility for Peer-to-peer networks or FALSE if the Tables are on a Novel file server.
2) Use the UNC naming convention to achieve a path to the network directory and table directory.

If the above steps are not followed, users will likely be locked out of the tables getting errors:
"Directory is controlled by other .NET file."
"File: (Path1) PDOXUSRS.LCK"
"Directory: (Path2)"
    OR
"Multiple .NET files in use."
"File: (Path) PDOXUSRS.LCK"
How tables get damaged
Table damage can result from improper setup, power failures, hardware failures, software failures, or human failures. The following list is arranged in order of likelihood;
Improper Application Exit, Badly written programs, and Power Supply Problems,
By far the chief cause of Paradox table corruption comes from the fact that Paradox caches information in volatile memory. Improperly closing files such as due to loss of power (or brown out) or restarting a workstation or the server without closing files first, or programmatically closing the file in an illegal way may all cause table corruption. Paradox tables are not designed to withstand such behavior.
Use surge protectors or UPSs.
Unfortunately in many cases the real culprit here is the end-user. The day comes to and end and the user just shuts off the machine. This is a training issue.
Note that most Client Server databases are designed to recover from such conditions.
Improper Setup
Specifically, incorrectly setting the LOCAL SHARE property. Most commonly this occurs in Peer-to-Peer networking. In this case the two different database engines are on two CPUs, even though they may be the same version. See the section Paradox on a Network above for more information and proper setup. 
Another condition is when two different database engines execute on the same CPU concurrently and access data locally. This would be true when any combination of following is used concurrently: An application(s) that uses the Paradox Engine, BDE 16 bit, BDE 32 bit, Paradox for DOS. In this case each engine must set LOCAL SHARE to TRUE. 
Note that two applications using the sane BDE (for example: Delphi 5 and C++ Builder 5) concurrently are not a problem and LOCAL SHARE does not need to be set to TRUE; In this case, all locking and cached data is in a central memory pool which all BDE applications have access to. Also, if two different database engines use data remotely, LOCAL SHARE must be set to TRUE. 
Its possible to write code used in your application startup to check the setting of local share. Look at the DbiOpenCfgInfoList BDE API function call in the BDE help file for more information (bde32.hlp).
Disk Errors and RAM Problems
These are nasty because they tend to be the most difficult to track down. We recommend that you run Scan Disk (or equivalent) regularly and make sure your RAM memory is properly matched to you CPU and clock speed.
Network Problems
Error transmitting data from the workstation to the server can corrupt data. Most commonly, this occurs with bad network hardware (cable, card, hub, etc.). This has been determined to be a problem even though there were no other errors are detected in data transmission. To determine if this is the cause for your error, try eliminating one CPU at a time from using the data and see if the problem continues. 
When Client is Win95 OSR2 and Tables are on an NT Server
According to Miccrosoft (Q174371) , when a program (like the BDE) uses the GetFileSize() API to get the size of an existing file on a Microsoft networking server (such as a Windows NT-based server), the Client for Microsoft Networks may not return the correct file size. When the program then attempts to write additional information to the end of the file, it may overwrite existing data instead
A Bad VREDIR.VXD on a Windows 95 client accessing the tables can corrupt data. Several versions (4.00.1111, 4.00.1113 and 4.00.1114) of the file VREDIR.VXD need to be updated. Reports have shown that using the original release of (4.00.950) and a new release (4.00.1116 or later) do not result in corruption problems. These bad VXD’s will cause the errors "Blob has been modified" and/or "Index is out of date." If any one of the clients has a "bad" version of this device driver, the error can occur on any machine, not just the machine with the bad driver. This error is most likely occurs in 16Bit versions of the Borland Database Engine, although it still can occur in 32Bit versions. 
To fix the problem download and execute Vrdrupd.exe from support.microsoft.com/download/support/mslfiles/Vrdrupd.exe. 
The following files are installed by Vrdrupd.exe in the \Windows\System directory; Vredir.vxd (ver 4.00.1116, 9/11/97, 11:16a, 156,773 bytes) and Vnetsup.vxd  (ver 4.00.1112, 5/30/97, 11:12a, 17,595 bytes) 
For further information on the update of VREDIR.VXD, Please check the following Microsoft Developer Network Articles: Q174371 and Q165403 
Also on Windows 95 with Tables on NT. 
Add the following key in your registry: HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxD\Vredir 
Then create the string or Binary Value (either one works) with a name of DiscardCacheonOpen and make it equal to 1. 
This an undocumented registry entry obtained from Microsoft. Questions on its functionality should be directed to Microsoft. 
Windows 95 & 98 running Novell software
Make the following registry entries
For the key “HKey_Local_Machine\System\CurrentControlSet\Services\VxD\NWREDIR” set the binary value “ReadCaching” to 0.
For the key “HKey_Local_Machine\Network\Novell\System Config\Netware Dos Requester” set the string value “Cache Writes” to No and the string value “Opportunistic Locking” to No.
You can set these entries even if Novell is not installed without adverse consequence.
Opportunistic locking (Windows NT Only)
There is a problem with opportunistic locking in Windows NT. Try turning off opportunistic locking in the Windows NT registry: See Microsoft Article Q129202  Additional information about possible problems introduced by opportunistic locking can be found in MSDN articles Q134637, Q124916, and Q126026. 
Note: Both Borland’s internal testing and ours has not indicated this setting to be significant. Further, Corel tech support denies that NT opportunistic locking is a problem. However, some Borland customers have indicated this to solve the problem. 
Tables with a large number of Indexes and Referential Integrity
Testing has shown that tables with a large numbers of indexes or indexes with a large number of segments, especially involving Referential Integrity can cause index corruption problems. This seems to be especially true when Windows NT is hosting the Tables. Moving the tables so they are hosted on a Windows 95/98 or Novell Netware files servers may resolve the problem. Where tables must be kept on an NT Server Borland recommends switching to a Client/Server database.
Green Devices
Corel recommends that you disable all green (energy-saving) hardware and software. Often table corruption may occur when using green monitors, green cards and other green devices.
Write-Behind Caching
For Windows 3.1 - ensure that SMARTDRIVE or any other caching program does not perform write-behind caching. 
For Windows for Workgroups 3.1x – disable disk write caching in the SYSTEM.INI in the [386Enh] section and add an entry to disable 32-bit write-caching on all drives that have shared data on them, eg ForceLazyOff=CDE. Microsoft KnowledgeBase article Q107645 describes this option and article Q108109 emphasizes that [386Enh] is the correct section, not [vcache] as mentioned in the Resource Kit documentation. If AUTOEXEC.BAT loads the SMARTDRV.EXE program, make sure the /X parameter is used to disable write-behind caching
For Windows 95 and 98 – From the control panel select the System Icon, than on the Performance tab click the File System button and choose Troubleshooting. Check the option to “Disable write-behind caching for all drives”. 
And a bit more esoteric …
Apparently one programmatic way you can corrupt paradox tables is if you attempt to post a duplicate value to a unique, non-primary index at the same time you attempt to open the same table. This problem only occurs if local share is set to False and only occurs on local drives.
Unverified Voodoo
The following points have been mentioned as being causes of table corruption but not been formally tested.
•	Windows 95 Only: Bring up the network properties screen on all Workstations and enter the netBEUI properties screen. On the advanced tab, make sure that "Set this protocol to be the default protocol" is checked. 
•	Windows 95 Only: If the previous suggestion did not work, try removing the following protocols in order. Remove one at a time and then re-test your problem: NETBIOS support for IPX/SPX-compatible Protocol , TCP/IP , and IPX/SPX-compatible Protocol 
•	If the problem disappears, attempt to add back in all protocols except for the last one that was taken out. Again, make sure netBEUI's default protocol check box is checked. 
•	Windows NT Only used as a Workstation: On the Network Bindings page of the Network Properties, set the NetBEUI Protocol to be at the top of all services. The TCP/IP stack is known for having alot of overhead that might cause timing problems. Since NT will send requests back in the same protocol as it is sent, changing the bindings on a NT machine used as a server will have no effect. 
How to Minimize Table Damage
BACKUP YOUR TABLES REGULARLY
BACKUP YOUR TABLES! And do it on a regular scheduled basis otherwise you get no sympathy. With good backups, the worst that can happen is some small incremental data loss. You’ve heard this all before. Just do it
Train your users
Probably the hardest. Get your users trained. Make sure they understand how to properly exit your application, shut down windows and turn off their machine.
Configure your Environment Correctly
Make sure your network is set up according the guidelines in the section Paradox on a Network. Specifically, 
1). Make sure to Set LOCAL SHARE to TRUE with which ever BDE configuration utility you have.
2). Set up the 3 file shared directory structure discussed above.
3). Specify your applications TSession.NetFileDir, TSession.PrivateDir and TDatabase.Directory to point to the proper directory.
4). Make sure your PrivateDir has enough disk space available. Queries linked across tables can take up three to four times the size of the largest table of its temporary files!
5). Use UNC path names.
Check your Hardware
Make sure you hardware (computers, network cards, diskdrives etc. etc.) is in good working order.
Flush your Buffers
Force your data write to disk. As mentioned, changes made to a Paradox table are normally not written to disk until the table is closed, so power failure or system crash can result in a loss of data, and or table corruption.. To avoid this loss of data you can instruct the VCL to write changes to disk using the FlushBuffers method. The FlushBuffers method didn’t appear until Delphi and C++ Builder 3. For earlier version a direct call to the BDE API method DbiSaveChanges accomplishes the same thing.
FlushBuffers internally calls DbiSaveChanges and I would normally opt for the VCL method. However, if you want to make the BDE call directly by all means do so. You should refer to the BDE help file (bde32.hlp) for the detail. Also, prior to BDE version 4 another function DbiUseIdleTime was also available. I don’t discuss DbiUseIdleTime here because as nice as it was it’s now gone. .
FlushBuffers saves to disk all the updates that are in the buffer of the table associated with the table. It can be called at any point. For example, a good time to call FlushBuffers is in the Table AfterPost event:
void __fastcall TForm1::Table1AfterPost(TDataSet *DataSet)
{
  Table1-> FlushBuffers);
}
Another good place to call FlushBuffers would be in the Applications.OnIdle event. In that case you would call the FlushBuffers for all modified tables in your application.
Post un-posted records onClose
Depending on how you application is designed it is often possible that there are unposted records hanging around when a form (or the application) is closed. Use the OnClose or OnCloseQuery event to post or cancel unposted records.
Don’t Use the DOS SUBST command or the Root Dir
Don’t store tables on drive letters manufactured with the DOS SUBST command. SUBST disables 32 bit file access slowing things down and blocking VSHARE from being loaded and generally mucking things up. Don’t store NET files in a root directory, some BDE visions handle this very badly.
Win3.1 Applications
In Delphi 1, write a wm_EndSession message handler for your main form and call Halt in it. This ensures the BDE closes down and hopefully flushes all its buffers. Also, make sure SHARE is loaded with the parameters suggested by Borland /F:4096 /L:40.

Common Error Messages and Causes
"Multiple Paradox net file found"
The message "Multiple Paradox net file found" (Error 0x2C06 or 11270: DBIERR_NETMULTIPLE) indicates improper network setup. See the earlier section Paradox on a Network
"Index out of Date"
Index out Date ($2F02) is an error that occurs while using Paradox tables when the data in a table and a corresponding index is not consistent. In most cases, short of malicious behavior such as renaming an index, adding some data to the table, then renaming the index back, there is no programmatic way to cause this error to occur (See the section above How Table Get Damaged). There is no way to determine which index is out of date. All indexes must be recreated.
"Blob has been modified"
Blob has been modified ($3302) is an error that occurs when the BLOb portion of the record contained in the .DB file has become inconsistent with the BLOb portion in the .MB file. This could occur when the write to the .DB file was successful but the .MB file did not get updated, or visa-versa. (See the section above How Table Get Damaged)
"Lock file has grown too large"
The error “Lock file has grown too large, Decimal:9495 Hex:2517” is  specific to Paradox tables and can be caused in any BDE (16 or 32 Bit) application that meet any of the following criteria:
1)  The Executable is in the same directory as the table.
2)  The Private Directory is not correctly set or not set at all.
3) Delphi or C++Builder: Having a TTable open on a paradox table and then performing multiple TQuery operations.
4) LOCAL SHARE set to TRUE.

To solve the problem, make sure that your application has done ALL of the following:

1)  Follow the guidelines indicated in the section Paradox on a Network above. Especially pay attention to the recommended 3 directory structure. For the following example under the directory where the executable is, create three new directories: TABLES, PRIV, and NET.  Place all the tables for the application into the TABLES directory.  
2) Set the session's private directory to the PRIV directory.  Take the following steps (this example uses Delphi but the essence is the same for C++ Builder)

Session.PrivateDir := ExtractFilePath(ParamStr(0)) + 'PRIV';

3)  Set the session's network directory to the NET directory.  Take the following steps according to the software you are using.

Session.NetFileDir := ExtractFilePath(ParamStr(0)) + 'NET';

4)  If LOCAL SHARE is set to true and you are not sharing tables between different applications at the same time, change LOCAL SHARE to false.

This should correct the Lock File Too Large error.
“Unknown Internal Operating System”
This error can occur when attempting to open a Paradox table whose language driver is not installed on your computer. In most circumstances this means a bad BDE install and BDE should be reinstalled.
One way to determine a likely bad install is by running BDE administrator and attempting to modify the language driver for the Paradox driver. If only one language driver is available, it indicates a bad install.
This problem is most likely to occur with BDE 5.0 when deploying with a deployment tool that does not know about BDE 5.0. The problem occurs because BDE 5.0 includes a new mechanism for language drivers. To deploy BDE 5.0 language driver features with an older development tool be sure include BANTAM.DLL and *.BTL from the BDE directory on your deployment machine.
“Sharing Violation”
This error is most commonly caused by a "Lock File Contention".  A lock file contention occurs when user "A", is accessing one or more Paradox tables in a directory.  "A" is closing the last table in the directory.  The BDE detects that "A" is the last program accessing the tables in the directory.  Since "A" is the last user on the tables, the .LCK files are going to be deleted.  At this time, user "B" attempts to open a table in the same directory. "B" opens the .LCK files to write an entry to it.  This is when "A" tries to 
delete the .LCK files that "B" has just now opened.  This will cause a sharing violation on the .LCK files.  The share violation usually occurs on the last client to close the table.

There are a few of solutions to this situation. 

Solution 1 
The first solution is to override Windows error routines and ignore the error. In all test cases, then a sharing violation occurs, the table is still opened or closed. To accomplish this, use the Windows API SetErrorMode passing the SEM_FAILCRITICALERRORS constant.  You would only need to do this before opening and closing a table and then check to see if the table has actually been open. 

Solution 2
The second solution is to keep the LCK files in the table's directories.  If the BDE detects that more than one Application (or Session) is using the tables, it will not attempt to delete the .LCK files therefore solving the problem. Accomplish this by creating a "Dummy" Paradox table in each table directory that the application uses. Example: executable is in directory C:\MyProg.  This executable opens tables in two different directories - C:\MyTables and D:\TempTbl.  Create a "Dummy" table with the Database Desktop, or any other Paradox table creation utility, in both the C:\MyTables and D:\TempTbl directories.  Once the tables are created, create an application that opens each of the "Dummy" programs at startup.  Leave this program running at all times.  Optimally, this executable is placed on a server machine, like Windows NT, so whenever other applications are accessing the data, the server also has the "Dummy" tables open.  

Solution 3
Leave at least one table during the entire application's run.  Open one table during application startup don’t close it until exit.  

Solution 4
Use the DbiAcqPersistTableLock BDE API function to create a lock on a table that does not exist. See bde32.hlp for details. Be aware that each instance of the application must have a unique, non-existent table name or an attempt to place a lock in the directory will fail.  If this method is used, an algorithm must be used to guarantee a unique table names.  If a user can only run one instance of the program at a time, the network user name can be used as a table name.

Addition notes
The sort of “Lock File Contention” problem does not seem to occur on NT workstation machines. The application can be either 16 or 32 bit. SetErrorMode seems to work with both cases.
The problem is more likely to occur if the network protocol is netBEUI.  If possible use netBIOS or IPX/SPX.
Constant closing and opening of tables will cause this error more often.
The error most commonly occurs on the close of the table, not the open.  In this situation the closing application tries to delete files that another application now has open.

“Duplicate value in unique key”
If this table has an autoincrement field type then the likely cause is a bad auto increment seed in the table header. See the section titled Broken Auto Increment field later in this document.
Fixing Corrupt Tables
Two Goals
When facing corrupt paradox tables you should always have two goals. First, try to determine the cause of the damage and eliminate it. Second, recover and repair the data.
Repair steps
There are several steps involved in repairing table corruption.
1.	Reboot
First try rebooting your system(s) and make sure the corruption message is real. It turns out that some corruption messages may be just a misunderstanding between volatile memory, disk memory and the BDE. If after rebooting the error is still manifest then … go on.
2.	Preparation
Before you begin with repair utilities, you should always make a backup of all files (corrupt or not). Its possible the repair utility could make things worse so make sure you keep an earliest version of the corrupt files around. This is especially important if you have to resort to step 6.
You will also need to have exclusive access to the files. If possible copy them to a local hard drive and disconnect from the network. If this is not possible, make sure that no one else has access to the tables while you are working on then.
3.	The Table repair utility and Tutility DLL.
When ever Borland does a build of the BDE, one of the resulting DLLs is TUTIL32.DLL (TUTILITY.DLL for the 16 bit BDE). This DLL is not distributed with the BDE but is available on the Borland Website at www.borland.com/devsupport/bde/utilities.html . Borland does not officially support this DLL but they have published some documentation and sample programs that can also be found at the above location. (Historically, the location of these files has moved quite often so if the link goes bad just surf the BDE support area, you should find it.). You can find additional information on these DLLs at our web site www.o2a.com/TUFiles.htm web site which also maintains links to the current page on the Borland site.
I mention that the TUTIL32.DLL is a side effect of the BDE build process because the rule is that the BDE version and the TUTIL32.DLL version should match. The reality is that the code for the TUTIL32.DLL hasn’t been modified since BDE 3.51 so any version of the DLL greater than 3.51 should be fine.
The TUTIL32.DLL is the basis for the Table Repair utility that comes with Corel’s Paradox Application (version 9 as of this writing). So if you have a recent version of the Paradox Application you can use the built in table repair functionality on your Paradox tables. If you don’t have a version of the Paradox application you can grab a table repair utility (that also uses the TUTIL32.DLL) from the Borland web site mentioned above. 
Or… even better, you can check out our TTUtility component set at www.o2a.com/tu.htm. Yes, this is a shameless plug but if you want automated Paradox table verify and repair that can take care of your whole database without human intervention then it’s the only way to go . 
Table repair based on the TUTIL32.DLL will repair damage, and should usually be the first step in repairing a corrupt table. The DLL is not however 100% effective. 
How the DLL works – The TUTIL32.DLL can both verify and repair Paradox tables. The idea is to first confirm corruption but running the verify routine and then depending on the severity of the error select a repair method. If the verify routine only finds damage in the indexes or the data blocks of the DB file then the table can be rebuilt using its own structure. If verify finds that the header section of the DB file is damaged then what the table knows about its own structure is questionable. In this case a suitable structure definition will need to be provided to the repair routine. Typically this is done by providing another table with the same structure as the one being repaired to “borrow structure” from. For this reason, we always suggest that you keep an empty set of all your tables around in a safe place.
With a valid table structure the DLL’s rebuild function can be called. Rebuild first renames the corrupt table to a backup name, then creates a new empty table with the original name. Next the DLL starts moving the data, one record at a time, from the original table to the new table. If the original table had indexes and the indexes were in good shape then the old indexes are also renamed to the back up name and new ones are created from scratch. 
Information about the structure of the primary index is stored in the DB header block but nothing about he secondary indexes is stored in the DB header so if any of the secondary indexes are missing prior to the rebuild then they will not be available in the newly rebuilt table. Also if the primary index information in the header is damaged then its possible that now primary index is created. In this case you can use the DB Desktop to rebuild these indexes after the table repair has completed.
If the TUTIL32.DLL is passed a table name and the message “Cannot open table” then the damage is to serious for the DLL and you should continue on to step 4..
4.	Removing indexes
Corruption can sometimes occur in the keys, indexes or validity checks of a table. This sort of corruption is dealt with by deleting these elements, and then recreating them using the Database Desktop’s restructure tool.
Start up DB Desktop and select Tools | Utilities | Info Structure and select the problem table. Write down ALL of the structure information about indexes, validity checks etc.. If you get an error message “Unable to open table” or “Corrupt index other than header”, you will not be able to write down the information about the table structure. You can still continue with this section; however, you will need to know what indexes and validity checks you have defined so that you can recreate them later.
Write down what fields are part of the primary key, the validity checks for each field (if any), what table lookups are defined, etc. You will need to recreate all of these entries in a moment.
Close DB Desktop and open Windows Explorer and select the directory where the tables are located. In that directory, you’ll see a number of files with identical names, but with different extensions. Delete any files that have the same name as the table in question, and have any of the following extensions PX, .X??, .Y??, .TV, .FAM, or VAL. Do not delete the .DB or .MB files; these contain your data and BLOb (memo) fields.
Once these files are deleted, you should be able to open and use your tables so restart DB Desktop and re-define all of you indexes, validity checks and referential integrity. If you still can’t open your files then go on to step 5.
Recreate the primary key, validity checks, secondary indexes, etc. by selecting Tools | Utilities | Restructure, re-entering the items you wrote down earlier and save.
Your table should work correctly now. 
5.	Export to ASCII
This method is the most thorough way of removing corruption from a table. The data is completely separated from the structure of the table. The old table structure is discarded and re-entered. The data is then imported back into a new structure.NOTE: This method will not work for Memo, Graphic, OLE or Binary fields. 
A discussion of the what’s needed to export a Paradox table to an ASCII file is beyond the scope of this paper. There are two articles on the subject on the Borland web site. These are TI892D.TXT(Article ID 15892) “Using the ASCII Driver with Comma-delimited Files” and also FAQ1960C.TXT(Article ID 16960)  “Converting ASCII files to Paradox Tables” another really good article on the subject by Dr. Cary Jensen can be found on the Delphi Magazine web site at www.delphimag.com/features/1999/06/di199906cj_f/di199906cj_f.asp . 
Using the same methods as above, make a list of the field names, types and sizes, as well as the keys, indices, validity checks, etc. and export your table to “ASCII Delimited Text” format. Once you have verified that all of the records have exported correctly (open the text file in WordPad), you can delete the original table. Now create a new table with the original nane  and re-import the ASCII table into the Paradox table. 
6.	One other Option
If none of the above options work, your table may is likely very severely damaged. Corel Technical Services may be able to recover some or all records in the table; this service is available for a fee ($150 US per hour at the time of publication of this document). Call 1-888-765-7369 for further information. 
We have never used this service and are neither recommending or not.
Broken Auto Increment field
The single most commonly reported problem with tables that have been theoretically repaired successfully with the TUTIL32.DLL is a “Duplicate value in unique key” error when a new record is inserted into the table. 
 In every case where this error has occurred after a rebuild the cause has been an AutoIncrement field type. The reason for the error is that the auto increment “seed” (stored beginning at position 49h in the DB file header block) incorrectly stores a value that has already been used. The only solution we’ve found for this situation is to use DB Desktop to restructure the file converting the auto increment field to a long integer type field, save the change, the restructure the table again converting the long integer field back into an auto increment field.
Out experience tells us this is a very common problem and our tests show that it is very easy to reproduce. In fact, we give it about a 50% chance of occurring in the situation where a table with one auto increment field is opened, a record is inserted and then the application is abnormally aborted (like killing it in the task manager). 
Miscellaneous FAQ
I have a paradox table that uses a password.  How do I make it so that the form that uses the table comes up without prompting the user for the password?
The table component's ACTIVE property must be set to FALSE (If it is active before you have added the pasword, you will be prompted). Then, put this code in the handler for the form's OnCreate event:

  Session.AddPassword('My secret password');
  Table1.Active := True;

Once you close the table, you can remove the password with RemovePassword('My secret password'), or you can remove all current passwords with RemoveAllPasswords.  (Note: This is for Paradox tables only.)

I have referential integrity set on my Paradox how do I do a cascading delete of my child records?
Paradox tables offer a Referential Integrity feature. This feature prevents adding records to a child table for which there is no matching record in the parent table. It will also cause the key field(s) in the child table to be changed when the corresponding key field(s) in the parent are changed (commonly referred to as a cascading update). These events occur automatically, requiring no intervention by a Delphi or C++Builder application using these tables. However, the Paradox Referential Integrity feature will not accommodate cascading deletes. That is, the VCL will not allow you to delete a record in the parent table while matching records exist in the child table. This would make "orphans" of the child records, losing referential integrity. The VCL raises an exception when an attempt is made to delete such a parent record.

To effect a cascading delete requires that the deletion of the matching child records be deleted programmatically -- before the parent record is deleted. In a VCL application, this is done by interrupting the process of deleting the record in the parent table, deleting the matching records in the child table (if there are any), and then continuing with the deletion of the parent record.

A record in a table is deleted by a call to the Delete method of the TTable component, which deletes the current record in the associated table. Interrupting the this process to first perform some other operations is a matter creating a procedure associated with the BeforeDelete event of the TTable. Any commands in a BeforeDelete event procedure are executed before the call actually goes out from the application to the BDE to physically remove the record from the table file.

To handle the deletion of one or more child records, in a BeforeDelete event procedure the Delete method for the TTable representing the child table is called in a loop. The loop is based on the condition of the record pointer in the table not being positioned at the end of the data set, as indicated by the Eof method of the TTable. This also accounts for there being no child records at all matching the parent record to be deleted: if there are no matching records, the record pointer will already be at the end of the data set, the loop condition will evaluate to False, and the Delete method in the loop never gets executed. Here’s an example on Object Pascal.

  procedure TForm1.Table1BeforeDelete(DataSet: TDataset);
  begin
    with Table2 do begin
      DisableControls;
      First;
      while not Eof do
        Delete;
      EnableControls;
    end;
  end;

In the above example, the parent table is represented by the TTable component Table1 and the child by Table2. The DisableControls and EnableControls methods are used as a cosmetic measure to freeze any data-aware components that might be displaying data from Table2 while the records are being deleted. These two methods make the process visually appear smoother, but are only optional and not essential to this process. The Next method need not be called within this loop. This is because the loop begins at the first record and, as each record is deleted, the record that previously followed the deleted record moves up in the data set, becoming both the first and the current record.

This example presumes that the parent and child tables are linked with a Master-Detail relationship, as is typical for tables for which such Referntial Integrity is configured. Linking the tables in this manner results in only those records in the child table that match the current record in the parent table being available. All other records in the child table are made unavailable through the Master-Detail filtering. If the tables are not so linked, there are two additional considerations that must be accounted for when deleting the child records. The first is that a call to the First method may or may not put the record pointer on a record that matches the current record in the parent table. This necessitates using a search method to manually move the record pointer to a matching record. The second consideration affects the condition for the loop. Because records other than those matching the current record in the parent table will be accessible, the condition for the loop must check that each record is a matching record before attempting to delete it. This checking is in addition to querying the Eof method. Because the records will be ordered by this key field (from a primary or secondary index), all of the matching records will be contiguous. This leads to the given that, as soon as the first non-matching record is reached, it can be assumed that all matching records have been deleted. Thus, the previous example would be modified to:

  procedure TForm1.Table1BeforeDelete(DataSet: TDataset);
  begin
    with Table2 do begin
      DisableControls;
      FindKey([Table1.Fields[0].AsString])
      while (Fields[0].AsString = Table1.Fields[0].AsString) and 
        (not Eof) do
        Delete;
      EnableControls;
    end;
  end;

In the above, it is the first field in the parent table (Table1) upon which the Referential Integrity is based, and the first field in the child table (Table2) against which matching is judged.
I am attempting to add data to my Paradox table but I'm getting the Error "Table is Full". What is the cause of this and how can I add more records?
Paradox tables have a block size which determines the maximum record size for a table and the table's maximum size. By default tables have a block size of 2 or 4K. Regardless of the block size, tables can have a maximum of 64K blocks. This means by default a table can grow to 256 MB. 
You can increase the block size of a table in 1 of two ways. 
Run BDE Admin and change the block size for the Paradox driver to a revised number. Legal block sizes are 1024, 2048, 4096, 16384 and 32768. If your block size is larger then 4096 then you must also change level to be at least 5. Finally, create a new table and batchmove your data from your old table to your new table 
It is also possible to change the block size of an existing Paradox table by calling BDE API function dbiDoRestucture (see bde32.hlp). For an example see www.borland.com/devsupport/bde/files/pxrest.zip 

How can I check the LOCAL SHARE setting from my code?
The Local Share setting is crucial to proper operation of Paradox tables on a network. You can check the LOCALSHARE setting in your main forms OnCreate as follows.

function LocalShareIsTrue : Boolean;
var 
  SL : TStringList;
begin
  { Ensure BDE is initialised }
  Session.Open;
  SL := TStringList.Create;
  Session.GetConfigParams('\System\Init','',SL);
  result := ('TRUE' = SL.Values['LOCAL SHARE']);
  SL.Free;
end;

And then in the main forms OnCreate;

procedure TForm1.FormCreate(Sender: TObject);
begin
  if not LocalShareIsTrue then
  begin
    ShowMessage('BDE''s LOCAL SHARE flag must be TRUE for this ' +
      'program to run. This program will now terminate');
    Application.ShowMainForm := False;
    Application.Terminate;
  end
end;

Note that Delphi 1 did not support the GetConfigParams  menthod so you will need to call the BDE API method DbiGetSysConfig to get the local share value.  

How do I pack a Paradox Table?
Deleting records from Paradox table, doesn't resize the file; it simply marks the space of the record as available.  Thus, as you add records, over time you get a bigger data file.  Once you've deleted some records you can “pack” the table. Here’s some code to do just that.

procedure PackIt(Tbl: TTable);
var 
  crtd: CRTblDesc;
  DB : TDatabase;
  Res: DBIResult; 
begin
  DB := TDatabase.Create(Application.MainForm);
  DB.DatabaseName := Tbl.DatabaseName;
  if Tbl.Active then
    Tbl.Active := False;
  DB.Connected := True;
  FillChar(crtd,SizeOf(CRTblDesc),0);
  StrPCopy(crtd.szTblName,tbl.TableName);
  crtd.bPack := True;
  Res := DbiDoRestructure(db.Handle,1,@crtd,nil,nil,nil,FALSE);
  DB.Connected := False;
  DB.Free;
  If Res = ERRCODE_NONE then
    showmessage('Pack Complete!')
  else  
    DbiError(Res);
end;

Accessing the PDOXUSRS.NET file on Novell drive takes 7-10 seconds with Windows 95 Client for Novell. Occurs with any BDE client.
Problem only occurs with Novell client. Microsoft is OK. So, the simplest solution is to switch to Netware client. Also, according to Novell the problem only occurs with Windows 95 and 98. Windows NT are fine.
Novell has a discussion of this problem on their web site. It may be found by going to support.novell.com/search/kb_index.htm, search on pdoxusrs.net, then select the document called "slowness when launching Paradox on Windows 95"
Here is the solution this document states:
Cache writes = off 
Close Behind Ticks=0
File Caching=0
Lock Delay=1
Lock Retries=1
Read Only Compatibility= on
True Commit=On
Opportunistic Locking=off (with the older client)

I need to distribute my Paradox tables on a CD-ROM, how do I do that?
The Paradox locking scheme requires the existence of a PDOXUSRS.LCK file to handle its locking logic. This file is generally created at run-time and resides in the same directory as the tables. With a CD-ROM there is no way to create this file at run-time since the device is read-only. 
The solution is to pre-create the PDOXUSRS.LCK file and put it on the CD-ROM when it is originally created. The following is a small program for creating a PDOXUSRS.LCK file that you can copy to the CD-ROM master image.

uses BDE,FileCtrl
procedure MakeNETFile(DirPath : TFileName);
var
  DB : TDatabase;
  s : array[0..100] of char;
begin
  If DirectoryExists(DirPath) then 
  begin
    DB := TDatabase.Create(Application.MainForm);
    DB.DatabaseName:= 'TempDB';
    DB.DriverName:= 'Standard';
    DB.LoginPrompt:= false;
    DB.Connected := False;
    DB.Params.Add('Path=' + DirPath);
    DB.Connected := TRUE;
    Check(DbiAcqPersistTableLock(DB.Handle,'PARADOX.DRO','PARADOX'));
    DB.Connected := False;
    DB.Free;
  end
  else 
  begin
    StrPCopy(s,'Directory : ' + DirPath + ' Does Not Exist');
    Application.MessageBox(s, 'Error!', MB_ICONSTOP);
  end;
end;

To use this procedure specify the destination path of the LCK file in the DirPath paramter. On return, both a PDOXUSRS.LCK and Paradox.lck file will be in the DirPath location. All you need do is copy the resulting PDOXUSRS.LCK to the CD-ROM master image. (The PARADOX.LCK file is only necessary when accessing Paradox for DOS tables so you can delete it.)

References
Borland Technical Articles www.borland.com
TI3342 (Article ID: 15209) Views on the Paradox corruption issue
TI15443 (Article ID: 15443) Autoincrement value of Paradox table
TI1437D (Article ID: 16437) Paradox Locking Protocols
TI992D (Article ID: 15992) Automating logon for Paradox tables
TI265B (Article ID: 15265) Sharing Violation Error with Paradox Tables
TI1333D (Article ID: 16333) Paradox Tables on CD-ROM
FAQ3749B (Article ID: 18749) Tables language drive must be correct
FAQ379B (Article ID: 15379) Access to PDOXUSRS.NET slow
TI2913D (Article ID: 17913) Making sure changes survive a power failure
TI862D (Article ID: 15862) Cascading Deletes w Pdox Referential Integrity
TI42B (Article ID: 15042) Packing Paradox table
TI1256B (Article ID: 15256) Removing “Lock file . to . large” Error
TI15143 (Article ID: 10318) Paradox Table full fix by changing block size
TI69B (Article ID: 15069) Common Paradox Error Messages
TI247B (Article ID: 15247) BDE Setup for Peer to peer networks
FAQ313B (Article ID: 15313) Paradox File Extensions
TI5B (Article ID: 15212 ) Paradox.NET file explained
TI239B (Article ID: 15212 )  The Paradox Engine
TI2801C (Article ID: 17801) Writing a Buffer Disk 
Corel www.corel.com
CTI 7586 Possible Causes of Table Corruption
CTI 7588 Dealing with Table Corruption
CTI 7587 Configuring the Idapi (Borland Database EngineI
Microsoft Developer Network Articles 
Other
www.itecuk.com/Delmag/Paradox.htm Really good articles on the subject from a really good (likely the best) Delphi magazine..
www.turbopower.com/newsletters/0798/default.asp - Discussion of the Windows 95 redirector problem and NT opportunistic locking:
msdn.microsoft.com - Q148367 discusses the Win95 redirector bug
www.daccess.com/Support/Integrating_DF_with_NetWare.htm - Discussion of Novell settings to avoid data loss:
support.novell.com/search/kb_index.htm Article 2917002 describes a Novell read caching problem; article 2911461 describes potential data loss issues using Windows 95 against a NetWare 3.11 server: 
orionweb.lotus.com/sims/c8f6_546.htm - cc:Mail technical paper 144293 discussing various Windows registry settings that need to be set correctly to avoid data loss: 
orionweb.lotus.com/sims/8a76_546.htmcc:Mail technical paper 139714 discussing preferred NetWare settings to avoid data loss; if you use NetWare you should read this as it describes many preferred NetWare configuration settings not discussed here: