PB Database Related

----------------------------------------------------------------
Database artboards:
When a table defines a primary key or a unique index, you can modify, add, and delete data in the results window.

Using SQL statements to create a data table is the quickest way. However, when you create a data table, PB adds information about the data table to the System data table, and the extended properties of the table and field are saved in the system table. Therefore, creating system tables directly using SQL statements will make the information in the system tables incomplete. Use the Synch Extended Attributes command under the Window menu design to correct these incomplete. In fact, the incomplete system tables do not have a lot of side effects, especially if you are not using system table authoring programs.

Extended Properties of the table:
Set the related properties in the related property pages. You can set the comment information for a table in the General property page, and you can use Chinese characters. The Data Font property page is used to define the display properties of the information retrieved from the database, manipulate the data in the databases artboard, or run the data window when retrieving data. The Heading Font property page is used to set the display style of the header in the Data window for grid, tabular, and n-up display styles. The Label Font property page is used to set the display style of the label in the data window of the freeform display style.

Extended Properties for fields:
Set the related properties in the corresponding property pages. The General property page is used to set the comment information for the field (which appears at the table's field description, at the tag of the Data Window object). The Headers property page is used to set freeform, display styles in the Data window Label,tabular,grid and n-up the header in the data window of the display style (after setting the contents of the label and heading two, such as filling in the Chinese information for the field, Displays the Chinese information in the corresponding label or header after the Data Window object is made. The Display property page is used to set the displayed style of the field, including the width of the data in the field, the height, whether it is displayed as a picture, whether to add a certain mark (for example, whether to add ￥ to indicate that the current data is renminbi). The Validation property page is used to set the validation rules, and the data entered in the Data window must be able to be received by the validation rule. For example, you can specify that the data that the user enters on the salary (payroll) field should be within a certain range and not be received if it is not in that range. The Editstyle property page is used to set the editing style when the field is edited in the data window, such as using the radio button to let the user edit the field's data.

You can open two Columns (view->columns) at the same time to copy and paste the definition of a field between different data.

Print definition of a data table:
Definition syntax for OUTPUT data table: Export Syntax
SQL syntax for viewing data table operations: Pending Syntax

Open related Table
In a data table containing keys, it is often necessary to open all data tables that have dependencies on the key, right-click in the Objects Layout window, the key (primary key or foreign key) icon in the data table, and the open dependant table (s) in the pop-up menu. command to display all data tables that have dependencies on the key. When a dependent data window is opened, there is a line join between the keys that have dependencies, which indicates the dependencies between them. When you open a data table for a long time, you can right-click the window blank and use the Arrange tables in the pop-up menu to arrange the layout of the Data window.

When defining a foreign key, be careful to select the delete policy on the Ruels property page

Results page, right-click Save Rows as ... Save data to External
Rows->import importing data from outside

----------------------------------------------------------------
A transaction object can only connect to one database at a time, and defining multiple transaction objects allows you to establish connections to a database at the same time.
Transaction Gt_sqlca
GT_SQLCA = Create Transaction

----------------------------------------------------------------
Transaction
In Pb, the operation of a transaction is done by first defining the start of a transaction (by default, SQLCA) and then modifying the data, which is persisted if committed (commit), and if it is rolled back (rollback), the database management system discards all modifications. Returns the state at which the transaction was started.

----------------------------------------------------------------
The transaction object consists of 15 parameters: (5 state information to return the operation, and 10 parameters for setting and database connection)
SQLCode is the success flag, there are three possible values: 0-Success, 100-no data, a-error (long)
Error code for Sqldbcode database (long)
Sqlerrtext Database error message (string)
Sqlnrows the number of rows involved-different DBMS differs (long)
Information specified by the Sqlreturndata DBMS (string)

Dbms
Database
Logid
Logpass
ServerName
Userid
Dbpass
Lock
Dbparm

Connect {using SQLCA}; Connection database, after connection, you can determine whether the database is connected correctly according to the return value of Sqlca.sqlcode

----------------------------------------------------------------
Database operations:
Select:
Select field Name set into: Variable collection from table name where conditional expression {Using transaction object name};
Select Salary,name into:li_salary,:ls_name from Salarys where name =: Ls_nameusing Sqlca;
Insert:
Insert into Table name (field list) VALUES (value list) {using Transaction object};
INSERT INTO Dept (deptno,deptname,workers) VALUES (: Ls_deptno, "Sales department", 10);
Delete:
Delete from table name where condition expression {using Transaction object};
Delete from table name where current of cursor name;
Delete from dept where workers = 10;
Delete Form dept where current of Dept_cur;
Modify:
Update table name set field name =: variable name (or constant) [, Field name =: variable name (or constant)] where condition {using Transaction object};
Update table name set field name =: variable name (or constant) [, Field name =: variable name (or constant)] where current of cursor;

----------------------------------------------------------------
You can use the Execute Immediate directive to perform arbitrary database operations. --Dynamic SQL statements
The database directives are edited into a string, and you can execute any data definition statements, such as Build table, primary key, stored procedure, etc.
eg.
String Ls_sql
Ls_sql = "Delete from Customers WHERE CustomerID = ' 1 '"
Execute immediate:ls_sql;
If Sqlca.sqlcode = 0 Then
Commit
Else
Rollback
End If
Note: Ls_sql can include variables, etc., as long as it is ultimately an SQL statement
Note: if, Sqlca.autocommit = True, the transaction is committed automatically, then the following if ... is not required.

----------------------------------------------------------------
There are four types of dynamic SQL statements:
No input parameters, no result set;
There are input parameters, but no result set;
The parameters and result sets are known at compile time;
Development program Fashion does not know the parameters and the result set.

Type one

This type of dynamic SQL statement is often used to execute DLLs or other SQL statements that are specific to the database. The syntax format is:
EXECUTE IMMEDIATE sqlstatement {USING transactionobject};
Where SQLStatement is a string whose contents are valid SQL statements, Transactionobject is the transaction object name, curly braces indicate that the clause can be omitted, and Sqlca is used when omitted. Here is an example of creating a delete data table:
String MySQL = "DROP table employee"
EXECUTE immediate:mysql USING SQLCA;
* It is best to use the following code
String ls_sql = ' DROP table employee '
Execute immediate:ls_sql using Sqlca;
If Sqlca.sqlcode = 0 Then
Commit
Else
Rollback
End If

Type two

Use this type of dynamic SQL statement before running a number of known parameters and no return value. This type of dynamic SQL statement can also handle data manipulation statements that require parameters to be defined at run time. Its syntax format is:
PREPARE Dynamicstagingarea from Sqlstatement{using transactionobject};
EXECUTE dynamicstagingarea USING {parameterlist};
Where Dynamicstagingarea is a variable of type Dynamicstagingarea, the default global variable of that type is sqlsa;sqlstatement is a string constant or variable whose content is a valid SQL statement, The SQL statement uses a question mark to represent the required parameter, and the execution question mark is substituted by the value represented by the using clause in the SQL statement in the EXECUTE statement; Transactionobject is the transaction object name, curly braces indicate that the clause can be omitted, and when omitted, use Sqlca Paramenterlist is a parameter list, which can be a variable, a constant, or a property of a control, and each parameter corresponds to a question mark in SQLStatement. The dynamic policy area is used to prepare the SQL statement and the required number of arguments, its properties are not accessible at run time, and Sqlsa is the default dynamic policy area variable.
eg
int Emp_id_var = 56
PREPARE Sqlsa from "DELETE from employee WHERE emp_id =?";
EXECUTE Sqlsa Using:emp_id_var;
eg
Prepare Sqlsa from "INSERT into employee (emp_id,manager_id) value (?,?)";
Execute Sqlsa using:ls_empid,:sle_manager.text;

Type Three

This type of dynamic SQL statement may be used only after the first type, it is commonly used to deal with the number of parameters and the result set at compile time is known, but also into the cursor and stored procedures two cases. The syntax used in the form of cursors and the order in which they appear in the program are:
DECLARE cursor DYNAMIC cursor for dynamicstagingarea;
PREPARE Dynamicstagingarea from Sqlstatement{using transactionobject};
OPEN DYNAMIC cursor{using Parameterlist};
FETCH Cursor into hostvaribalelist;
Close Cursor;
The third type of dynamic SQL statement that uses stored procedures is similar in format and order to the syntax above, except that the EXECUTE statement is used instead of the open statement above, with the syntax in the following form:
DECLARE Procedure DYNAMIC Procedure for Dynamicstagingarea;
PREPARE Dynamicstagingarea from Sqlstatement{using transactionobject};
Exectue DYNAMIC procedure{using Parameterlist};
FETCH Procedure into hostvariablelist;
CLOSE Procedure;
where cursor and procedure are cursor names and procedure names respectively; Dynamicstagingarea is a dynamic policy area variable, usually using a system-predefined global variable sqlsa;sqlstatement is a string (a constant or variable can be Variable name is preceded by a colon), the content is a valid SQL statement, and a question mark is used to represent the argument; Parameterlist is a list of parameters corresponding to the question mark in SQLStatement The hostvariablelist is the powerscript main variable (that is, the powerscript variable preceded by a colon); Transactionobject is the name of the transaction object and SQLCA is used by default.
The Declare statement describes a dynamic cursor or dynamic procedure, prepare statement prepares a dynamic policy area, an open or EXECUTE statement opens a dynamic cursor or performs a dynamic process, a fetch statement reads a row of data, and if multiple rows of data need to be read, the FETCH statement needs to be executed repeatedly. Finally, the close statement closes the dynamic cursor or dynamic procedure. The use of the FETCH statement and the close statement is the same as described in the previous section. Here is an example of an application of the third type of dynamic SQL statement, which he obtains as an employee of "Beijing":
DECLARE my_cursor DYNAMIC cursor for SQLSA;
int Emp_id_var
String sqlstatement,emp_state_var = "Beijing"
SQLStatement = "Select emp_id from employee WHERE emp_state =?"
PREPARE Sqlsa from:sqlstatement;
OPEN DYNAMIC my_cursor Using:emp_state_var;
FETCH My_cursor Into:emp_id_var;
CLOSE My_cursor;
The example omits the necessary SQL statements to perform state checks, and when the program is actually written, the Sqlcode property of the transaction object should be checked to determine whether the SQL statement was executed successfully, except for the Declare statement, after executing other SQL statements.
Use this type of dynamic SQL statement to create a more generic script that adds data to a list box or drop-down list box.
//////////////////////////////////
Function name: Wf_additem (dropdownlistbox fo_obj,string fs_sql)
Parameters: Fo_obj as drop-down list box, fs_sql as SQL statement
return value: None
function: Use the SQL statement specified by the parameter to add data to the specified drop-down list box
////////////////////////////////////
String Ls_item
DECLARE item_cur dynamic cursor for SQLSA; Defining the dynamic cursor
Prepare Sqlsa from:fs_sql using Sqlca;
Open dynamic item_cur; Turn on the dynamic cursor
Fetch Item_cur Into:ls_item; Fetch data
Fo_obj.setredraw (FALSE)//Disable drop-down list box refresh
Do While Sqlca.sqlcode = 0
Fo_obj.additem (Ls_item)//drop-down list box to add items
Fetch Item_cur Into:ls_item;
Loop
Fo_obj.setredraw (TRUE)//Refresh drop-down list box
Close item_cur; Turn off the dynamic cursor

Type Four

The fourth type of dynamic SQL statement is the most complex and powerful, and it is capable of handling SQL statements that do not know the parameters and result set of the programming fashion. Similar to the third dynamic SQL statement, there are two types of dynamic SQL statements in class Fourth: one for cursor processing and the other for stored procedures, except that the open statement is used instead of the EXECUTE statement for cursor processing. In the case of a stored procedure, the EXECUTE statement is used but the open statement is not used. The syntax for the fourth dynamic SQL statement is given below, where cursor targets the cursor and procedure for the stored procedure:
DECLARE cursor| Procedure DYNAMIC cursor| PROCEDURE for Dynamicstagingarea;
PREPARE Dynamicstagingarea from Sqlstatement{using transactionobject};
DESCRIBE Dynamicstagingarea into Dynamicdescriptionarea;
OPEN DYNAMIC Cursor USING Descriptor dynamicdescroptionarea;|
EXECUTE DYNAMIC Procedure USING descriptor Dynamicdescriptionarea;
FETCH cursor| Procedure USING descriptor Dynamicdescriptionarea;
CLOSE cursor| Procedure;
where cursor and procedure are cursor names and procedure names respectively; Dynamicstagingarea is a dynamic policy area variable, usually using a system-predefined global variable sqlsa;sqlstatement is a string (a constant or variable can be Variable name is preceded by a colon), the content is a valid SQL statement, and uses a question mark to represent the parameter; Dynamicdescriptionarea is a dynamic descriptor variable that is specifically used to describe the input and output parameters in the fourth class of dynamic SQL statements. Typically, a system-predefined global variable, Sqlda;transactionobject, is the transaction object name, and Sqlca is used by default. The fourth dynamic SQL statement uses the dynamic Descriptor object variable, which can get the input parameter number, input parameter type, output parameter number and output parameter type by four properties Numinputs,inparmtype, Numoutputs, and Outparmtype of the variable. , where Inparmtype is the array, and each element in turn corresponds to a question mark in the SQL statement; Outparmtype is also an array, and each element corresponds to an output parameter. The data types for Inparmtype and Outparmtype are enumeration type Parmtype, which range from the values listed in the applicable parameter type column below:
parameter types for function names
Getdynamicnumber () typeinteger!, typedecimal!, typedouble!,
typelong!, typeteal!, typeboolean!,
typeunsingedinteger!, typeunsignedlong!
Getdynamicstring () typestring!
Getdynamicdate () typedate!
Getdynamictime () typetime!
Getdynamicdatetime () typedatetime!
Set the specific input parameter value by using the function setdynamicparm () of the object variable. The above object function gets the value of the output parameter (which is actually the return data of the SQL statement), each of which is for a specific data type.
The order of execution of each statement in the fourth class of dynamic SQL statement syntax is important, and the execution of the latter statement is meaningful only if the previous statement succeeds, so that, in addition to the Declare statement, the Sqlcode property of the transaction object should be checked after the execution of the statement. To determine whether the execution of the current SQL statement was successful. By invoking a FETCH statement, you can read multiple data, and after each reading of a piece of data, you typically use the Choose case in a loop statement to determine the type of the output parameter and then use the corresponding function above to get its value. The following is an example of an application of the fourth dynamic SQL statement, which omits the process of checking the Sqlcode property of the transaction object that must be available in actual programming (that is, checking that the SQL statement executes successfully):
String ls_sqlstatement
Integer Li_count = 0
ls_sqlstatement = "Select emp_id from Employee"
Prepare Sqlsa from:ls_sqlstatement;
Descrobe Sqlsa into SQLDA;
Declare my_cursor Dynamic cursor for SQLSA;
Open Dynamic my_cursor Using descriptor SQLDA;
Fetch my_cursor Using Descriptor SQLDA;
If Sqlca.sqlcode =
MessageBox ("Hint", "No data Found!") ")
Close my_cursor;
Return
End If
Do
Li_count + +
When the FETCH statement executes successfully, the dynamic description area Sqlda contains the first row of data for the result set
, the remaining data can be obtained by executing the FETCH statement repeatedly.
SQLDA. The number of output parameters is included in the numoutputs.
SQLDA. The Outparmtype array contains data types for each parameter, such as typeinteger!, etc.
Use the Choose Case statement to invoke different object functions for different output parameter types to get
The value of the corresponding parameter.
Choose Case SQLDA. OUTPARMTYPE[1]
Case typestring!
Stringvar = getdynamicstring (sqlda,1)
Case typeinteger!
Intvar = Getdynamicnumber (sqlda,1)
End Choose
Loop while Li_count <> SQLDA. Numoutputs
Close my_cursor;

* See Help for details

----------------------------------------------------------------
To use a cursor step:
1) Defining Cursors
DECLARE CURSOR cursor name for
Select field name from table name
Where condition expression {using Transaction object};
2) Open cursor
Open cursor name;
The corresponding return result is saved in the cursor after the cursor is opened
3) Read data
Fetch cursor name into: variable list;
4) Close the cursor
Close cursor name;
When iterating over a cursor, it is possible to know whether all the data has been processed by judging the parameters of the transaction object. That is, the parameter sqlcode of the transaction object determines whether all the data is processed.
Fetch ...;
Do While Salca.sqlcode = 0
//
Fetch ...;
Loop

For li_index = 1 to Sqlca.sqlnrows
//
Fetch ...;
Next

----------------------------------------------------------------
The transaction object is the equivalent of a liaison, dedicated to powerbuilder the communication between the application and the database. Before accessing a database, you must first establish a transaction object, establish a junction through the transaction object and the database, and then work with the database, all of which are related to the data through this liaison. A transaction is a concept that is closely related to a transactional object, which is the smallest unit of work for a transactional object, consisting of one or more SQL statements. All the SQL statements in a transaction are executed correctly, the entire transaction is committed, and as long as there is an SQL statement failure, the previous action in the transaction is undone and returned to the state where the transaction started. Transaction processing is done through transactional objects and related SQL statements.

PowerBuilder, there are 4 SQL statements dedicated to transaction processing, which are connect,disconnect,commit and rollback, respectively, responsible for establishing joins, disconnecting, committing, and fallback transactions for the database. Before retrieving the data window or executing the SQL statement, you should first use the Connect statement and the database to establish the correct join; when all database-related operations are complete, you can use the Disconnect statement and the database to break the join. Commit is used to commit a transaction, and rollback is used to rollback a transaction. These four transaction management statements are in a similar format as follows:
Statement {using Transaction};
Where statement represents any of the four words, transaction is the name of the transaction object, and if omitted, the default global transaction object SQLCA is used. Programmers can also declare variables of their own type of transaction object. If you use a transaction object that you declare, you should create the object after the declaration using the CREATE statement, and then execute the destroy statement to destroy the custom transaction object after you have finished using it. and a using transaction clause is added to the SQL statement that involves the transaction object. Here is a complete example of using a custom transaction object:
(1) Declare global variables: Transaction MY_SQLCA.
(2) Write the following script in the Open event of the Application object:
MY_SQLCA = Create transaction//Creating Transaction Object
The following statement assigns a value to a member variable in a transaction object
My_sqlca.dbms =profilestring ("PB. INI "," Database "," DBMS "," ")
My_sqlca.database =profilestring ("PB. INI "," Database "," Database "," "")
....//Set other parameters for the transaction object My_sqlca.
Connect using My_sqlca; Join database
If My_sqlca.sqlcode=0 then//determine if the connection is correct
Open (W_main)//Correct connection opens the main window
else//otherwise
MessageBox (String (My_sqlca.sqlcode), "Cannot join database!") Display error message
Halt Close; Close the app
End If
(3) Release the transaction object in the Close event of the Application object and write the following script:
Disconnect Using My_sqlca; disconnecting from and connecting to a database
Destroy My_sqlca; Releasing a Transaction object
After you establish a join with the database, you can complete the operation of the database and execute commit or rollback. Closes the old transaction after each commit or rollback, and begins a new transaction. During a transactional process, the application controls the database and the DBMS locks the data in the database according to a mechanism. If the duration of a transaction is too long, it can cause a lot of problems. For example, for a typical production system, transaction log dumps are automatically or manually performed on a daily basis. If a client application of that system is running all day and only read-only queries, the transaction is always active after a transaction is started using the Connect statement, and any attempt to dump or truncate the log will not take effect, resulting in a full database problem. Therefore, PowerBuilder provides a member variable for the transaction object that can choose to commit the transaction automatically, that is, autocommit, setting this argument to True to end a transaction by automatically executing a commit after each statement that the transaction object contains. Another workaround is for developers to explicitly manage transactions by using Transaction management statements in the script, which requires a better understanding of the transaction.

A data window is a primary control that works with a database, and you must first set up the transaction object correctly for the Data window control before you perform the function of the Data window. Typically, the transaction object is set using the function Settrans or settransobject before the data is retrieved. With different functions, the data window transaction is handled differently. The syntax format for the function Settrans is as follows:
Dwcontrol. Settrans (transaction)
Where Dwcontrol is the Data window control name of the transaction object to set, transaction is the transaction object name. Returns 1 if the function is executed correctly, otherwise returns-1, or null if any argument is null. The function Settransobject and the function's format, parameters and return values are exactly the same.
function Settrans After the transaction object is set, the data window can automatically manage transaction processing, and transaction management is performed automatically after each function or statement that is contained in the transaction. After the function Settransobject sets the transaction object, the transaction of the data window is controlled by the script, unless the AUTOCOMMIT member variable of the transaction object is set to true before the connection to the database is established. Although the data window's automatic transaction processing can save some of the script about transaction processing, it also brings a lot of potential dangers. The database is automatically joined each time a retrieval or modification is performed, and the disconnect is executed automatically after execution, eliminating the need to perform connect,commit,rollback or disconnect. Any error during execution causes the rollback to be executed automatically, and the script has no choice but to control transaction processing. In applications where the connection to the database is very few and can be automatically transacted by the system, the function Settrans is used to set the transaction object to the Data window control. Typically, setting a transaction object with Settransobject can make the data window more efficient to perform. We recommend that you use Settransobject to set the transaction object for the Data window control.
In addition, the function Settranspool can set transactional object sharing and also affect the processing of transactions. You can use this function to maximize the throughput of a database and to control the maximum number of simultaneous open database joins. If a transactional object share is set in the application, when a database join is made using a transactional object, the system first checks to see if there is a transaction object that has exactly the same value as the transaction object member variable to be used. If present, there is no need to re-create the transaction object, take advantage of the existing transaction object, and when there is a transactional object share, executing a COMMIT statement will not actually terminate a transaction physically, but only logically terminate the transaction. The transaction object is re-enabled when a new transaction with the same value is established. The syntax format for this function is:
ApplicationName. Settranspool (minimum, maximum, timeout)
Where ApplicationName is the name of the Application object, and minimum and maximum are the minimum and maximum number of transaction objects to be guaranteed to open in the transaction object pool, minimum must be less than or equal to maximum Timeout is the maximum wait time when a database join is established, and returns an error message if the join is not successfully established at that time. Returns 1 if the function executes correctly, otherwise returns-1. Here is an example of the function:
Getapplication (). Settranspool (12,16,10)
The above statement first uses the function getapplication to get the current application object, and then sets the transaction object share to the Application object, with a minimum of 12 open transaction objects, up to 16, and a maximum wait time of 10 seconds for the join.
It is recommended that you use this function before a database join, usually in the Open event of the Application object, to first use the function to establish a transactional object share, and then create the transaction object to use, and join the database. When you need to maintain multiple joins in your application and contain a large number of short transactions that access the same data source, using this function to create a transactional object share can improve the efficiency of your application execution. The following is a script that creates a transactional object share in the Application object's Open event:
If getapplication (). Settranspool (12,16,10) <> 1 Then
MessageBox ("Hint", "Error!") ")
Halt Close;
Else
SQLCA. Dbms=profilestring ("PB. INI "," Database "," DBMS "," ")
SQLCA. Database=profilestring ("PB. INI "," Database "," Database "," "")
...//Set other SQLCA member variable values
Connect; Join using the SQLCA transaction object
If SQLCA. SQLcode = 0 Then//join succeeded
Open (W_main)//Opening main action window
Else//Junction not successful displays error message
Messagebox ("Error!", String (SQLCA. Sqldbcode) + "~r~n" + SQLCA. Sqlerrtext)
Halt Close; Shut down application software
End If
End If

In the above script, if the transaction object share is established correctly and the connect is performed correctly, the system automatically opens 12 transaction objects.

----------------------------------------------------------------
There are 5 tables in the PowerBuilder database to record information about other tables in the database, and the 5
Tables are automatically maintained by the PowerBuilder, which is usually referred to as the warehouses of the PowerBuilder 5 tables. This warehouse allows to receive
Set and maintain extended column properties.
PBCATTBL records information about tables in the current database
Pbcatcol to record information about columns in individual tables
Pbcatedt Editing styles
PBCATFMT Display Style
PBCATVLD validation Rules

When you create a data table using PowerBuilder, PowerBuilder can automatically maintain these 5 tables. When you create a datasheet with a tool other than PB, the information for the new data table is not automatically added to the warehouse, and many developers ' errors are to manually enter the information into the warehouse. The correct action should be to perform the Synch Extended attributes menu item under the Design menu of the database artboard so that the warehouse can be updated automatically. There are two tables that are frequently used in programming, that is, the pbcattbl that holds the table information and the Pbcatcol that holds the field information.
PBCATTBL: Where Pbt_tname is used to store other table names, PBT_OWNR is used to store the table's owner, PBT_CMNT is used to store the table's annotations, which are used frequently during programming, and are rarely used in other fields. Using these three fields, you can extract all the tables in the system, in order to construct a more friendly interface, the content that is displayed to the user is generally in field pbt_cmnt, and the table's index is based on the fields Pbt_tnam and PBT_OWNR.
Pbcatcol: Where Pbc_tnam is used to store the table name, PBC_OWNR is used to hold the table owner, Pbc_cid is the record field creation order, Pbc_cnam to hold the field name, Pbc_labl to hold the label of the field, PBC_ Cmnt the comment used to store the field. These fields are often used during programming, where pbc_cmnt is often displayed in the user interface.

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