10.2.1 Keeping Track of PL/SQL Keywords

Well, if PLVcase is going to uppercase only keywords, it has to know which identifiers in a PL/SQL program are the reserved words. This information is maintained in the PLV_token table, which has the following structure:

 Name                            Null?    Type
 ------------------------------- -------- ----
 TOKEN                           NOT NULL VARCHAR2(100)
 TOKEN_TYPE                               VARCHAR2(10)

where the token column is the identifier and token_type indicates the type.

The different token types in the PLV_token table are stored in the PLV_token_type table, which has this structure:

 Name                            Null?    Type
 ------------------------------- -------- ----
 TOKEN_TYPE                               VARCHAR2(10)
 NAME                            NOT NULL VARCHAR2(100)

The contents of the PLV_token_type are explained in the following table:

Token Type	Name	Description
B	BUILT-IN	Builtin functions and procedures of the PL/SQL language, including packaged builtins.
D	DATATYPE	Different datatypes of the PL/SQL language, such as INTEGER and VARCHAR2.
DD	DATA-DICTIONARY	Views and tables from the Oracle Server data dictionary, such as ALL_SOURCE and DUAL.
E	EXCEPTION	Predefined system exceptions such as ZERO_DIVIDE.
OF	ORACLE-FORMS	Reserved words from the Oracle Forms product set
S	SYMBOL	Symbols like + and =.
SQL	SQL	Elements of the SQL language. In many cases, SQL tokens are used in PL/SQL and also in Oracle Developer/2000. These are still listed as SQL tokens.
X	SYNTAX	Syntax elements of the PL/SQL language, such as AND or LIKE.

There is a row in PLV_token for each reserved word in PL/SQL . You can change the contents of this table if you want. You might, for example, want to add keywords for the Oracle Developer/2000 builtins or the Oracle Web Agent PL/SQL packages. You can even add your own application-specific identifiers to the table. As long as the token type you assign is not any of those listed above, PL/Vision will not misinterpret your entries.

There are currently 1,235 rows in the PLV_token table, broken down by token type as follows:

Token Type	Count
BUILT-IN	198
DATATYPE	22
DATA-DICTIONARY	168
EXCEPTION	15
ORACLE-FORMS	623
SYMBOL	32
SQL	94
SYNTAX	83

From the PL/SQL side of things, the PLVtkn package provides an interface to the PLV_token table. This package is used by PLVcase to determine the case of an individual token according to the UPPER-lower method.

As you will soon see, PLVtkn is not a particularly large or complicated package. Its purpose in life is to consolidate all of the logic having to do with individual PL/SQL tokens, particularly regarding keywords. By hiding the implementation details (the name and structure of the PLV_token table, the particular values used to denote a symbol or syntax element or builtin function), PLVtkn makes it easier for developers to apply this information in their own programs.

10.2.2 Determining Token Type

PLVtkn provides a set of functions you can use to determine a string's token type in PL/SQL . The headers for these functions are shown below:

FUNCTION is_keyword

 
   (token_in IN VARCHAR2, type_in IN VARCHAR2 := c_any) RETURN BOOLEAN;

FUNCTION is_syntax

 (token_in IN VARCHAR2) RETURN BOOLEAN;
FUNCTION is_builtin

 (token_in IN VARCHAR2) RETURN BOOLEAN;
FUNCTION is_symbol

 (token_in IN VARCHAR2) RETURN BOOLEAN;
FUNCTION is_datatype

 (token_in IN VARCHAR2) RETURN BOOLEAN;
FUNCTION is_exception

 (token_in IN VARCHAR2) RETURN BOOLEAN;

All of the functions except for is_keyword take a single string argument and return TRUE if the string is that type of token. The following examples illustrate the way the PLVtkn functions interpret various strings:

SQL> exec p.l(PLVtkn.is_builtin('to_char'));
TRUE
SQL> exec p.l(PLVtkn.is_builtin('loop'));
FALSE
SQL> exec p.l(PLVtkn.is_syntax('loop'));
TRUE
SQL> exec p.l(PLVtkn.is_syntax('='));
FALSE
SQL> exec p.l(PLVtkn.is_symbol('='));
TRUE

10.2.3 Retrieving Information About a Token

You will use the get_keyword procedure to retrieve from the PLV_token table all information stored about a particular token. The header of this procedure is:

   PROCEDURE get_keyword (token_in IN VARCHAR2, kw OUT kw_rectype);

You provide the token or string and get_keyword returns a PL/SQL record, which is a translated version of the row in the table. The translation generally involves converting string constants to Boolean values. For example, one of the record's fields is named is_keyword . The expression assigned to this Boolean field is:

   kw.is_keyword := 
      kw_rec.token_type IN 
         (c_syntax, c_builtin, c_symbol,
          c_sql, c_datatype, c_datadict, c_exception);

where kw_rec is the cursor-based record into which the PLV_token row is fetched.

The anonymous block below shows how to use get_keyword . It accepts a string from the user of this script ( plvtkn.tst ), retrieves the information about that string (as a token), and displays some of the data.

DECLARE
   my_kw PLVtkn.kw_rectype;
BEGIN
   PLVtkn.get_keyword ('&1', my_kw);
   p.l (my_kw.token_type);
   p.l (my_kw.is_keyword);
END;
/

The lines below show this script being executed for the THEN keyword.

SQL> @plvtkn.tst then
X
TRUE