PB Database Related

----------------------------------------------------------------
Database artboards:
A table that defines a primary key or a unique index enables you to change, add, and delete data in the results window.

Using SQL statements to create a data table is the quickest way. However, PB at the same time when creating a data table, to include information about the data table in the System data table, the table and the extended properties of the 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 form menu design to correct these incomplete. In fact, the incomplete system tables do not have a lot of side effects, especially if you do not use system table coding.

Extended Properties of the table:
Set the related properties in the related property pages. You can set the gaze information of 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 an artboard, or retrieve data in a data form. The Heading Font property page is used to set the display style of the header in the data form 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 form of the freeform display style.

Extended Properties for fields:
Set the related properties in the corresponding property page. The General property page is used to set the gaze information for a field (the tag of the data form object, which is now in the field description of the table). The Headers property page is used to set the header in the data form for freeform, which displays styles in the data form Label,tabular,grid and n-up display styles (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 form object is made. The Display property page is used to set the style of the field, including the width of the data in the field, the height, whether it is displayed as a picture, whether or not to add a certain mark (for example, whether to join ￥ 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 form must be able to be received through this validation rule. For example, the ability to specify that the data entered on the salary (payroll) field should be within a range, assuming that it is not within that range, is not received. The Editstyle property page is used to set the editing style when the field is edited in the data form, such as the ability to use the radio button to allow the user to edit the field's data.

can open two Columns (view->columns) at the same time, 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 that includes 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 datasheet, 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 data form that has dependencies 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 longer time, you can right-click the window blank and use arrange tables in the pop-up menu to arrange the layout of the data form.

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 transactional object can only connect to a database at a time, defining multiple transaction objects to be able to connect to and from 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 a transaction (SQLCA) and then altering the data, assuming commit, the changes are permanently preserved, and the database management system will discard all changes, assuming fallback (rollback). Back to the state at the start of the transaction.

----------------------------------------------------------------
The transaction object contains 15 parameters: (5 status information to return the operation, and 10 other 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}; Connect to the database and, when connected, can infer whether the database is connected correctly based on 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;
Changes:
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;

----------------------------------------------------------------
The ability to run arbitrary database operations with the Execute immediate command. --Dynamic SQL statements
Edit a database directive into a string that you can run regardless of 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 contain variables and so on, just to finally be an SQL statement can
Note: if, Sqlca.autocommit = True, you commit the transaction on your own initiative, you do not need the following if ...

----------------------------------------------------------------
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 the result set are already 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 used frequently to run 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's a sample to create a delete data table:
String MySQL = "DROP table employee"
EXECUTE immediate:mysql USING SQLCA;
* Best to use such as 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

A dynamic SQL statement that uses such a type before executing a known number of parameters and no return value. A dynamic SQL statement of this type can also handle data manipulation statements that need to define the parameters at execution 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 number, 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 name of the transaction object, curly braces indicate that the clause can be omitted, and when omitted, use Sqlca A paramenterlist is a list of variables, constants, or properties of a control, corresponding to the question mark in SQLStatement. The dynamic policy area is used to prepare the SQL statement and the required number of arguments, and its properties are not available to the application at execution time, 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

Such a type of dynamic SQL statement may be used only after the first type, it is often used to handle 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 formatted and ordered in a similar way to the syntax above, simply by using the EXECUTE statement instead of the open statement, which has the following syntax:
DECLARE Procedure DYNAMIC Procedure for Dynamicstagingarea;
PREPARE Dynamicstagingarea from Sqlstatement{using transactionobject};
Exectue DYNAMIC procedure{using Parameterlist};
FETCH Procedure into hostvariablelist;
CLOSE Procedure;
The cursor and procedure are respectively cursor names and process names; Dynamicstagingarea is a dynamic policy area variable, usually using a system-defined 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 the question marks corresponding to the 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 runs a dynamic process, and a fetch statement reads a row of data, assuming that multiple rows of data need to be read, then the FETCH statement needs to be run repeatedly. Finally, the close statement closes the dynamic cursor or dynamic procedure. The FETCH statement and the close statement are used in the same way as described in the previous section. Here is an example of an application of the third 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 demo sample omits the necessary SQL statement run-state checks, and when the code is actually tapped, the Sqlcode property of the transaction object should be checked to infer the success of the SQL statement, except for the Declare statement, after the other SQL statements have been run.
Using a dynamic SQL statement of this type can 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)
Number of Fo_obj: drop-down list box, fs_sql as SQL statement
return value: None
Function: Add data to the specified drop-down list box using the SQL statement specified by the number of parameters
////////////////////////////////////
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 join the project
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 can handle SQL statements that do not know the parameters and result sets 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 one for stored procedures where the difference is to use the Open statement 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;
The cursor and procedure are respectively cursor names and process names; Dynamicstagingarea is a dynamic policy area variable, usually using a system-defined 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 number of arguments; Dynamicdescriptionarea is a dynamic description of the narrative area variable, which is specifically used to describe the input and output parameters of the fourth class of dynamic SQL statements, The global variable sqlda;transactionobject, which is usually defined in advance by the system, is the transaction object name, using SQLCA by default. The fourth dynamic SQL statement uses the dynamic descriptive narrative area object variable, through which four attributes Numinputs,inparmtype, numoutputs and Outparmtype can get input parameters, input parameter type, The output parameters and the output parameter type information, in which Inparmtype is the array, 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, and the values range from the values listed in the applicable parameter types column below:
The type of parameter that the function name applies To
Getdynamicnumber () typeinteger!, typedecimal!, typedouble!,
typelong!, typeteal!, typeboolean!,
typeunsingedinteger!, typeunsignedlong!
Getdynamicstring () typestring!
Getdynamicdate () typedate!
Getdynamictime () typetime!
Getdynamicdatetime () typedatetime!
Set the detailed input parameters by using the function setdynamicparm () of the object variable. The value of the output parameter (which is actually the return data of the SQL statement) is given by the above object function, each of which is for a specific data type.
The order of the statements in the syntax format of the fourth dynamic SQL statement is very important, only when the previous statement runs successfully, the latter statement is meaningful, so, in addition to the Declare statement, the Sqlcode property of the transaction object should be checked after the other statement is run. To infer whether the current SQL statement is running successfully. By calling the FETCH statement, you can read multiple data, after each reading of a piece of data, usually in a circular statement using the Choose Case to determine the type of output parameters and then use the corresponding function above to get its value. The following is an example of an application demonstration of the fourth class of dynamic SQL statements, omitting the process of checking the Sqlcode property of the transaction object that must be present in actual programming (that is, checking that the SQL statement is running 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 runs successfully, the first row of the result set is included in the dynamic descriptive narrative area Sqlda
, you can get the rest of the data by running the FETCH statement repeatedly.
SQLDA. The number of output parameters is included in the numoutputs.
SQLDA. The Outparmtype array includes data types for each of the parameters, 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 number of parameters.
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 a cursor is looped, the parameters of the transaction object are inferred to know whether to process the total data. That is, the sqlcode of the transaction object to infer whether the data of the total part 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 visiting the database, you must first establish a transaction object, establish a junction through the transaction object and the database, then the ability to work with the database, all and data related operations are 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 SQL statements in a transaction run correctly, and the entire transaction is successfully committed, with only one SQL statement failing, and the previous actions in the transaction are undone, again returning 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 you can retrieve a data form or run an SQL statement, you should first use the Connect statement and the database to establish the correct join, and when all the database-related operations are complete, you will be able to 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 seen in the following:
Statement {using Transaction};
, statement represents the random one in four words, transaction is the name of the transaction object, assuming omitted, the default global transaction object SQLCA is used. Program apes can also declare their own variables for the type of transaction object. If you use a transaction object that you declare, you should create the object using the CREATE statement after the declaration, and then destroy your own defined transaction object by running the destroy statement after completion. and the Using transaction clause is added to the SQL statement that involves the transaction object. The following is a complete example of a transaction object that uses its own definition:
(1) Declare global variables: Transaction MY_SQLCA.
(2) Write a script such as the following 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//inference is correctly joined
Open (W_main)//Correct join opens main form
else//otherwise
MessageBox (String (My_sqlca.sqlcode), "Cannot join database!") Display error message
Halt Close; Close the app
End If
(3) Dispose of the transaction object in the Close event of the Application object, writing such as the following script:
Disconnect Using My_sqlca; disconnecting from and connecting to a database
Destroy My_sqlca; Releasing a Transaction object
After establishing a join with the database, you can complete the operation of the database and run commit or rollback. Close the old transaction after each commit or rollback, and start the new transaction processing. In a transaction process, the application controls the database and the DBMS locks the data in the database based on a mechanism. Assuming a transaction lasts too long, it can cause a lot of problems. For example, for a typical production system, the transaction log dumps are carried out voluntarily or manually on a daily basis. Assuming that a certain type of client application of the system runs all day and only reads queries only, then the transaction is always activated after a transaction is started using the Connect statement, and the attempt to dump or truncate the log will not take effect and will eventually result in a full database problem. Therefore, PowerBuilder gives the transaction object a member variable that can choose to commit the transaction itself, that is, autocommit, setting the argument to True to end a transaction by running the commit itself after each statement that the transaction object includes. The second solution 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 form is a primary control that works with a database, and you must first set up the transaction object correctly for the data form control before you run the data form's functionality. Typically, the transaction object is set using the function Settrans or settransobject before the data is retrieved. With different functions, the data form has a different transaction method. The syntax format for the function Settrans is as follows:
Dwcontrol. Settrans (transaction)
Dwcontrol is the data form control name of the transaction object to set, and transaction is the transaction object name. Returns 1 if the function is running correctly, otherwise returns-1, or null if the discretionary number of parameters is null. The function Settransobject and the function's format, the parameters and the return value are exactly the same.
function Settrans After the transaction object is set, the data form can proactively manage the processing of the transaction, and each feature or statement included in the transaction is run on its own initiative for transaction management. After the function Settransobject sets the transaction object, the transaction of the data form 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 form's own proactive transaction can save some script on transaction processing, it also brings a lot of potential criticality. Each time you run a search or change, and so on, you actively join the database, after running the disconnect itself, no longer need to run Connect,commit,rollback or disconnect. No matter what error in the running process will cause yourself to run rollback, the script has no choice for the transaction and cannot control transaction processing. When the connection to the database is very few in the application system and can be transacted by the system itself, the function Settrans is used to set the transaction object to the data form control. Typically, using Settransobject to set transaction objects can make data forms more efficient to run. We recommend that you use Settransobject to set the transaction object for the data form control.
In addition, the function Settranspool can set the transaction object sharing, also affects the transaction processing. You can use this function to maximize the throughput of a database and to control the maximum number of database joins that are open at the same time. Assuming 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 with the same value as the transaction object member variable to be used. If there is, there is no need to create the transaction object again, take advantage of the already existing transaction object, and when there is a transactional object share, running the commit statement will not actually terminate the transaction physically, but only logically terminate the transaction. When a new transaction with the same value is established, the transaction object is enabled again. The syntax format for this function is:
ApplicationName. Settranspool (minimum, maximum, timeout)
, 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 is running 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, typically 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 include a large number of short transactions that access the same data source, using this function to create transactional object sharing can improve the efficiency of your application. 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 form
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, assuming that the transaction object share is properly established and that the connect is running correctly, the system proactively opens 12 transaction objects.

----------------------------------------------------------------
There are 5 tables in the PowerBuilder database to record information about other tables in the database, and this 5
Tables are actively maintained by the PowerBuilder themselves, usually referred to as the warehouses of the PowerBuilder 5 tables. The warehouse agreed 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 proactively maintain these 5 tables. When creating a data table with a tool other than PB, the information in the new data table is not actively added to the warehouse itself, so many developers are making the mistake of manually entering the information into the warehouse. The correct operation should be the Synch Extended attributes menu item under the Design menu running the database artboard so that the warehouse can proactively update itself. There are two tables that are often used in programming, the PBCATTBL that holds the table information, and the pbcatcol that holds the field information.
PBCATTBL: Pbt_tname is used to store other table names, PBT_OWNR is used to store the table's owner, PBT_CMNT is used to hold the table gaze, these three fields are often used in programming, other fields are very rarely used. Using these three fields to extract all the tables in the system, in order to construct a friendlier interface, the content that is usually displayed to the user is in the field pbt_cmnt, and the table's index is based on the fields Pbt_tnam and PBT_OWNR.
Pbcatcol: Pbc_tnam used to store the table name, PBC_OWNR used to store 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 gaze used to hold the field. These fields are often used in programming, where pbc_cmnt is often displayed in the user interface.

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

PB Database Related