#ifndef DSRI_H
#define DSRI_H

/*
 *	DSRI.H: Generated Fri Mar 26 14:41:00 2010
 *	GENERATED FILE.  PLEASE DO NOT EDIT.
 */

/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 * D S R I _ D E F I N I T I O N S 
 * Copyright (c) 1984 through 2010 
 * by 
 * Oracle Corporation, Redwood Shores, Ca.  U.S.A. 
 * This software is furnished under a license and may be used and  copied 
 * only  in  accordance  with  the  terms  of  such  license and with the 
 * inclusion of the above copyright notice.  This software or  any  other 
 * copies  thereof may not be provided or otherwise made available to any 
 * other person.  No title to and ownership of  the  software  is  hereby 
 * transferred. 
 * The information in this software is subject to change  without  notice 
 * and should  not be  construed  as  a commitment by Oracle Corporation. 
 *    ABSTRACT 
 *	These are the values that are defined by the DSRI architecture. 
 *	They include the binary language representation (BLR), 
 *	metadata binary language representation (MBLR), parameter 
 *	blocks, information calls and other things. 
 *--------------------------------------------------------------------------- 
 */






/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_<whatever> 
 *   This section contains the vakues for all the RDB_K_<whatever> values 
 *--------------------------------------------------------------------------- 
 */

/*
 * These are the general limits established by the architecture 
 */
#define RDB_K_MAX_SYNONYM_CHAIN           64
#define RDB_K_MESSAGE_VECTOR_SIZE         20

/*
 * Define the values for RDB_SYSTEM_FLAG 
 */
#define RDB_K_SYSFLG_USER                 0
#define RDB_K_SYSFLG_SYSTEM               1
#define RDB_K_SYSFLG_LAYERED              2


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_DB_TYPE_<mumbo> 
 *   This section contains the values for the database types.  The values are u 
 *   mainly at create, attach, change and delete database time. 
 *--------------------------------------------------------------------------- 
 */

#define RDB_K_DB_TYPE_UNKNOWN             0
#define RDB_K_DB_TYPE_MIN                 1
/* Rdb */
#define	RDB_K_DB_TYPE_VMS                 1
#define	RDB_K_DB_TYPE_DECRDB              RDB_K_DB_TYPE_VMS
#define	RDB_K_DB_TYPE_RDB                 RDB_K_DB_TYPE_VMS
/* Rdb/ELN */
#define	RDB_K_DB_TYPE_ELAN                2
/* VIDA for IDMS/R */
#define	RDB_K_DB_TYPE_VIDA                3
/* RdbAccess for DB2 */
#define	RDB_K_DB_TYPE_VIDA2               4
/* RdbAccess for Oracle */
#define	RDB_K_DB_TYPE_VIDAO               5
/* RdbAccess for RMS */
#define	RDB_K_DB_TYPE_NSDS                6
/* Data Access Facility */
#define	RDB_K_DB_TYPE_DAF                 RDB_K_DB_TYPE_NSDS
/* Internal testing */
#define	RDB_K_DB_TYPE_BRIDGE              7
/* DB Integrator */
#define	RDB_K_DB_TYPE_DBI                 8
/* RdbAccess for EDA/SQL */
#define	RDB_K_DB_TYPE_EDASQL              9
/* RdbAccess for SQL400 */
#define	RDB_K_DB_TYPE_SQL400              10
/* RdbAccess for SQL Access */
#define	RDB_K_DB_TYPE_SQLACC              11
/* RdbAccess for Sybase */
#define	RDB_K_DB_TYPE_SYBASE              12
/* RdbAccess for ORACLE */
#define	RDB_K_DB_TYPE_ORACLE              13
/* RdbAccess for DB2 */
#define	RDB_K_DB_TYPE_DB2                 14
/* DB Integrator Gateway for Sequelink (SQLNK) */
#define	RDB_K_DB_TYPE_SQLNK               15
/* DB Integrator Gateway for PC Data (ODBC) */
#define	RDB_K_DB_TYPE_ODBC                16
/* DB Integrator Gateway for RMS and Custom Drivers (NREL) */
#define	RDB_K_DB_TYPE_NREL                17

#define	RDB_K_DB_TYPE_MAX                 17


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_FACILITY_<mumbo> 
 *   This section contains the facility values for the database systems. 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_FACILITY_ALL                0
#define	RDB_K_FACILITY_RDB_VMS            1
#define	RDB_K_FACILITY_DECRDB             RDB_K_FACILITY_RDB_VMS
#define	RDB_K_FACILITY_RDB                RDB_K_FACILITY_RDB_VMS
#define	RDB_K_FACILITY_RDB_ELN            2
#define	RDB_K_FACILITY_VIDA               3
#define	RDB_K_FACILITY_VIDA2              4
#define	RDB_K_FACILITY_VIDAO              5
#define	RDB_K_FACILITY_NSDS               6
#define	RDB_K_FACILITY_DAF                RDB_K_FACILITY_NSDS
#define	RDB_K_FACILITY_BRIDGE             7
#define	RDB_K_FACILITY_DBI                8
#define	RDB_K_FACILITY_EDASQL             9
#define	RDB_K_FACILITY_SQL400             10
#define	RDB_K_FACILITY_SQLACC             11
#define	RDB_K_FACILITY_SYBASE             12
#define	RDB_K_FACILITY_ORACLE             13
#define	RDB_K_FACILITY_DB2                14
#define	RDB_K_FACILITY_SQLNK              15
#define	RDB_K_FACILITY_ODBC               16
#define	RDB_K_FACILITY_NREL               17


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_SECURE_<mumbo> 
 *   RDB_K_SECURE_FAC_<mumbo> 
 *   This section contains the security facility values. 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_SECURE_VERSION1             1
#define	RDB_K_SECURE_VERSION2             2

#define	RDB_K_SECURE_FAC_UNKNOWN          0
#define	RDB_K_SECURE_FAC_VMS              1
#define	RDB_K_SECURE_FAC_DECRDB           RDB_K_SECURE_FAC_VMS
#define	RDB_K_SECURE_FAC_RDB              RDB_K_SECURE_FAC_VMS
#define	RDB_K_SECURE_FAC_ELN              2
#define	RDB_K_SECURE_FAC_REMOTE           3
#define	RDB_K_SECURE_FAC_VIDA             4
#define	RDB_K_SECURE_FAC_VIDA2            5
#define	RDB_K_SECURE_FAC_VIDAO            6
#define	RDB_K_SECURE_FAC_NSDS             7
#define	RDB_K_SECURE_FAC_DAF              RDB_K_SECURE_FAC_NSDS
#define	RDB_K_SECURE_FAC_BRIDGE           8
#define	RDB_K_SECURE_FAC_DBI              9
#define	RDB_K_SECURE_FAC_EDASQL           10
#define	RDB_K_SECURE_FAC_SQL400           11
#define	RDB_K_SECURE_FAC_SQLACC           12
#define	RDB_K_SECURE_FAC_SYBASE           13
#define	RDB_K_SECURE_FAC_ORACLE           14
#define	RDB_K_SECURE_FAC_DB2              15
#define	RDB_K_SECURE_FAC_SQLNK            16
#define	RDB_K_SECURE_FAC_ODBC             17
#define	RDB_K_SECURE_FAC_NREL             18

#define	RDB_K_SECURE_MIN                  1
#define	RDB_K_SECURE_USER_NAME            1
#define	RDB_K_SECURE_USER_PWD             2
#define	RDB_K_SECURE_CONNECTION_NAME      3
#define	RDB_K_SECURE_CANCEL_CONNECTION    4
#define	RDB_K_SECURE_OVERRIDE_PRIVS       5
#define	RDB_K_SECURE_REFRESH_UIC          6

#define	RDB_K_SECURE_MAX                  6


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_HANDLE_<mumbo> 
 *   This section contains the handle values. 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_HANDLE_MIN                  1
#define	RDB_K_HANDLE_DATABASE             1
#define	RDB_K_HANDLE_TRANSACTION          2
#define	RDB_K_HANDLE_REQUEST              3
#define	RDB_K_HANDLE_SEGMENTED_STRING     4
#define	RDB_K_HANDLE_MARKPOINT            5
#define	RDB_K_HANDLE_NOTREQUIRED          6
#define	RDB_K_HANDLE_MAX                  6

/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_PLTFRM_<mumbo> 
 *   This section contains the platform values. 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_PLTFRM_MIN                  0
#define	RDB_K_PLTFRM_VMS                  0
#define	RDB_K_PLTFRM_UNIX                 1
#define	RDB_K_PLTFRM_WNT                  2

#define	RDB_K_PLTFRM_MAX                  2


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_CALLBACK_<mumbo> 
 *   This section contains the callback values. 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_CALLBACK_MIN                0
/* The value zero is the initial value and should never be seen by SQL */
#define	RDB_K_CALLBACK_UNKNOWN            0
/* The transaction ended with a sucessful COMMIT */
#define	RDB_K_CALLBACK_COMMITTED          1
/* The transaction ended with a successful ROLLBACK */
#define	RDB_K_CALLBACK_ROLLEDBACK         2
/* The transaction ended with either a ROLLBACK (such as after constraint */
/* failure) or with a 2PC failure.  Whether the ultimate resolution is */
/* COMMIT or ROLLBACK can not be determined */
#define	RDB_K_CALLBACK_FAILED             3

#define	RDB_K_CALLBACK_MAX                3

/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 * RDB_K_PROFILE_<mumbo> 
 * This section contains the special values stored in RDB_PROFILE_TYPE 
 * column in the RDB_PROFILES table 
 * Note: RDB_K_PROFILE_UNKNOWN indicates that the target is either 
 * a role (RDB_K_PROFILE_ROLES) or a user (RDB_K_PROFILE_USERS) and that 
 * the engine should make the determination from the operating system. 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_PROFILE_MIN                 0

#define	RDB_K_PROFILE_QUOTAS              0
#define	RDB_K_PROFILE_ROLES               1
#define	RDB_K_PROFILE_DEFAULT_ROLES       2
#define	RDB_K_PROFILE_USERS               3
#define	RDB_K_PROFILE_UNKNOWN             4

#define	RDB_K_PROFILE_MAX                 4

/*
 * These literals are reserved values for users (database creator, 
 * DEFAULT, PUBLIC) and roles (BATCH, DIALUP, INTERACTIVE, NETWORK, LOCAL 
 * and REMOTE) 
 */
#define	RDB_K_PRF_DB_CREATOR_ID           1
#define	RDB_K_PRF_DEFAULT_ID              2
#define	RDB_K_PRF_PUBLIC_ID               1073741823	/* %X3FFFFFFF */
#define	RDB_K_PRF_BATCH_ID                -2147483647	/* %X80000001 */
#define	RDB_K_PRF_DIALUP_ID               -2147483646	/* %X80000002 */
#define	RDB_K_PRF_INTERACTIVE_ID          -2147483645	/* %X80000003 */
#define	RDB_K_PRF_LOCAL_ID                -2147483644	/* %X80000004 */
#define	RDB_K_PRF_NETWORK_ID              -2147483643	/* %X80000005 */
#define	RDB_K_PRF_REMOTE_ID               -2147483642	/* %X80000006 */

/*
 * These values define the bit mapping for the profile privilege masks 
 *        
 */
/* Symbolic name			Value */
/* -------------			----- */
#define	RDB_K_PRF_ALL                     0
#define	RDB_K_PRF_ANY_CATALOG             1
#define	RDB_K_PRF_ANY_COLLATION           2
#define	RDB_K_PRF_ANY_FIELD               3
#define	RDB_K_PRF_ANY_FUNCTION            4
#define	RDB_K_PRF_ANY_INDEX               5
#define	RDB_K_PRF_ANY_MODULE              6
#define	RDB_K_PRF_ANY_OUTLINE             7
#define	RDB_K_PRF_ANY_PROCEDURE           8
#define	RDB_K_PRF_ANY_PROFILE             9
#define	RDB_K_PRF_ANY_RELATION            10
#define	RDB_K_PRF_ANY_REF_ROLE            11
#define	RDB_K_PRF_ANY_REF_SYSPRIV         12
#define	RDB_K_PRF_ANY_ROLE                13
#define	RDB_K_PRF_ANY_SCHEMA              14
#define	RDB_K_PRF_ANY_SEQUENCE            15
#define	RDB_K_PRF_ANY_STOMAP              16
#define	RDB_K_PRF_ANY_SYNONYM             17
#define	RDB_K_PRF_ANY_TRIGGER             18
#define	RDB_K_PRF_ANY_TYPE                19
#define	RDB_K_PRF_ANY_USER                20
#define	RDB_K_PRF_ANY_VIEW                21
#define	RDB_K_PRF_ANY_TEMP_TABLE          22

/* Mask name				Value */
/* -------------			----- */
#define	RDB_M_PRF_ALL                     (1<<RDB_K_PRF_ALL)
#define	RDB_M_PRF_ANY_CATALOG             (1<<RDB_K_PRF_ANY_CATALOG)
#define	RDB_M_PRF_ANY_COLLATION           (1<<RDB_K_PRF_ANY_COLLATION)
#define	RDB_M_PRF_ANY_FIELD               (1<<RDB_K_PRF_ANY_FIELD)
#define	RDB_M_PRF_ANY_FUNCTION            (1<<RDB_K_PRF_ANY_FUNCTION)
#define	RDB_M_PRF_ANY_INDEX               (1<<RDB_K_PRF_ANY_INDEX)
#define	RDB_M_PRF_ANY_MODULE              (1<<RDB_K_PRF_ANY_MODULE)
#define	RDB_M_PRF_ANY_OUTLINE             (1<<RDB_K_PRF_ANY_OUTLINE)
#define	RDB_M_PRF_ANY_PROCEDURE           (1<<RDB_K_PRF_ANY_PROCEDURE)
#define	RDB_M_PRF_ANY_PROFILE             (1<<RDB_K_PRF_ANY_PROFILE)
#define	RDB_M_PRF_ANY_RELATION            (1<<RDB_K_PRF_ANY_RELATION) \
					  | (1<<RDB_K_PRF_ANY_TEMP_TABLE)
#define	RDB_M_PRF_ANY_REF_ROLE            (1<<RDB_K_PRF_ANY_REF_ROLE)
#define	RDB_M_PRF_ANY_REF_SYSPRIV         (1<<RDB_K_PRF_ANY_REF_SYSPRIV)
#define	RDB_M_PRF_ANY_ROLE                (1<<RDB_K_PRF_ANY_ROLE)
#define	RDB_M_PRF_ANY_SCHEMA              (1<<RDB_K_PRF_ANY_SCHEMA)
#define	RDB_M_PRF_ANY_SEQUENCE            (1<<RDB_K_PRF_ANY_SEQUENCE)
#define	RDB_M_PRF_ANY_STOMAP              (1<<RDB_K_PRF_ANY_STOMAP)
#define	RDB_M_PRF_ANY_SYNONYM             (1<<RDB_K_PRF_ANY_SYNONYM)
#define	RDB_M_PRF_ANY_TRIGGER             (1<<RDB_K_PRF_ANY_TRIGGER)
#define	RDB_M_PRF_ANY_TYPE                (1<<RDB_K_PRF_ANY_TYPE)
#define	RDB_M_PRF_ANY_USER                (1<<RDB_K_PRF_ANY_USER)
#define	RDB_M_PRF_ANY_VIEW                (1<<RDB_K_PRF_ANY_VIEW)
#define	RDB_M_PRF_ANY_TEMP_TABLE          (1<<RDB_K_PRF_ANY_TEMP_TABLE)

/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 * RDB_K_LEVEL_* 
 * This section contains the level of SQL92 compliance required of the engine. 
 * All non-zero values imply SQL92 or better semantics.  Different values 
 * may trigger slightly different semantics in the DSRI implementation. 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_LEVEL_ORALVL_2              -2
#define	RDB_K_LEVEL_ORALVL_1              -1
#define	RDB_K_LEVEL_NONE                  0
#define	RDB_K_LEVEL_SQL92_ENTRY           1
#define	RDB_K_LEVEL_SQL92_TRANS           2
#define	RDB_K_LEVEL_SQL92_INT             3
#define	RDB_K_LEVEL_SQL92_FULL            4
#define	RDB_K_LEVEL_SQL99                 5
#define	RDB_K_LEVEL_SQL3                  RDB_K_LEVEL_SQL99	/* alias */

/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 * RDB_K_CHANGE_ 
 * These literals are the modes used by MBLR_K_CHANGE_ATTRIBUTES and indicate 
 * if the listed objects are enabled or disabled. 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_CHANGE_DISABLE              0
#define	RDB_K_CHANGE_ENABLE               1
#define	RDB_K_CHANGE_ENABLE_NOCHECK       2

/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 * RDB_K_PART_MODE_* 
 * These literals are the modes used by MBLR_K_PARTITION_DEF clause in 
 * a storage map or index. 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_PART_MODE_DEFINE            0	/* add partition */
#define	RDB_K_PART_MODE_MIN               RDB_K_PART_MODE_DEFINE
#define	RDB_K_PART_MODE_DELETE            1	/* drop partition */
#define	RDB_K_PART_MODE_MOVE              2	/* move partition */
#define	RDB_K_PART_MODE_COMMENT           3	/* comment on */
#define	RDB_K_PART_MODE_RENAME            4	/* rename partition */
#define	RDB_K_PART_MODE_ERASE             5	/* delete partition */
#define	RDB_K_PART_MODE_BUILD             6	/* build index part */
#define	RDB_K_PART_MODE_REBUILD           7	/* rebuild index part */
#define	RDB_K_PART_MODE_TRUNCATE          8	/* truncate partition */
#define	RDB_K_PART_MODE_MAX               8

/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 * RDB_K_AUTOMATIC_* 
 * These literals are the modes used by MBLR_K_MODE clause in 
 * a relation definition. 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_AUTOMATIC_NEVER             0
#define	RDB_K_AUTOMATIC_INSERT            1
#define	RDB_K_AUTOMATIC_UPDATE            2
#define	RDB_K_AUTOMATIC_ALWAYS            3

/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 * RDB_K_VLIST_ 
 * These literals are the modes used by BLR_K_VALUE_LIST 
 * _ORA indicates ORACLE dialect variants which have slightly different 
 * semantics. 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_VLIST_DATA_SET              0
#define	RDB_K_VLIST_LEAST                 1
#define	RDB_K_VLIST_GREATEST              2
#define	RDB_K_VLIST_LEAST_ORA             3
#define	RDB_K_VLIST_GREATEST_ORA          4
#define	RDB_K_VLIST_ROUND_NUMERIC         5
#define	RDB_K_VLIST_ROUND_ADT             6
#define	RDB_K_VLIST_TRUNC_NUMERIC         7
#define	RDB_K_VLIST_TRUNC_ADT             8
#define	RDB_K_VLIST_CONCAT                9
#define	RDB_K_VLIST_CONCAT_ORA            10
#define	RDB_K_VLIST_BIN_TO_NUM            11
#define	RDB_K_VLIST_CONCAT_WS             12
#define	RDB_K_VLIST_CONCAT_WS_ORA         13


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_DPB_<mumbo> 
 *   RDB_K_DPB2_<mumbo> 
 *   This section contains all the values for the Database Parameter Block used 
 *   in attach, create and change database 
 *--------------------------------------------------------------------------- 
 */

/*
 * DPB version tags 
 */
#define	RDB_K_DPB_VERSION1                1
#define	RDB_K_DPB_VERSION2                2


/*
 *----------------------------------------------------------------------------- 
 * DPB version 1 tags 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_DPB_MIN                     1
#define	RDB_K_DPB_CDD_PATHNAME            1
#define	RDB_K_DPB_ALLOCATION              2
#define	RDB_K_DPB_AIJ                     3
#define	RDB_K_DPB_PAGE_SIZE               4
#define	RDB_K_DPB_NUM_BUFF                5
#define	RDB_K_DPB_BUFFER_LENGTH           6
#define	RDB_K_DPB_DEBUG                   7
#define	RDB_K_DPB_GARBAGE_COLLECT         8
#define	RDB_K_DPB_VERIFY                  9
#define	RDB_K_DPB_SWEEP                   10
#define	RDB_K_DPB_ENABLE_JOURNAL          11
#define	RDB_K_DPB_DISABLE_JOURNAL         12
#define	RDB_K_DPB_DBKEY_SCOPE             13
#define	RDB_K_DPB_NUM_USERS               14
#define	RDB_K_DPB_DB_EXTENT               15
#define	RDB_K_DPB_EXT_DB_MIN_NUM_PAGES    16
#define	RDB_K_DPB_EXT_DB_MAX_NUM_PAGES    17
#define	RDB_K_DPB_EXT_DB_PCT_GROWTH       18
#define	RDB_K_DPB_SNP_ALLOCATION          19
#define	RDB_K_DPB_SNP_ENABLED             20
#define	RDB_K_DPB_SNP_DISABLED            21
#define	RDB_K_DPB_SNP_EXTENT              22
#define	RDB_K_DPB_EXT_SNP_MIN_NUM_PAGES   23
#define	RDB_K_DPB_EXT_SNP_MAX_NUM_PAGES   24
#define	RDB_K_DPB_EXT_SNP_PCT_GROWTH      25
#define	RDB_K_DPB_AIJ_CONTINUOUS          26
#define	RDB_K_DPB_AIJ_ONCE                27
#define	RDB_K_DPB_AIJ_SPOOL_FILE          28
#define	RDB_K_DPB_DESCRIPTION_SOURCE      29
#define	RDB_K_DPB_CONVERT                 30
#define	RDB_K_DPB_SNAPSHOT                31
#define	RDB_K_DPB_OPEN_MANUAL             32
#define	RDB_K_DPB_OPEN_AUTOMATIC          33
#define	RDB_K_DPB_DEFINE_STORAGE          34
#define	RDB_K_DPB_CHANGE_STORAGE          35
#define	RDB_K_DPB_STORAGE_NAME            36
#define	RDB_K_DPB_FILESPEC                37
#define	RDB_K_DPB_EXTENSIBLE              38
#define	RDB_K_DPB_SNP_DEFERRED            39
#define	RDB_K_DPB_NUM_NODES               40
#define	RDB_K_DPB_FILE_TYPE               41
#define	RDB_K_DPB_CDD_MAINTAINED          42
#define	RDB_K_DPB_CDD_REQUIRED            43
#define	RDB_K_DPB_SEGMENT_AREA            44
/* SPAMS is not currently used */
#define	RDB_K_DPB_SPAMS                   45
#define	RDB_K_DPB_SPAM_THRESHOLD_1        46
#define	RDB_K_DPB_SPAM_THRESHOLD_2        47
#define	RDB_K_DPB_SPAM_THRESHOLD_3        48
#define	RDB_K_DPB_SPAM_INTERVAL           49
#define	RDB_K_DPB_AIJ_ALLOCATION          50
#define	RDB_K_DPB_AIJ_EXTENT              51
#define	RDB_K_DPB_DBR_BUFFERS             52
#define	RDB_K_DPB_END_STORAGE_AREA        53
#define	RDB_K_DPB_MAX                     53

/*
 *----------------------------------------------------------------------------- 
 * DPB version 1 sub options 
 *----------------------------------------------------------------------------- 
 */


/* DBKEY scope */
#define	RDB_K_DPB_DBKEY_SCOPE_TRANS       0
#define	RDB_K_DPB_DBKEY_SCOPE_ATTACH      1

/* Deferred snapshots */
#define	RDB_K_DPB_SNP_DEFERRED_NO         0
#define	RDB_K_DPB_SNP_DEFERRED_YES        1

/* CDD required */
#define	RDB_K_DPB_EXT_DICT_IGNORED        0
#define	RDB_K_DPB_EXT_DICT_REQUIRED       1

/* CDD update */
#define	RDB_K_DPB_CLI_DICT_IGNORED        0
#define	RDB_K_DPB_CLI_DICT_MAINTAINED     1
#define	RDB_K_DPB_CLI_DICT_UNLINK         2

/* CDD database */
#define	RDB_K_DPB_DICT_DATABASE_NO        0
#define	RDB_K_DPB_DICT_DATABASE_YES       1

/* Multischema */
#define	RDB_K_DPB_MULTISCHEMA_NO          0
#define	RDB_K_DPB_MULTISCHEMA_YES         1

/* Global buffering */
#define	RDB_K_DPB_GB_OFF                  0
#define	RDB_K_DPB_GB_ON                   1

/* Fast commit */
#define	RDB_K_DPB_CHKPNT_OFF              0
#define	RDB_K_DPB_CHKPNT_ON               1

/* File types */
#define	RDB_K_DPB_FT_PARTITIONED          0
#define	RDB_K_DPB_FT_CLUSTERED            1

/* Protection */
#define	RDB_K_DPB_PROT_DEFAULT            0
#define	RDB_K_DPB_PROT_ANSI_COMPLIANT     1

/* Mask for pages, indices, records and transactions */
#define	RDB_M_DPB_SWP_PAGES               1
#define	RDB_M_DPB_SWP_RECORDS             2
#define	RDB_M_DPB_SWP_INDICES             4
#define	RDB_M_DPB_SWP_TRANSACTIONS        8


/*
 *----------------------------------------------------------------------------- 
 * DPB version 2 tags 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_DPB2_MIN                    1
#define	RDB_K_DPB2_DBKEY_SCOPE            1
/* Deprecated for Rdb V6.0 */
/* Tag will be removed in the future */
#define	RDB_K_DPB2_AIJ                    1
/* The above 2 tags happen to have the same value.  Luckily, they do not */
/* clash currently because RDB_K_DPB2_DBKEY_SCOPE is used by */
/* RDB_K_FACILITY_ALL and RDB_K_DPB2_AIJ is used by RDB_K_FACILITY_RDB_VMS. */
/* RDB_K_DPB2_AIJ is being deprecated by Rdb V6.0. */

#define	RDB_K_DPB2_ALLOCATION             2
#define	RDB_K_DPB2_PAGE_SIZE              3
#define	RDB_K_DPB2_NUM_BUFF               4
#define	RDB_K_DPB2_BUFFER_LENGTH          5
#define	RDB_K_DPB2_NUM_USERS              6
#define	RDB_K_DPB2_EXT_DB_MIN_NUM_PAGES   7
#define	RDB_K_DPB2_EXT_DB_MAX_NUM_PAGES   8
#define	RDB_K_DPB2_EXT_DB_PCT_GROWTH      9
#define	RDB_K_DPB2_SNP_ALLOCATION         10
#define	RDB_K_DPB2_SNP_FLAG               11
#define	RDB_K_DPB2_EXT_SNP_MIN_NUMPAGES   12
#define	RDB_K_DPB2_EXT_SNP_MAX_NUMPAGES   13
#define	RDB_K_DPB2_EXT_SNP_PCT_GROWTH     14
#define	RDB_K_DPB2_DB_EXTENT              15
#define	RDB_K_DPB2_CDD_PATHNAME           16
#define	RDB_K_DPB2_AIJ_ALLOCATION         17
#define	RDB_K_DPB2_AIJ_EXTENT             18
#define	RDB_K_DPB2_DBR_BUFFERS            19
#define	RDB_K_DPB2_SNP_ENABLED            20
#define	RDB_K_DPB2_SNP_DISABLED           21
#define	RDB_K_DPB2_SNP_EXTENT             22
#define	RDB_K_DPB2_SPAM_THRESHOLD_1       23
#define	RDB_K_DPB2_SPAM_THRESHOLD_2       24
#define	RDB_K_DPB2_SPAM_THRESHOLD_3       25
#define	RDB_K_DPB2_AIJ_CONTINUOUS         26
#define	RDB_K_DPB2_AIJ_ONCE               27
#define	RDB_K_DPB2_AIJ_SPOOL_FILE         28
#define	RDB_K_DPB2_DESCRIPTION_SOURCE     29
#define	RDB_K_DPB2_CONVERT                30
#define	RDB_K_DPB2_SNAPSHOT               31
#define	RDB_K_DPB2_OPEN_MANUAL            32
#define	RDB_K_DPB2_OPEN_AUTOMATIC         33
#define	RDB_K_DPB2_DEFINE_STORAGE         34
#define	RDB_K_DPB2_CHANGE_STORAGE         35
#define	RDB_K_DPB2_STORAGE_NAME           36
#define	RDB_K_DPB2_FILESPEC               37
#define	RDB_K_DPB2_EXTENSIBLE             38
#define	RDB_K_DPB2_SNP_DEFERRED           39
#define	RDB_K_DPB2_NUM_NODES              40
#define	RDB_K_DPB2_FILE_TYPE              41
#define	RDB_K_DPB2_CDD_MAINTAINED         42
#define	RDB_K_DPB2_CDD_REQUIRED           43
#define	RDB_K_DPB2_SEGMENT_AREA           44
/* SPAMS is not currently used */
#define	RDB_K_DPB2_SPAMS                  45
#define	RDB_K_DPB2_SPAM_INTERVAL          46
#define	RDB_K_DPB2_END_STORAGE_AREA       47
#define	RDB_K_DPB2_ALG                    48
#define	RDB_K_DPB2_DELETE_STORAGE         49
#define	RDB_K_DPB2_LAYERED_ACCESS         50
#define	RDB_K_DPB2_REQUEST_SCOPE          51
#define	RDB_K_DPB2_READ_ONLY              52
#define	RDB_K_DPB2_PROTECTION             53
#define	RDB_K_DPB2_COLLATION_SEQUENCE     54
#define	RDB_K_DPB2_DDTM_NOTINVOLVED       55
#define	RDB_K_DPB2_FROM_JSV               56
#define	RDB_K_DPB2_CDD_DICTIONARY         57
#define	RDB_K_DPB2_CHECK_ACCESS           58
/*
 * Added in Rdb/VMS V4.1 
 */
/* SERdb integrity */
#define	RDB_K_DPB2_KEEP_INTEGRITY         59
/* SERdb meta level */
#define	RDB_K_DPB2_META_LEVEL             60
#define	RDB_K_DPB2_WORM                   61
#define	RDB_K_DPB2_MULTISCHEMA            62
/* Image name passed to DECtrace */
#define	RDB_K_DPB2_IMAGE_NAME             63
/* Global buffering */
#define	RDB_K_DPB2_GB_ENABLED             64
#define	RDB_K_DPB2_GB_NUM_BUFF            65
#define	RDB_K_DPB2_GB_NUM_PER_USER        66
/* Fast commit */
#define	RDB_K_DPB2_FC_CHKPT_INTERVAL      67
#define	RDB_K_DPB2_FC_CHKPT_ENABLED       68
#define	RDB_K_DPB2_FC_CHKPT_TIME          69
/* Carry-over */
#define	RDB_K_DPB2_CARRY_OVER             70
/* Lock timeout */
#define	RDB_K_DPB2_LOCK_TIMEOUT           71
/* Fast commit */
#define	RDB_K_DPB2_FC_COMMIT_TO_JOURNAL   72
#define	RDB_K_DPB2_FC_TRANS_INTERVAL      73

/*
 * Added in Rdb/VMS V4.2 
 */
/* MIA character set */
#define	RDB_K_DPB2_DEF_CSET_ID            74
#define	RDB_K_DPB2_NAT_CSET_ID            75
#define	RDB_K_DPB2_ROOT_FILE_ACL_TYPE     76
#define	RDB_K_DPB2_ROOT_FILE_ACL          77
/* area extent enable */
#define	RDB_K_DPB2_DB_EXTENT_ENABLED      78
/* name character set */
#define	RDB_K_DPB2_NAM_CSET_ID            79
/* SERdb mac policy */
#define	RDB_K_DPB2_MAC_POLICY             80

/*
 * Added in Rdb V5.1 
 */
#define	RDB_K_DPB2_PRESTART_TXN           81

/*
 * Added in Rdb V6.0 
 */
/* Cache Filename */
#define	RDB_K_DPB2_AIJ_CACHE_FILE         82
/* Backup Server */
#define	RDB_K_DPB2_AIJ_BCK_SERVER         83
/* Backup Same as Journal */
#define	RDB_K_DPB2_AIJ_SUPERCEDE          84
/* Log Server */
#define	RDB_K_DPB2_AIJ_LOG_SERVER         85
/* Overwrite AIJ option */
#define	RDB_K_DPB2_JOURNAL_OVERWRITE      86
#define	RDB_K_DPB2_DEFINE_JOURNAL         87
#define	RDB_K_DPB2_CHANGE_JOURNAL         88
#define	RDB_K_DPB2_JOURNAL_NAME           89
#define	RDB_K_DPB2_DELETE_JOURNAL         90
/* Notify Operator */
#define	RDB_K_DPB2_JOURNAL_NOTIFY         91
/* Enable Journal */
#define	RDB_K_DPB2_USE_JOURNAL            92
#define	RDB_K_DPB2_END_JOURNAL            93
/* Reserve n Journals */
#define	RDB_K_DPB2_RESERVE_JOURNAL        94
/* Reserve n Storage Areas */
#define	RDB_K_DPB2_RESERVE_STORAGE        95
#define	RDB_K_DPB2_RESTRICTED_ACCESS      96
#define	RDB_K_DPB2_STATISTICS             97
#define	RDB_K_DPB2_IDX_COMPRESSION        98
/* Locking is page/row */
#define	RDB_K_DPB2_AREA_LOCKING           99

/* DBI special tags */
#define	RDB_K_DPB2_TEMP_PROXY             100
#define	RDB_K_DPB2_DEFAULT_LINK           101

#define	RDB_K_DPB2_SQL92_SEMANTICS        102	/* SQL behaviour */
#define	RDB_K_DPB2_GB_INHIB_FLAG          103	/* Inhibit binding to gl */
/*
 * Added in V6.1 
 */
#define	RDB_K_DPB2_ASYNCH_ENABLED         104	/* Allows asynch DSRI */
#define	RDB_K_DPB2_NOTIFY_OP_CLASS        105	/* notify operator class */
#define	RDB_K_DPB2_SHUTDOWN_TIME          106	/* shutdown time when er */
#define	RDB_K_DPB2_ASYNCH_PREFETCH        107	/* asynch prefetch */
#define	RDB_K_DPB2_ABW_CLEAN_BUFFERS      108	/* buf count for asyn be */
#define	RDB_K_DPB2_ASYNCH_BATCHWRITE      109	/* asyn betch write */
#define	RDB_K_DPB2_APF_DEPTH              110	/* buf count for prefetch */

#define	RDB_K_DPB2_PARTITIONED_LOCK       111	/* lock partitioning */
#define	RDB_K_DPB2_GB_TRANSFER            112	/* page transfer for glo */
#define	RDB_K_DPB2_INCR_BACKUP            113	/* incremental backup */
#define	RDB_K_DPB2_ABW_MAX_BUFFERS        114	/* asyn batch write max */
#define	RDB_K_DPB2_AREA_ADD_MULTITHREAD   115	/* # of areas created at */
/*
 * Added in V7.0 
 */
#define	RDB_K_DPB2_DEFAULT_STORAGE        116	/* default storage area name */
#define	RDB_K_DPB2_DEFAULT_TEMPLATE       117	/* default template area name */
#define	RDB_K_DPB2_D_ASYNCH_PREFETCH      118	/* detected async prefetch */
#define	RDB_K_DPB2_DAPF_DEPTH             119	/* detected apf depth */
#define	RDB_K_DPB2_DAPF_THRESHOLD         120	/* detected apf threshold */
#define	RDB_K_DPB2_USE_CACHE              121	/* enable row caching */
#define	RDB_K_DPB2_DEFINE_CACHE           122	/* create a cache */
#define	RDB_K_DPB2_CHANGE_CACHE           123	/* alter a cache */
#define	RDB_K_DPB2_DELETE_CACHE           124	/* drop a cache */
#define	RDB_K_DPB2_CACHE_NAME             125	/* name of cache */
#define	RDB_K_DPB2_RESERVE_CACHE          126	/* reserve cache slots */
#define	RDB_K_DPB2_WORKLOAD_ENABLED       127	/* enable workload collection */
#define	RDB_K_DPB2_FILESPEC_EDIT          128	/* edit string for file spec */
#define	RDB_K_DPB2_END_CACHE              129	/* end of cache definition */
#define	RDB_K_DPB2_CARD_UPDATE_ENABLED    130	/* enable cardinality updates */
#define	RDB_K_DPB2_DDL_ENABLED            131	/* enable use of DDL */
#define	RDB_K_DPB2_RESERVE_TEMPLATE       132	/* reserve template slots */
#define	RDB_K_DPB2_DEFER_CARD_UPDATE      133	/* defer cardinality update to DETACH */
#define	RDB_K_DPB2_DEFINE_TXN_MODES       134	/* allowed txn modes for database */
#define	RDB_K_DPB2_CHANGE_TXN_MODES       135	/* alter txn modes for database */
#define	RDB_K_DPB2_INTERNAL_USE           136	/* special tag */
#define	RDB_K_DPB2_MEMORY_MAPPING         137	/* mem map options */
#define	RDB_K_DPB2_CHECKSUM               138	/* ena/disable checksum on area */
#define	RDB_K_DPB2_SNP_CHECKSUM           139	/* ena/disable checksum on area */
#define	RDB_K_DPB2_CACHE_REPLACE          140	/* cache replacement policy */
#define	RDB_K_DPB2_RC_LOCATION            141	/* cache: location */
#define	RDB_K_DPB2_RC_SWEEP_INTERVAL      142	/* cache: sweep interval */
#define	RDB_K_DPB2_RC_RESERVED_RECS       143	/* cache: reserved rows */
#define	RDB_K_DPB2_RC_SWEEP_THRESHOLDS    144	/* cache: sweep thresholds */
#define	RDB_K_DPB2_RC_SWEEP_RECS          145	/* cache: sweep rows */
/*
 * Added in Rdb V7.1 
 */
#define	RDB_K_DPB2_RESERVE_SEQUENCES      146	/* seq: reserve */
#define	RDB_K_DPB2_RC_CHKPT_DEST          147	/* cache: destination */
#define	RDB_K_DPB2_RC_CHKPT_TIME          148	/* cache: checkpoint time */
#define	RDB_K_DPB2_SECURITY_POLICY        149	/* db: how is security checking performed */
#define	RDB_K_DPB2_BUFFER_TYPE            150	/* ruj: local/global */
#define	RDB_K_DPB2_DISPLAY_CSET_ID        151	/* auto translate */
#define	RDB_K_DPB2_SECURITY_CREATOR_ID    152	/* (import tag) */
#define	RDB_K_DPB2_OBJECT_SYNONYMS        153	/* does RDB_OBJECT_SYNONYMS exist? */
#define	RDB_K_DPB2_LOGMINER               154	/* enable/disable logminer */
#define	RDB_K_DPB2_NDX_PREFIX_CARD        155	/* system index: prf card setting */
#define	RDB_K_DPB2_NDX_TYPE               156	/* system index: type of sorted index */
#define	RDB_K_DPB2_GALAXY_SUPPORT         157	/* enable/disable galaxy */
#define	RDB_K_DPB2_SHARED_INSTANCE        158	/* single or multiple instances */
#define	RDB_K_DPB2_FC_CHKPT_TXN           159

/*
 * Added in Rdb 7.2 
 */
#define	RDB_K_DPB2_GB_ALLOCATION          160	/* Allocation in bytes (not buffers) */


#define	RDB_K_DPB2_MAX                    160

/*
 *----------------------------------------------------------------------------- 
 * DPB version 2 sub options 
 *----------------------------------------------------------------------------- 
 */


/* Generic ON and OFF */
#define	RDB_K_DPB2_OFF                    0
#define	RDB_K_DPB2_ON                     1
#define	RDB_K_DPB2_UNKNOWN                -1

/* Prefix cardinality collection */
#define	RDB_K_DPB2_COLLECT_DISABLED       0
#define	RDB_K_DPB2_COLLECT_ENABLED        1
#define	RDB_K_DPB2_COLLECT_FULL           2

/* Logminer bits options (use disabled to clear bits, */
/* other values to set mask) */
#define	RDB_K_DPB2_LOGMINER_ENABLED       0
#define	RDB_K_DPB2_LOGMINER_CONTINUOUS    1

#define	RDB_M_DPB2_LOGMINER_DISABLED      0
#define	RDB_M_DPB2_LOGMINER_ENABLED       (1<<RDB_K_DPB2_LOGMINER_ENABLED)
#define	RDB_M_DPB2_LOGMINER_CONTINUOUS    (1<<RDB_K_DPB2_LOGMINER_CONTINUOUS) \
					  | RDB_M_DPB2_LOGMINER_ENABLED

/* Options for the NDX_TYPE */
#define	RDB_K_DPB2_NDX_TYPE_SORTED        0
#define	RDB_K_DPB2_NDX_TYPE_RANKED        1

/* Subtags for MEMORY_MAPPING */
#define	RDB_K_DPB2_MEMMAP_VLM             0
#define	RDB_K_DPB2_MEMMAP_SYSBUF          1
#define	RDB_K_DPB2_MEMMAP_WINDOW_CNT      2
#define	RDB_K_DPB2_MEMMAP_RESIDENT        3
#define	RDB_K_DPB2_MEMMAP_WORKING_SET     4

/* Request scope */
#define	RDB_K_DPB2_REQUEST_SCOPE_ATTACH   0
#define	RDB_K_DPB2_REQUEST_SCOPE_PROG     1

/* CLTN options */
#define	RDB_K_DPB2_CLTN_MIN               1
#define	RDB_K_DPB2_CLTN_NAME              1
#define	RDB_K_DPB2_CLTN_DESCRIPTION       2
#define	RDB_K_DPB2_CLTN_SEQUENCE_TABLE    3
#define	RDB_K_DPB2_CLTN_MAX               3

/* Locking */
#define	RDB_K_DPB2_LOCK_RECORD            0
#define	RDB_K_DPB2_LOCK_PAGE              1

/* SERdb integrity preserved */
#define	RDB_K_DPB2_KEEP_INTEGRITY_NO      0
#define	RDB_K_DPB2_KEEP_INTEGRITY_YES     1

/* Metadata level */
#define	RDB_K_DPB2_META_LEVEL_MULTI       0
#define	RDB_K_DPB2_META_LEVEL_SINGLE      1

/* ALG */
#define	RDB_K_DPB2_ALG_ENABLED            0
#define	RDB_K_DPB2_ALG_DISABLED           1

/* Root file ACL */
#define	RDB_K_DPB2_ROOT_FILE_ACL_NO       0
#define	RDB_K_DPB2_ROOT_FILE_ACL_YES      1

/* Journal types (used for DEFINE/CHANGE_JOURNAL) */
#define	RDB_K_DPB2_JTYPE_AIJ              0	/* After Image Journal */
#define	RDB_K_DPB2_JTYPE_RUJ              1	/* Recovery Unit Journal */

/* Area types (used for DEFINE/CHANGE_STORAGE) */
#define	RDB_K_DPB2_ATYPE_STORAGE          0	/* Storage Area */
#define	RDB_K_DPB2_ATYPE_TEMPLATE         1	/* Template Area */

/* Type of DELETE operation restrict or cascade */
#define	RDB_K_DPB2_DELETE_RESTRICT        0
#define	RDB_K_DPB2_DELETE_CASCADE         1

/* Type of destination for row cache checkpoint (RDB_K_DPB2_RC_CHKPT_DEST) */
#define	RDB_K_DPB2_CHKPT_ALL_TO_FILE      0
#define	RDB_K_DPB2_CHKPT_UPD_TO_FILE      1
#define	RDB_K_DPB2_CHKPT_UPD_TO_DB        2

/* Type of policy */
#define	RDB_K_DPB2_SECURITY_EXTERNAL      0
#define	RDB_K_DPB2_SECURITY_INTERNAL_ID   1
#define	RDB_K_DPB2_SECURITY_INTERNAL_NM   2
#define	RDB_K_DPB2_SECURITY_EXTERNAL_PS   3	/* PERSONA */
    
/* Types of buffers */
#define	RDB_K_DPB2_BUFTYPE_LOCAL          0
#define	RDB_K_DPB2_BUFTYPE_GLOBAL         1



/*
 *----------------------------------------------------------------------------- 
 * Options for DPB2 option RDB_K_DPB2_TRANSACTION_MODES 
 *	Allow selection of various transaction options 
 *		BATCH UPDATE 
 *		READ ONLY (BATCH RETRIEVAL) 
 *		CONCURRENT UPDATE 
 *		CONCURRENT READ 
 *		PROTECTED UPDATE 
 *		PROTECTED READ 
 *		EXCLUSIVE UPDATE 
 *		EXCUSIVE READ 
 *----------------------------------------------------------------------------- 
 */

#define	RDB_K_TXN_MODE_CONCURRENT_READ    0
#define	RDB_K_TXN_MODE_CONCURRENT_WRITE   1
#define	RDB_K_TXN_MODE_PROTECTED_READ     2
#define	RDB_K_TXN_MODE_PROTECTED_WRITE    3
#define	RDB_K_TXN_MODE_EXCLUSIVE_READ     4
#define	RDB_K_TXN_MODE_EXCLUSIVE_WRITE    5
#define	RDB_K_TXN_MODE_READ_ONLY          6
#define	RDB_K_TXN_MODE_BATCH_UPDATE       7

#define	RDB_M_TXN_MODE_CONCURRENT_READ    (1<<RDB_K_TXN_MODE_CONCURRENT_READ)
#define	RDB_M_TXN_MODE_CONCURRENT_WRITE   (1<<RDB_K_TXN_MODE_CONCURRENT_WRITE)
#define	RDB_M_TXN_MODE_PROTECTED_READ     (1<<RDB_K_TXN_MODE_PROTECTED_READ)
#define	RDB_M_TXN_MODE_PROTECTED_WRITE    (1<<RDB_K_TXN_MODE_PROTECTED_WRITE)
#define	RDB_M_TXN_MODE_EXCLUSIVE_READ     (1<<RDB_K_TXN_MODE_EXCLUSIVE_READ)
#define	RDB_M_TXN_MODE_EXCLUSIVE_WRITE    (1<<RDB_K_TXN_MODE_EXCLUSIVE_WRITE)
#define	RDB_M_TXN_MODE_READ_ONLY          (1<<RDB_K_TXN_MODE_READ_ONLY)
#define	RDB_M_TXN_MODE_BATCH_UPDATE       (1<<RDB_K_TXN_MODE_BATCH_UPDATE)

#define	RDB_M_TXN_MODE_CONCURRENT_ALL     (RDB_M_TXN_MODE_CONCURRENT_READ | \
					   RDB_M_TXN_MODE_CONCURRENT_WRITE)
#define	RDB_M_TXN_MODE_PROTECTED_ALL      (RDB_M_TXN_MODE_PROTECTED_READ | \
					   RDB_M_TXN_MODE_PROTECTED_WRITE)
#define	RDB_M_TXN_MODE_EXCLUSIVE_ALL      (RDB_M_TXN_MODE_EXCLUSIVE_READ | \
					   RDB_M_TXN_MODE_EXCLUSIVE_WRITE)
#define	RDB_M_TXN_MODE_READ_WRITE         (RDB_M_TXN_MODE_CONCURRENT_ALL | \
					   RDB_M_TXN_MODE_PROTECTED_ALL | \
					   RDB_M_TXN_MODE_EXCLUSIVE_ALL)
#define	RDB_M_TXN_MODE_ALL                (RDB_M_TXN_MODE_CONCURRENT_ALL | \
					   RDB_M_TXN_MODE_PROTECTED_ALL | \
					   RDB_M_TXN_MODE_EXCLUSIVE_ALL | \
					   RDB_M_TXN_MODE_READ_ONLY | \
					   RDB_M_TXN_MODE_BATCH_UPDATE)
#define	RDB_M_TXN_MODE_NONE               0

/*
 *----------------------------------------------------------------------------- 
 * Edit string option encodings (re: RDB_K_DPB2_FILESPEC_EDIT) 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_ES_FIELD_SEP                28	/* field separator */
#define	RDB_K_ES_SEQUENCE                 1	/* aij sequence number */
#define	RDB_K_ES_MIN                      1
#define	RDB_K_ES_YEAR                     2	/* year */
#define	RDB_K_ES_MONTH                    3	/* month of year */
#define	RDB_K_ES_HOUR                     4	/* hour of day */
#define	RDB_K_ES_MINUTE                   5	/* minute of hour */
#define	RDB_K_ES_JULIAN_DAY               6	/* days since 1 JAN */
#define	RDB_K_ES_DAY                      7	/* day of month */
#define	RDB_K_ES_WEEKDAY                  8	/* day of week */
#define	RDB_K_ES_DAY_OF_EPIC              9	/* days since zero yr */

#define	RDB_K_ES_MAX                      9

/*
 *----------------------------------------------------------------------------- 
 * Literal values for the various evaluation times written to 
 * RDB_EVALUATION_TIME column of the RDB_CONSTRAINTS table 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EVAL_COMMIT_TIME            1	/* initially evaluated at COMMIT time */
#define	RDB_K_EVAL_UPDATE_TIME            2	/* initially evaluated at UPDATE time */
#define	RDB_K_EVAL_NOT_DEFERRABLE         3	/* always at UPDATE time, can't defer */


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_TPB_<mumbo> 
 *   This section contains all the values for the Transaction Parameter Block 
 *   used in transactions. 
 *--------------------------------------------------------------------------- 
 */

/*
 *----------------------------------------------------------------------------- 
 * TPB version tags 
 *----------------------------------------------------------------------------- 
 */
#define	TPB_K_VERSION                     1

/*
 *----------------------------------------------------------------------------- 
 * TPB option tags 
 *----------------------------------------------------------------------------- 
 */
#define	TPB_K_OPT_MIN                     1
/* high-consistency */
#define	TPB_K_DEGREE3                     1
/* high-concurrency */
#define	TPB_K_DEGREE2                     2

/* Used with LOCK_READ and LOCK_WRITE. */
#define	TPB_K_SHARED                      3
#define	TPB_K_PROTECTED                   4
#define	TPB_K_EXCLUSIVE                   5

#define	TPB_K_WAIT                        6
#define	TPB_K_NOWAIT                      7

#define	TPB_K_READ                        8	/* READ_ONLY (snapshot) */
#define	TPB_K_WRITE                       9	/* READ_WRITE */

/* Followed by relation name & optional mode. */
#define	TPB_K_LOCK_READ                   10
#define	TPB_K_LOCK_WRITE                  11

/* Followed by constraint name. */
#define	TPB_K_VERB_TIME                   12
#define	TPB_K_COMMIT_TIME                 13

/* BATCH_UPDATE */
#define	TPB_K_BATCH_UPDATE                14

/* Retain Mode Transaction */
#define	TPB_K_RETAIN_LOCKS                15

/* Allow auto ready of relations used by constrs and trigs */
#define	TPB_K_AUTO_LOCKS                  16

/* Disable default auto locking mode. */
#define	TPB_K_NOAUTO_LOCKS                17

#define	TPB_K_DEFER_INDEX_UPDATES         18
#define	TPB_K_2PC_TRANSACTION             18	/* obsolete */
#define	TPB_K_DDTM_NOTINVOLVED            19	/* obsolete */
#define	TPB_K_FROM_JSV                    20	/* obsolete */

/* WAIT n seconds */
#define	TPB_K_WAIT_INTERVAL               21
/* TPB unique tid for DECtrace */
#define	TPB_K_UNIQUE_ID                   22

/*
 * Isolation levels 
 */
/* NRR/Phantoms */
#define	TPB_K_ISOLATION_LEVEL1            23
/* Phantoms */
#define	TPB_K_ISOLATION_LEVEL2            24
/* Repeatable Reads/No Phantoms */
#define	TPB_K_ISOLATION_LEVEL3            25
/* Dirty Reads */
#define	TPB_K_ISOLATION_LEVEL0            26

/* Reserving for data definition */
#define	TPB_K_LOCK_DDL                    27

/* Partitioned table reservation */
#define	TPB_K_PARTITION                   28

/* Utility wants the best read-only style transaction */
#define	TPB_K_UTILITY_READ                 29

/* Name the TPB buffer */
#define	TPB_K_BUFFER_NAME                  30

#define	TPB_K_OPT_MAX                     30


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_INFO_<mumbo> 
 *   RDB_K_INFO_<yyy>_<mumbo> 
 *   This section contains the information tags. 
 *--------------------------------------------------------------------------- 
 */

/*
 *----------------------------------------------------------------------------- 
 * Generic tags 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_INFO_MIN                    0
#define	RDB_K_INFO_FILLER                 0
#define	RDB_K_INFO_END                    1
#define	RDB_K_INFO_TRUNCATED              2
#define	RDB_K_INFO_ERROR                  3
#define	RDB_K_INFO_MAX                    3
/*
 * There should be no new tags added to the above 
 */

/*
 *----------------------------------------------------------------------------- 
 * Database identifiers 
 * Tags start at 4 because 1-3 is used by the generic tags 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_INFO_DB_MIN                 RDB_K_INFO_MIN
#define	RDB_K_INFO_DB_ID                  4
#define	RDB_K_INFO_DB_READS               5
#define	RDB_K_INFO_DB_WRITES              6
#define	RDB_K_INFO_DB_FETCHES             7
#define	RDB_K_INFO_DB_MARKS               8
#define	RDB_K_INFO_DB_ASTS                9
#define	RDB_K_INFO_DB_AST_WRITES          10
#define	RDB_K_INFO_DB_IMPLEMENTATION      11
#define	RDB_K_INFO_DB_VERSION             12
#define	RDB_K_INFO_DB_BASE_LEVEL          13
#define	RDB_K_INFO_DB_PAGE_SIZE           14
#define	RDB_K_INFO_DB_NUMBER_BUFFERS      15
#define	RDB_K_INFO_DB_LIMBO               16
#define	RDB_K_INFO_DB_NAME                17
/*
 *++ 
 * Rdb/VMS V3.0 Physical Structure Information (KODA) for RDO EXPORT 
 * Per Area Information 
 */
#define	RDB_K_INFO_DB_STO_AREA_STATS      18
#define	RDB_K_INFO_DB_ALLOCATION          19
#define	RDB_K_INFO_DB_EXTENT_MIN          20
#define	RDB_K_INFO_DB_EXTENT_MAX          21
#define	RDB_K_INFO_DB_EXTENT_PRCNT        22
#define	RDB_K_INFO_DB_SNP_EXTENT_MIN      23
#define	RDB_K_INFO_DB_SNP_EXTENT_MAX      24
#define	RDB_K_INFO_DB_SNP_EXTENT_PRCNT    25
#define	RDB_K_INFO_DB_SNP_ALLOCATION      26
#define	RDB_K_INFO_DB_SNP_FILE            27
#define	RDB_K_INFO_DB_AREA_FILE           28
#define	RDB_K_INFO_DB_AREA_TYPE           29
#define	RDB_K_INFO_DB_AREA_NAME           30
/*
 *-- 
 *++ 
 * Database-wide information 
 */
#define	RDB_K_INFO_DB_STO_AREA_LIST       31
#define	RDB_K_INFO_DB_SEGMENT_AREA        32
#define	RDB_K_INFO_DB_NUMBER_USERS        33
#define	RDB_K_INFO_DB_NUMBER_NODES        34
#define	RDB_K_INFO_DB_NUMBER_DBR_BFRS     35
#define	RDB_K_INFO_DB_SNP_ENABLED         36
#define	RDB_K_INFO_DB_SNP_DEFERRED        37
#define	RDB_K_INFO_DB_AIJ_ALLOCATION      38
#define	RDB_K_INFO_DB_AIJ_EXTENSION       39
#define	RDB_K_INFO_DB_BUFFER_SIZE         40
#define	RDB_K_INFO_DB_AREA_ACCESS_MODE    41
#define	RDB_K_INFO_DB_MFDB                42
/*
 *-- 
 */
#define	RDB_K_INFO_DB_REMOTE_NODE         43
/*
 *++ 
 * New storage area options 
 */
#define	RDB_K_INFO_DB_ALLOCATION_MAX      44
#define	RDB_K_INFO_DB_SNP_ALLOC_MAX       45
/*
 *-- 
 *++ 
 * Security options 
 */
#define	RDB_K_INFO_DB_AUDIT_EVENTS        46
#define	RDB_K_INFO_DB_AUDIT_ALARM_NAME    47
#define	RDB_K_INFO_DB_AUDIT_FILE_NAME     48
#define	RDB_K_INFO_DB_AUDIT_FLAGS         49
/*
 *-- 
 *++ 
 * SERdb info call options 
 */
#define	RDB_K_INFO_DB_INTEGRITY           50
#define	RDB_K_INFO_DB_SINGLE_LEVEL        51
/*
 *-- 
 */
#define	RDB_K_INFO_DB_ALG_COUNT           52	/* Adjustable Lock Granularity */
#define	RDB_K_INFO_DB_SPAM_INTERVAL       53	/* Storage area SPAM interval */
#define	RDB_K_INFO_DB_AREA_THRESHOLD      54	/* Storage area threshold */
#define	RDB_K_INFO_DB_LAREA_THRESHOLD     55	/* Logical area threshold */
#define	RDB_K_INFO_DB_GB_ENABLED          56	/* Global buffering enabled */
#define	RDB_K_INFO_DB_GB_NUM_BUFF         57	/* Number of global buffers */
#define	RDB_K_INFO_DB_GB_NUM_PER_USER     58	/* Number Buffers Per User */
#define	RDB_K_INFO_DB_FC_CHKPT_INTERVAL   59	/* Fast commit Checkpoint interval */
#define	RDB_K_INFO_DB_FC_CHKPT_ENABLED    60	/* Fast commit Checkpoint enabled */
#define	RDB_K_INFO_DB_FC_CHKPT_TIME       61	/* Fast commit Chckpt time interval */
#define	RDB_K_INFO_DB_AIJ_FILE_NAME       62	/* Names for the AIJ */
#define	RDB_K_INFO_DB_LCKOPT_ENABLED      63	/* carry over lock enabled */
#define	RDB_K_INFO_DB_LOCK_TIMEOUT        64	/* default lock wait time interval */
#define	RDB_K_INFO_DB_FC_COMMIT_TO_JRNL   65	/* Fast commit enabled */
#define	RDB_K_INFO_DB_FC_TSN_INTERVAL     66	/* Fast commit TSN interval */
#define	RDB_K_INFO_DB_MULTISCHEMA         67	/* Is multischema enabled? */
#define	RDB_K_INFO_DB_CSET                68	/* What are the DB csets ? */
#define	RDB_K_INFO_DB_STO_AREA_COUNT      69	/* Return number of storage areas */
#define	RDB_K_INFO_DB_ROOT_FILE_ACL       70	/* Database root file ACL */
#define	RDB_K_INFO_DB_EXTENT_ENABLED      71	/* Return TRUE if EXTENT ENABLED */
#define	RDB_K_INFO_DB_MAC_POLICY          72	/* SERdb mac policy */
/*
 * Rdb V6.0 
 */
#define	RDB_K_INFO_DB_AIJ_LIST            73	/* list of aij names */
#define	RDB_K_INFO_DB_AIJ_COUNT           74	/* count of aij's */
#define	RDB_K_INFO_DB_AIJ_NAME            75	/* name of journal */
#define	RDB_K_INFO_DB_AIJ_STATS           76	/* statistics for AIJ's */
#define	RDB_K_INFO_DB_AIJ_FREE            77	/* count of unused aij's */
#define	RDB_K_INFO_DB_STO_AREA_FREE       78	/* count of unused areas */
#define	RDB_K_INFO_DB_STATISTICS          79	/* Are statistics enabled or not */
#define	RDB_K_INFO_DB_AIJ_SPOOL_FILE      80	/* AIJ spool file spec */
#define	RDB_K_INFO_DB_AIJ_CACHE_FILE      81	/* AIJ cache file spec */
#define	RDB_K_INFO_DB_AIJ_SUPERSEDE       82	/* bck filename same as journal */
#define	RDB_K_INFO_DB_AIJ_BCK_SERVER      83	/* is bck server enabled or not */
#define	RDB_K_INFO_DB_AIJ_LOG_SERVER      84	/* is log server enabled or not */
#define	RDB_K_INFO_DB_AIJ_OVERWRITE       85	/* is circ aij used for only redo */
#define	RDB_K_INFO_DB_AIJ_ENABLED         86	/* aij used or not */
#define	RDB_K_INFO_DB_IDX_COMPRESSION     87	/* system index compression */
#define	RDB_K_INFO_DB_AREA_LOCKING        88	/* locking is page or record */
#define	RDB_K_INFO_DB_RESTRICTED_ACCESS   89	/* access is restricted */
#define	RDB_K_INFO_DB_AIJ_NOTIFY          90	/* notify operator */
#define	RDB_K_INFO_DB_ACTIVE_JOURNAL      91	/* active journal */
#define	RDB_K_INFO_DB_DEFAULT_LINK        92	/* DBI: default link */
/*
 * V6.1 
 */
#define	RDB_K_INFO_DB_OPEN_MODE           93	/* 7.0: manual/automatic */
#define	RDB_K_INFO_DB_SHUTDOWN_TIME       94	/* shutdown time when error */
#define	RDB_K_INFO_DB_ASYNCH_PREFETCH     95	/* asynch prefetch */
#define	RDB_K_INFO_DB_ABW_CLEAN_BUFFERS   96	/* buf count for betch write */
#define	RDB_K_INFO_DB_ASYNCH_BATCHWRITE   97	/* asyn betch write */
#define	RDB_K_INFO_DB_APF_DEPTH           98	/* depth for asyn prefetch */
#define	RDB_K_INFO_DB_PARTITIONED_LOCK    99	/* lock partitioning */
#define	RDB_K_INFO_DB_GB_TRANSFER         100	/* page transfer for global buf */
#define	RDB_K_INFO_DB_INCR_BACKUP         101	/* incremental backup */
#define	RDB_K_INFO_DB_ABW_MAX_BUFFERS     102	/* max buf for asyn batch write */
/*
 * V7.0 
 */
#define	RDB_K_INFO_DB_DEF_STORAGE_NAME    103	/* db default area */
#define	RDB_K_INFO_DB_DEF_TEMPLATE_NAME   104	/* * db default template */
#define	RDB_K_INFO_DB_D_ASYNCH_PREFETCH   105	/* detected asynch prefetch */
#define	RDB_K_INFO_DB_DAPF_DEPTH          106	/* depth for detected APF */
#define	RDB_K_INFO_DB_DAPF_THRESHOLD      107	/* threshold for detected APF */
#define	RDB_K_INFO_DB_CACHE_NAME          108	/* cache name */
#define	RDB_K_INFO_DB_CACHE_LIST          109	/* list of cache names */
#define	RDB_K_INFO_DB_CACHE_COUNT         110	/* count of cache slots */
#define	RDB_K_INFO_DB_CACHE_STATS         111	/* stats for cache */
#define	RDB_K_INFO_DB_CACHE_FREE          112	/* unused cache */
#define	RDB_K_INFO_DB_TEMPLATE_FREE       113	/* * unused templates */
#define	RDB_K_INFO_DB_WORKLOAD_ENABLED    114	/* is workload collection enabled? */
#define	RDB_K_INFO_DB_CARD_UPD_ENABLED    115	/* is cardinality collection enabled */
#define	RDB_K_INFO_DB_DDL_ENABLED         116	/* is DDL allowed? */
#define	RDB_K_INFO_DB_AIJ_EDIT_STRING     117	/* bckfile edit string */
#define	RDB_K_INFO_DB_ROW_CACHE_ENABLED   118	/* is row cache enabled? */
#define	RDB_K_INFO_DB_RUJ_FILE_LOCATION   119	/* directory for ruj */
#define	RDB_K_INFO_DB_TEMPLATE_ENABLED    120	/* * is area a TEMPLATE? */
/* txn-modes-enabled describes the root definitions */
#define	RDB_K_INFO_DB_TXN_MODES_ENABLED   121	/* current database txn modes */
#define	RDB_K_INFO_DB_MEMORY_MAPPING      122	/* database & cache: memory mapping */
#define	RDB_K_INFO_DB_CHECKSUM_FLAG       123	/* storage area: chksum flag setting */
#define	RDB_K_INFO_DB_SNP_CHECKSUM_FLAG   124	/* snapshot area: chksum flag setting */
#define	RDB_K_INFO_DB_CACHE_REPLACE       125	/* cache: replacement policy */
#define	RDB_K_INFO_DB_CACHE_SWEEP_INTVL   126	/* database: sweep interval */
#define	RDB_K_INFO_DB_CACHE_LOCATION      127	/* database & cache: location */
#define	RDB_K_INFO_DB_CACHE_RSVD_RECS     128	/* cache: reserved rows */
#define	RDB_K_INFO_DB_CACHE_SWEEP_RECS    129	/* cache: sweep records */
#define	RDB_K_INFO_DB_CACHE_THRESHOLDS    130	/* cache: hi/lo thresholds */
/*
 * V7.1 
 */
#define	RDB_K_INFO_DB_SEQUENCES_FREE      131	/* seq: free slots */
#define	RDB_K_INFO_DB_SORT_STATS_LIST     132
#define	RDB_K_INFO_DB_CACHE_CHKPT_TIME    133
#define	RDB_K_INFO_DB_CACHE_CHKPT_DEST    134
#define	RDB_K_INFO_DB_SECURITY_POLICY     135
#define	RDB_K_INFO_DB_SEQUENCE_COUNT      136
#define	RDB_K_INFO_DB_RUJ_BUFFER_TYPE     137
#define	RDB_K_INFO_DB_OBJECT_SYNONYMS     138	/* Are synonyms supported? */
/* txn-modes-current describes the current state which may differ */
/* from txn-modes-enabled */
#define	RDB_K_INFO_DB_TXN_MODES_CURRENT   139	/* current database txn modes */
#define	RDB_K_INFO_DB_SESSION_DEF_TXN     140	/* does session have default txn? */
#define	RDB_K_INFO_DB_NDX_TYPE            141	/* system index type */
#define	RDB_K_INFO_DB_NDX_PRF_COLLECT     142	/* system index prefix collection */
#define	RDB_K_INFO_DB_LOGMINER_ENABLED    143	/* is LogMiner enabled? */
#define	RDB_K_INFO_DB_PRESTARTED_TXN      144	/* prestarted txn mode */
#define	RDB_K_INFO_DB_GALAXY_ENABLED      145	/* is Galaxy support enabled? */
#define	RDB_K_INFO_DB_SHARED_INSTANCE     146	/* single or multiple instances */
#define	RDB_K_INFO_DB_FC_CHKPT_TXN        147	/* Fast commit Checkpoint txn interval */

/*
 * V7.1.1 
 */
#define	RDB_K_INFO_DB_CAPABILITY1         148	/* capablities bitmask */
#define	RDB_K_INFO_DB_VERSION_ORA         149	/* Ora style version string */
#define	RDB_K_INFO_DB_FULL_VERSION        150	/* Full version string */

/*
 * V7.1.3 
 */
#define	RDB_K_INFO_DB_QG_CPU_TIME         151
#define	RDB_K_INFO_DB_QG_ELAPSED_TIME     152
#define	RDB_K_INFO_DB_QG_ROW_LIMIT        153

#define	RDB_K_INFO_DB_MAX                 153

/*
 *----------------------------------------------------------------------------- 
 * RDB_K_INFO_DB_IMPL_<mumbo> 
 * Database implementation 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_INFO_DB_IMPL_UNKNOWN        0
#define	RDB_K_INFO_DB_IMPL_VMS            1
#define	RDB_K_INFO_DB_IMPL_DECRDB         RDB_K_INFO_DB_IMPL_VMS
#define	RDB_K_INFO_DB_IMPL_RDB            RDB_K_INFO_DB_IMPL_VMS
#define	RDB_K_INFO_DB_IMPL_ELAN           2
#define	RDB_K_INFO_DB_IMPL_ELAN_DEV       3
#define	RDB_K_INFO_DB_IMPL_DDAL_Y         4
#define	RDB_K_INFO_DB_IMPL_ELAN_Y         5
#define	RDB_K_INFO_DB_IMPL_JRI            6
#define	RDB_K_INFO_DB_IMPL_REM_CLIENT     RDB_K_INFO_DB_IMPL_JRI
#define	RDB_K_INFO_DB_IMPL_JSV            7
#define	RDB_K_INFO_DB_IMPL_REM_SERVER     RDB_K_INFO_DB_IMPL_JSV
#define	RDB_K_INFO_DB_IMPL_SERVER         8
#define	RDB_K_INFO_DB_IMPL_MACHINE        9
#define	RDB_K_INFO_DB_IMPL_VIDA           10
#define	RDB_K_INFO_DB_IMPL_IDB_PC         11
#define	RDB_K_INFO_DB_IMPL_IDB            12
#define	RDB_K_INFO_DB_IMPL_VIDA2_VMS      13
#define	RDB_K_INFO_DB_IMPL_VIDA2_MVS      14
#define	RDB_K_INFO_DB_IMPL_CICS           15
#define	RDB_K_INFO_DB_IMPL_DB2            16
/* RdbAccess for Oracle client */
#define	RDB_K_INFO_DB_IMPL_VIDAOC         17
/* RdbAccess for Oracle server */
#define	RDB_K_INFO_DB_IMPL_VIDAOS         18
/* Oracle Version number */
#define	RDB_K_INFO_DB_IMPL_ORACLE         19
#define	RDB_K_INFO_DB_IMPL_NSDS           20
#define	RDB_K_INFO_DB_IMPL_DAF            RDB_K_INFO_DB_IMPL_NSDS
#define	RDB_K_INFO_DB_IMPL_BRIDGE         21
#define	RDB_K_INFO_DB_IMPL_SERDB          22
#define	RDB_K_INFO_DB_IMPL_DBI            23
#define	RDB_K_INFO_DB_IMPL_EDASQL         24
#define	RDB_K_INFO_DB_IMPL_SQL400         25
#define	RDB_K_INFO_DB_IMPL_SQLACC         26
#define	RDB_K_INFO_DB_IMPL_SYBASE         27
#define	RDB_K_INFO_DB_IMPL_LSYB           28	/* Link to Sybase */
#define	RDB_K_INFO_DB_IMPL_LEDA           29	/* Link to EDA/SQL */
#define	RDB_K_INFO_DB_IMPL_LDB2           30
#define	RDB_K_INFO_DB_IMPL_LORA           31	/* Link to Oracle */
#define	RDB_K_INFO_DB_IMPL_SQLNK          32
#define	RDB_K_INFO_DB_IMPL_ODBC           33
#define	RDB_K_INFO_DB_IMPL_NREL           34
#define	RDB_K_INFO_DB_IMPL_LRED           35	/* Link to ODBC */

#define	RDB_K_INFO_DB_IMPL_MAX            35

/*
 *----------------------------------------------------------------------------- 
 * RDB_K_INFO_DB_CLASS_<mumbo> 
 * Database classes 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_INFO_DB_CLASS_DBMS          1
#define	RDB_K_INFO_DB_CLASS_Y_VALVE       2
#define	RDB_K_INFO_DB_CLASS_REM_INT       3
#define	RDB_K_INFO_DB_CLASS_REM_SRVR      4

/*
 *----------------------------------------------------------------------------- 
 * RDB_K_INFO_REQ_<mumbo> 
 * Request identifiers 
 * Note: RDB_K_INFO_REQ items cause information to be returned from 
 * RDB_REQUEST_INFO and RDB_COMPILE_REQUEST.  RDB_K_SET_REQ items are ignored 
 * by RDB_REQUEST_INFO, but cause parameters to be set by RDB_COMPILE_REQUEST. 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_INFO_REQ_MIN                RDB_K_INFO_MIN

/*
 * Tags start at 4 because 1-3 is used by the generic tags 
 */
/* Number different msg types */
#define	RDB_K_INFO_REQ_NUM_MSGS           4
/* Largest msg type */
#define	RDB_K_INFO_REQ_MAX_MSG            5
/* Maximum send msg length */
#define	RDB_K_INFO_REQ_MAX_SEND           6
/* Maximum receive msg length */
#define	RDB_K_INFO_REQ_MAX_RECEIVE        7
/* Current request state */
#define	RDB_K_INFO_REQ_STATE              8
/* Current message for send */
#define	RDB_K_INFO_REQ_MSG_NUMBER         9
/* Send message length */
#define	RDB_K_INFO_REQ_MSG_SIZE           10
/* Use optimizer number. */
#define	RDB_K_INFO_REQ_COST               11
/* Estimated # of rows returned */
#define	RDB_K_INFO_REQ_EST_ROWS           12
/* Return type of strategy used */
#define	RDB_K_INFO_REQ_OPT_PREF           13
/* Set type of strategy desired (see also the RDB_K_INFO_OPT_PREF* literals) */
#define	RDB_K_SET_REQ_OPT_PREF            14
/* limit on query compile time */
#define	RDB_K_SET_REQ_MAX_COMP_TIME       15
/* limit on rows for query */
#define	RDB_K_SET_REQ_MAX_ROWS            16
/* Request used for UPDATE */
#define	RDB_K_SET_REQ_FOR_UPDATE          17
/* Is request used for UPDATE? */
#define	RDB_K_INFO_REQ_FOR_UPDATE         18
/* User specified object name */
#define	RDB_K_SET_REQ_NAME                19
/* limit on compile CPU time */
#define	RDB_K_SET_REQ_MAX_COMP_CPU        20
/* Request changes transaction state */
#define	RDB_K_SET_REQ_TRANS_ACTION        21
/* Does request changes transaction state? */
#define	RDB_K_INFO_REQ_TRANS_ACTION       22
/* Pseudo module name */
#define	RDB_K_SET_REQ_MODULE_NAME         23
/* Routine name */
#define	RDB_K_SET_REQ_ROUTINE_NAME        24
/* PARAM: NULL semantics */
#define	RDB_K_SET_REQ_NULL_PARAMETERS     25
/* PARAM3: length in char or octets */
#define	RDB_K_SET_REQ_CHAR_LENGTH         26
/* Outline Mode */
#define	RDB_K_SET_REQ_OUTL_MODE           27
/* Outline Option */
#define	RDB_K_SET_REQ_OUTL_OPTION         28
/* Outline Name */
#define	RDB_K_SET_REQ_OUTL_NAME           29
/* Warn if string trunc occurs during GET */
#define	RDB_K_SET_REQ_WARN_TRUNC          30
/* Warn if nulls elim in set function */
#define	RDB_K_SET_REQ_WARN_ELIM_NULL      31
/* Hold cursor open across rollback or commit */
#define	RDB_K_SET_REQ_HOLD_OPEN           32
/* Item contains an ASCIL OBLR buffer */
#define	RDB_K_SET_REQ_OUTL_OBLR           33
/* Outline Compliance (see RDB_K_INFO_OUTL_COMPL_* values also) */
#define	RDB_K_SET_REQ_OUTL_COMPL          34
/* Force query to use SEQUENTIAL */
#define	RDB_K_SET_REQ_OPT_SEQ             35
/* Query governor on QUERY TIME */
#define	RDB_K_SET_REQ_MAX_QRY_TIME        36
/* Query governor on QUERY CPU */
#define	RDB_K_SET_REQ_MAX_QRY_CPU         37
/* Query governor on query I/O */
#define	RDB_K_SET_REQ_MAX_QRY_IO          38
/* with sampled/aggressive selectivity */
#define	RDB_K_SET_REQ_OPT_SEL             39
/* mark request as a compound statement */
#define	RDB_K_SET_REQ_IS_COMPOUND         40
/* Cursor name */
#define	RDB_K_SET_REQ_CURSOR_NAME         41
/* Mark request as system query */
#define	RDB_K_SET_REQ_SYSTEM_QUERY        42
/* Enable/disable AUTOMATIC TRANSLATION for this query */
#define	RDB_K_SET_REQ_AUTO_TRANSLATE      43

#define	RDB_K_INFO_REQ_MAX                43

/*
 *----------------------------------------------------------------------------- 
 * RDB_K_INFO_REQ_STATE_<mumbo> 
 * Request states 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_INFO_REQ_STATE_ACTIVE       2
#define	RDB_K_INFO_REQ_STATE_INACTIVE     3
#define	RDB_K_INFO_REQ_STATE_SEND         4
#define	RDB_K_INFO_REQ_STATE_RECEIVE      5
#define	RDB_K_INFO_REQ_STATE_SELECT       6
#define	RDB_K_INFO_REQ_STATE_MAX          7

/*
 *----------------------------------------------------------------------------- 
 * RDB_K_INFO_TRA_<mumbo> 
 * Transaction information 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_INFO_TRA_MIN                RDB_K_INFO_MIN

/*
 * Tags start at 4 because 1-3 is used by the generic tags 
 */
/* Transaction id */
#define	RDB_K_INFO_TRA_ID                 4
/* Type of transaction */
#define	RDB_K_INFO_TRA_TYPE               5
/* Isolation Level */
#define	RDB_K_INFO_TRA_ISOLATION_LEVEL    6
#define	RDB_K_INFO_TRA_MAX                6

/*
 *----------------------------------------------------------------------------- 
 * RDB_K_INFO_BLOB_<mumbo> 
 * Segmented string (Blob) information 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_INFO_BLOB_MIN               RDB_K_INFO_MIN

/*
 * Tags start at 4 because 1-3 is used by the generic tags 
 */
#define	RDB_K_INFO_BLOB_NUM_SEGMENTS      4
#define	RDB_K_INFO_BLOB_MAX_SEGMENT       5
#define	RDB_K_INFO_BLOB_TOTAL_LENGTH      6
#define	RDB_K_INFO_BLOB_CURRENT_SEGMENT   7
#define	RDB_K_INFO_BLOB_MAX               7

/*
 *----------------------------------------------------------------------------- 
 * RDB_K_BLOB_<mumbo> 
 * Segmented string (Blob) parameter structure 
 *----------------------------------------------------------------------------- 
 */

/* name of the table */
#define	RDB_K_BLOB_TABLE_NAME             4
/* name of the column */
#define	RDB_K_BLOB_COLUMN_NAME            5
/* name of the cursor */
#define	RDB_K_BLOB_CURSOR_NAME            6
/* associated request handle */
#define	RDB_K_BLOB_REQUEST_HANDLE         7
/* name of containing module */
#define	RDB_K_BLOB_MODULE_NAME            8
/* id of scratch table (needs RDB_K_BLOB_MODULE_NAME) */
#define	RDB_K_BLOB_SCRATCH_TABLE_ID       9
#define	RDB_K_BLOB_MAX                    9

/*
 *----------------------------------------------------------------------------- 
 * RDB_K_LOB_MODE_ tags 
 * Describes the semantics of a segmented string (aka LOB) data type 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_LOB_MODE_DSRI               0
#define	RDB_K_LOB_MODE_ORA                1
#define	RDB_K_LOB_MODE_SQL99              2
#define	RDB_K_LOB_MODE_LIST_UDT           3

/*
 *----------------------------------------------------------------------------- 
 * RDB_K_TXN_<mumbo> 
 * Transaction parameter structure 
 *----------------------------------------------------------------------------- 
 */

/* hand for database */
#define	RDB_K_TXN_DB_HANDLE               4
/* attributes (TPB) */
#define	RDB_K_TXN_ATTRIBUTES              5
/* 2pc transaction id */
#define	RDB_K_TXN_TRANSACTION_ID          6
/* enable/disable initialization of txn handle */
#define	RDB_K_TXN_INIT_HANDLE             7

#define	RDB_K_TXN_MAX                     7


/*
 * Information sub-options 
 */

/*
 *----------------------------------------------------------------------------- 
 * Storage area access modes 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_INFO_STAREA_MODE_RW         0
#define	RDB_K_INFO_STAREA_MODE_RO         1
#define	RDB_K_INFO_STAREA_MODE_WORM       2

/*
 *----------------------------------------------------------------------------- 
 * Settings accepted for RDB_K_INFO_REQ_OPT_SET_PREF 
 * These values correspond to the setting of the flag REQ_V_FAST_FIRST_FLAG 
 * and various other Rdb attributes for the request compile 
 *----------------------------------------------------------------------------- 
 */
/* TOTAL TIME optimization */
#define	RDB_K_INFO_OPT_PREF_TT            0
/* FAST FIRST optimization */
#define	RDB_K_INFO_OPT_PREF_FF            1
/* NONE (no preferences) */
#define	RDB_K_INFO_OPT_PREF_NONE          2
/* TOTAL TIME - override query outline */
#define	RDB_K_INFO_OPT_PREF_TT_OVERRIDE   3
/* FAST FIRST - override query outline */
#define	RDB_K_INFO_OPT_PREF_FF_OVERRIDE   4
/* NONE - override query outline */
#define	RDB_K_INFO_OPT_PREF_NN_OVERRIDE   5
/* SELECTIVITY = SAMPLED */
#define	RDB_K_INFO_OPT_PREF_SAMPLED       6
/* SELECTIVITY = AGGRESSIVE (aka Oracle RDBMS) */
#define	RDB_K_INFO_OPT_PREF_AGGRESSIVE    7

/*
 *----------------------------------------------------------------------------- 
 * Settings accepted for RDB_K_INFO_REQ_OPT_SET_COMPL 
 *----------------------------------------------------------------------------- 
 */
/* Compliance OPTIONAL */
#define	RDB_K_INFO_OUTL_COMPL_OPTIONAL    0
/* Compliance MANDATORY */
#define	RDB_K_INFO_OUTL_COMPL_MANDATORY   1

/*
 *----------------------------------------------------------------------------- 
 * Index values for the RDB_K_INFO_DB_MEMORY_MAPPING result buffer 
 *----------------------------------------------------------------------------- 
 */
/* Subtags for MEMORY_MAPPING */
#define	RDB_K_INFO_MEMMAP_SYSBUF          0
#define	RDB_K_INFO_MEMMAP_VLM             1
#define	RDB_K_INFO_MEMMAP_WINDOW_CNT      2
#define	RDB_K_INFO_MEMMAP_RESIDENT        3
#define	RDB_K_INFO_MEMMAP_WORKING_SET     4


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_EXT_<mumbo> 
 *   RDB_K_EXT_<yyy>_<mumbo> 
 *   This section contains the extension tags used in calls to RDB_EXTENSION. 
 *--------------------------------------------------------------------------- 
 */

/*
 *----------------------------------------------------------------------------- 
 * Call indices 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_MIN                     1
#define	RDB_K_EXT_ANALYZE                 1
#define	RDB_K_EXT_MONITOR_SHOW            2
#define	RDB_K_EXT_MONITOR_OPER            3
#define	RDB_K_EXT_RESOURCE_SHOW           4
#define	RDB_K_EXT_CONVERT_FIXUP           5
#define	RDB_K_EXT_GARBAGE_COLLECT         RDB_K_EXT_CONVERT_FIXUP	/* reused tag */
#define	RDB_K_EXT_VERIFY                  6	/* Rdb/ELN - REUSE */
#define	RDB_K_EXT_DELPRC_STREAM           7
#define	RDB_K_SWEEP                       RDB_K_EXT_DELPRC_STREAM	/* reused tag */
#define	RDB_K_EXT_PARSE_ACL               8
#define	RDB_K_EXT_FORMAT_ACL              9
#define	RDB_K_EXT_RETURN_ACCESS           10
#define	RDB_K_EXT_CHECK_CONSTRAINTS       11
#define	RDB_K_EXT_SET_TXN_CURRENT         12
#define	RDB_K_EXT_OLDEST_TRANSACTION      RDB_K_EXT_SET_TXN_CURRENT	/* resued tag */
#define	RDB_K_EXT_CHECK_ACCESS            13
#define	RDB_K_EXT_SET_AUDIT               14
/* Parse ANSI SQL date/time literal */
#define	RDB_K_EXT_PARSE_DATETIME          15
/* Format ANSI SQL date/time literal */
#define	RDB_K_EXT_FORMAT_DATETIME         16
/* get character set information */
#define	RDB_K_EXT_MIA_SYSTEM_INFO         17
/* Pack date/time vector to quadword */
#define	RDB_K_EXT_PACK_DATETIME           18
/* Unpack quadword to date/time vector */
#define	RDB_K_EXT_UNPACK_DATETIME         19
/* Establish default transaction TPB */
#define	RDB_K_EXT_SET_DEFAULT_TRANS       20
/* Establish default module context (includes transaction and more) */
#define	RDB_K_EXT_MODULE_SETUP            20
/* Get system information */
#define	RDB_K_EXT_SYSTEM_INFO             21
/* Get/Set engine information */
#define	RDB_K_EXT_ENGINE_INFO             22
/* Get/Set dispatch information */
#define	RDB_K_EXT_DISPATCH_INFO           23
/* Check external routine existence */
#define	RDB_K_EXT_CHECK_EXT_ROUTINE       24
/* Process TRACE flags set and show */
#define	RDB_K_EXT_SET_TRACE_FLAGS         25

/* new ext functions for controlling XA distributed transactions */
#define	RDB_K_EXT_RECOVER_XA              26
#define	RDB_K_EXT_COMMIT_XA               27
#define	RDB_K_EXT_ROLLBACK_XA             28

/* new extension functions for client context management (ext funnctions) */
#define	RDB_K_EXT_CREATE_CLIENT_CTX       29
#define	RDB_K_EXT_DELETE_CLIENT_CTX       30
#define	RDB_K_EXT_SET_CLIENT_CTX          31
#define	RDB_K_EXT_GET_CLIENT_CTX          32

/* allows client to register callback routine (used for transaction */
/* cleanup after a distributed TM commits/rollsback a transaction) */
#define	RDB_K_EXT_SET_TXN_CALLBACK        33

/* these rdb_extension functions are used to allow fine tuning of the */
/* deferred index updates (see TPB_K_DEFER_INDEX_UPDATES) */
#define	RDB_K_EXT_PREP_DEFERRED_INDEX     34
#define	RDB_K_EXT_UPDATE_DEFERRED_INDEX   35

/* Allow user to pass extra reserving clauses */
#define	RDB_K_EXT_RESERVE_TABLE           36

/* Check the BLR fragment */
#define	RDB_K_EXT_PARSE_VALEXP_BLR        37

/* Allow user to pass extra evaluating clauses */
#define	RDB_K_EXT_EVALUATE_CONSTRAINT     38

/* Establish the SQL language level (for semantic support) */
#define	RDB_K_EXT_SET_SQL_LEVEL           39

/* Terminate IMPORT DATABASE scope */
#define	RDB_K_EXT_BEGIN_IMPORT_DATABASE   40
#define	RDB_K_EXT_END_IMPORT_DATABASE     41

/* Return the dtype of the BLR expression */
#define	RDB_K_EXT_GET_VALEXP_DTYPE        42

/* Access the quietpoint lock */
#define	RDB_K_EXT_REQUEST_QUIET_POINT     43
#define	RDB_K_EXT_RELEASE_QUIET_POINT     44

/* Enable/Disable the query governor */
#define	RDB_K_EXT_QUERY_GOVERNOR          45

/* Modify the AIP */
#define	RDB_K_EXT_MODIFY_AIP              46

#define	RDB_K_EXT_MAX                     46


/*
 *----------------------------------------------------------------------------- 
 * Specific call parameters 
 * The value 1-4 is reserved for the RDB_K_INFO_<mumbo> tags 
 * All tags start at 5 
 *----------------------------------------------------------------------------- 
 */

/*
 *----------------------------------------------------------------------------- 
 * tags specific to Analyze called through RDB_EXTENSION 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_ANALYZE_MIN             5
#define	RDB_K_EXT_PAGE_CNT                5
#define	RDB_K_EXT_PAGE_SIZE               6
#define	RDB_K_EXT_REC_LEN                 7
#define	RDB_K_EXT_REC_CNT                 8
#define	RDB_K_EXT_FRAG_CNT                9
#define	RDB_K_EXT_LEN_AVAIL               10
#define	RDB_K_EXT_LEN_USED                11
#define	RDB_K_EXT_USED_HIST               12
#define	RDB_K_EXT_NODE_LEN                13
#define	RDB_K_EXT_DUP_LEN                 14
#define	RDB_K_EXT_NODE_CNT                15
#define	RDB_K_EXT_DUP_CNT                 16
#define	RDB_K_EXT_NODE_LEVEL              17

#define	RDB_K_EXT_ANALYZE_MAX             17

/*
 *----------------------------------------------------------------------------- 
 * tags specific to ACL 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_ACL_MIN                 5
#define	RDB_K_EXT_ACL_STR                 5
#define	RDB_K_EXT_ACL_ENT                 6
#define	RDB_K_EXT_ACL_WIDTH               7
#define	RDB_K_EXT_ACL_TERM                8
#define	RDB_K_EXT_ACL_INDENT              9
#define	RDB_K_EXT_ACL_ERRPOS              10
#define	RDB_K_EXT_ACL_DB_ACCESS           11
#define	RDB_K_EXT_ACL_REL_ACCESS          12
#define	RDB_K_EXT_ACL_ACCESS              13
#define	RDB_K_EXT_ACL_FLD_ACCESS          14
#define	RDB_K_EXT_ACL_PRIV_NAMES          15
#define	RDB_K_EXT_ACL_FORMAT              16
#define	RDB_K_EXT_ACL_TYPE_ANSI           17
#define	RDB_K_EXT_ACL_DB_ACCNOVR          18
#define	RDB_K_EXT_ACL_REL_ACCNOVR         19
#define	RDB_K_EXT_ACL_FLD_ACCNOVR         20
#define	RDB_K_EXT_ACL_MOD_ACCESS          21
#define	RDB_K_EXT_ACL_MOD_ACCNOVR         22
#define	RDB_K_EXT_ACL_RTN_ACCESS          23
#define	RDB_K_EXT_ACL_RTN_ACCNOVR         24
#define	RDB_K_EXT_ACL_SEQ_ACCESS          25
#define	RDB_K_EXT_ACL_SEQ_ACCNOVR         26
#define	RDB_K_EXT_ACL_PARSE_REVOKE        27

#define	RDB_K_EXT_ACL_MAX                 27

/*
 *----------------------------------------------------------------------------- 
 * tags specific to SET AUDIT 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_AUD_MIN                 5
#define	RDB_K_EXT_AUD_JNL                 5
#define	RDB_K_EXT_AUD_ALA                 6
#define	RDB_K_EXT_AUD_FIRST               7
#define	RDB_K_EXT_AUD_FLUSH               8
#define	RDB_K_EXT_AUD_TYPE                9
#define	RDB_K_EXT_AUD_PURGE               10
#define	RDB_K_EXT_AUD_PRIV                11
#define	RDB_K_EXT_AUD_START               12
#define	RDB_K_EXT_AUD_STOP                13
#define	RDB_K_EXT_AUD_ENABLE              14
#define	RDB_K_EXT_AUD_DISABLE             15
#define	RDB_K_EXT_AUD_RMU                 16
#define	RDB_K_EXT_AUD_PROT                17
#define	RDB_K_EXT_AUD_IDENT               18
#define	RDB_K_EXT_AUD_ACE                 19
#define	RDB_K_EXT_AUD_DACCESS             20
#define	RDB_K_EXT_AUD_MACCESS             21
#define	RDB_K_EXT_AUD_ALL                 22
#define	RDB_K_EXT_AUD_SCHEMA              23
#define	RDB_K_EXT_AUD_TABLE               24
#define	RDB_K_EXT_AUD_COLUMN              25
#define	RDB_K_EXT_AUD_NONE                26
#define	RDB_K_EXT_AUD_NAME                27
#define	RDB_K_EXT_AUD_RMU_CMD             28

#define	RDB_K_EXT_AUD_MAX                 28

/*
 * These literals are used to define the legal values for the 
 * RDB_K_EXT_AUD_TYPE tag 
 */
#define	RDB_K_AUDIT_TYPE_AUDIT            1
#define	RDB_K_AUDIT_TYPE_ALARM            2
#define	RDB_K_AUDIT_TYPE_BOTH             3

/*
 *----------------------------------------------------------------------------- 
 * Tags specific to parsing datatypes. 
 *----------------------------------------------------------------------------- 
 */
/* Minimum value */
#define	RDB_K_EXT_DT_MIN                  5
/* Literal string to parse */
#define	RDB_K_EXT_DT_STRING               5
/* Subtype of literal */
#define	RDB_K_EXT_DT_SUB_TYPE             6
/* Value after parse */
#define	RDB_K_EXT_DT_VALUE                7
/* Seconds precision */
#define	RDB_K_EXT_DT_SCALE                8
/* Interval leading field precision */
#define	RDB_K_EXT_DT_ILF_PREC             9
/* Vector of date/time fields */
#define	RDB_K_EXT_DT_VECTOR               10
/* data type */
#define	RDB_K_EXT_DT_TYPE                 11
/* length, collation */
#define	RDB_K_EXT_DT_LENGTH               12
/* collating sequence */
#define	RDB_K_EXT_DT_COLLATION            13

/* Maximum value */
#define	RDB_K_EXT_DT_MAX                  13

/*
 *----------------------------------------------------------------------------- 
 * Tags specific to module setup 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_TXN_MIN                 5
/* Default tpb */
#define	RDB_K_EXT_TXN_DEFAULT_TPB         5
/* Pseudo module name */
#define	RDB_K_EXT_TXN_MODULE_NAME         6
/* Temporary DDL for this module */
#define	RDB_K_EXT_TXN_TEMP_DDL            7

#define	RDB_K_EXT_TXN_MAX                 7

/*
 *----------------------------------------------------------------------------- 
 * Tags specific to SET_SQL_LEVEL 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_LVL_MIN                 5
/* Dialect level */
#define	RDB_K_EXT_LVL_LEVEL               5
/* Autotranslate */
#define	RDB_K_EXT_LVL_AUTOTRANS           6

#define	RDB_K_EXT_LVL_MAX                 6

/*
 *----------------------------------------------------------------------------- 
 * Tags specific to QUERY_GOVERNOR 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_QG_MIN                  5
/* Limit CPU time            */
#define	RDB_K_EXT_QG_CPU_TIME             5
/* Limit ELAPSED time */
#define	RDB_K_EXT_QG_ELAPSED_TIME         6
/* Limit rows */
#define	RDB_K_EXT_QG_RETURNED_ROWS        7

#define	RDB_K_EXT_QG_MAX                  7

/*
 *----------------------------------------------------------------------------- 
 * Tags specific to RDB_K_EXT_MODIFY_AIP 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_MODAIP_MIN              5
#define	RDB_K_EXT_MODAIP_LAREA_ID         5
#define	RDB_K_EXT_MODAIP_REBUILD_SPAMS    6
#define	RDB_K_EXT_MODAIP_LAREA_NAME       7
#define	RDB_K_EXT_MODAIP_LAREA_RENAME     8
#define	RDB_K_EXT_MODAIP_TABLE_NAME       9
#define	RDB_K_EXT_MODAIP_THRESHOLDS       10
#define	RDB_K_EXT_MODAIP_REC_LENGTH       11

#define	RDB_K_EXT_MODAIP_MAX              11

/*
 *----------------------------------------------------------------------------- 
 * tags specific to database system functions 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_SYS_MIN                 5
/* Database name passed through the handle */
#define	RDB_K_EXT_SYS_DB_NAME             5
/* temp name */
#define	RDB_K_EXT_SYS_HND_DB_NAME         RDB_K_EXT_SYS_DB_NAME
/* Database type information */
#define	RDB_K_EXT_SYS_DB_TYPE             6
#define	RDB_K_EXT_SYS_MAX                 6


/*
 *----------------------------------------------------------------------------- 
 * tags specific to database engine functions 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_ENG_MIN                 5
/* Trace callback address */
#define	RDB_K_EXT_ENG_TRC_CB_ADDR         5
/* Trace callback param */
#define	RDB_K_EXT_ENG_TRC_CB_PARAM        6
/* Env buffer address */
#define	RDB_K_EXT_ENG_ENV_BUF_ADDR        7
/* Trace callback param */
#define	RDB_K_EXT_ENG_ENV_BUF_LEN         8
/* CPID for Windows NT */
#define	RDB_K_EXT_ENG_CPID_VALUE          9

#define	RDB_K_EXT_ENG_MAX                 9


/*
 *----------------------------------------------------------------------------- 
 * tags specific to dispatch functions 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_DISP_MIN                5
/* receive prefetch count */
#define	RDB_K_EXT_DISP_RCV_PREFETCH       5
/* segmented string prefetch count */
#define	RDB_K_EXT_DISP_SGS_PREFETCH       6
/* let call know if the asynch feature is enabled */
#define	RDB_K_EXT_DISP_ASYNCH_ENABLED     7

#define	RDB_K_EXT_DISP_MAX                7



/*
 *----------------------------------------------------------------------------- 
 * tags specific to extended character set support (MIA/NTT) 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_CSET_MIN                5
#define	RDB_K_EXT_CSET_BY_ID              5
#define	RDB_K_EXT_CSET_BY_NAME            6
#define	RDB_K_EXT_CSET_LIST               7
#define	RDB_K_EXT_CSET_ID                 8
#define	RDB_K_EXT_CSET_NAME               9
#define	RDB_K_EXT_CSET_VERSION            10
#define	RDB_K_EXT_CSET_FORM_OF_USE        11
#define	RDB_K_EXT_CSET_NAMES_CSET         12
#define	RDB_K_EXT_CSET_MIN_OCTETS         13
#define	RDB_K_EXT_CSET_MAX_OCTETS         14
#define	RDB_K_EXT_CSET_STR_WILD           15
#define	RDB_K_EXT_CSET_CHAR_WILD          16
#define	RDB_K_EXT_CSET_BLANK              17
#define	RDB_K_EXT_CSET_ASSOC_CSET         18
#define	RDB_K_EXT_CSET_FLAGS              19
#define	RDB_K_EXT_CSET_TRANS              20
#define	RDB_K_EXT_CSET_MAX                20

/*
 *----------------------------------------------------------------------------- 
 * tags specific to external routines 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_RTX_MIN                 5
/* Routine name */
#define	RDB_K_EXT_RTX_ROUTINE_NAME        5
/* Error type */
#define	RDB_K_EXT_RTX_ERROR_TYPE          6
/* Image name */
#define	RDB_K_EXT_RTX_IMAGE_NAME          7
/* Body entry point name */
#define	RDB_K_EXT_RTX_BODY_ENT_NAME       8
/* Notify entry point name */
#define	RDB_K_EXT_RTX_NTFY_ENT_NAME       9
/* Error text */
#define	RDB_K_EXT_RTX_ERROR_TEXT          10
#define	RDB_K_EXT_RTX_MAX                 10

/*
 *----------------------------------------------------------------------------- 
 * Rdb_Extension tags specific to RDB_K_EXT_SET_TRACE_FLAGS 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_FLAG_MIN                5
/* Input flag string */
#define	RDB_K_EXT_FLAG_STRING             5
/* Ask for current flag setting, prefix in out buffer */
#define	RDB_K_EXT_FLAG_SHOW               6

#define	RDB_K_EXT_FLAG_MAX                6

/*
 *----------------------------------------------------------------------------- 
 * Rdb_Extension tags specific to XA distributed transaction management: 
 * RDB_K_EXT_RECOVER_XA, RDB_K_EXT_COMMIT_XA and RDB_K_EXT_ROLLBACK_XA 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_XA_TID                  5
#define	RDB_K_EXT_XA_MAXCOUNT             6
#define	RDB_K_EXT_XA_FLAGS                7

#define	RDB_K_EXT_XA_MAX                  7

/*
 *----------------------------------------------------------------------------- 
 * Rdb_Extension tags specific to external function client management: 
 * RDB_K_EXT_CREATE_CLIENT_CTX, RDB_K_EXT_DELETE_CLIENT_CTX, 
 * RDB_K_EXT_SET_CLIENT_CTX and RDB_K_EXT_GET_CLIENT_CTX 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_CC_PARENT               5
#define	RDB_K_EXT_CC_UIC                  6
#define	RDB_K_EXT_CC_USERNAME             7

#define	RDB_K_EXT_CC_MAX                  7

/*
 *----------------------------------------------------------------------------- 
 * Tags specific to verify constraint 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_EXT_VFYC_MIN                5
#define	RDB_K_EXT_VFYC_TABLE_NAME         5
#define	RDB_K_EXT_VFYC_CONSTRAINT_NAME    6
#define	RDB_K_EXT_VFYC_EXCLUDE_UNIQUE     7
#define	RDB_K_EXT_VFYC_INCLUDE_DISABLED   8
#define	RDB_K_EXT_VFYC_FAILURE_TEXT       9
#define	RDB_K_EXT_VFYC_TRUNCATE           10

#define	RDB_K_EXT_VFYC_MAX                10


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_CSET_<mumbo> 
 *   This section contains the MIA character set ids, etc. (as per DEC STD 169 
 *   compliance) 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_CSET_MCS                    0
/* Synonym for MCS */
#define	RDB_K_CSET_DEC_MCS                RDB_K_CSET_MCS
#define	RDB_K_CSET_ISOLATIN1              1
#define	RDB_K_CSET_ISOLATIN2              2
#define	RDB_K_CSET_ISOLATINARABIC         3
#define	RDB_K_CSET_ISOLATINGREEK          4
#define	RDB_K_CSET_ISOLATINCYRILLIC       5
#define	RDB_K_CSET_ISOLATINHEBREW         6
#define	RDB_K_CSET_ISOLATIN3              7
#define	RDB_K_CSET_ISOLATIN4              8
#define	RDB_K_CSET_ISOLATIN5              9
#define	RDB_K_CSET_ISOLATIN6              10
#define	RDB_K_CSET_ISOLATIN9              13
#define	RDB_K_CSET_KATAKANA               32
#define	RDB_K_CSET_KANJI                  64
#define	RDB_K_CSET_HANZI                  65
#define	RDB_K_CSET_KOREAN                 66
#define	RDB_K_CSET_HANYU                  67
#define	RDB_K_CSET_DTSCS                  68
#define	RDB_K_CSET_DEC_KANJI              96
#define	RDB_K_CSET_DEC_HANZI              97
#define	RDB_K_CSET_DEC_KOREAN             98
#define	RDB_K_CSET_DEC_HANYU              99
#define	RDB_K_CSET_DEC_SICGCC             100
#define	RDB_K_CSET_GB18030                101

#define	RDB_K_CSET_ASCII                  256
#define	RDB_K_CSET_SIMPLE_LATIN           257
#define	RDB_K_CSET_ARABIC                 258
         
/*
 * Character sets for Windows 
 */
#define	RDB_K_CSET_WIN_LATIN1             512
#define	RDB_K_CSET_WIN_LATIN2             513
#define	RDB_K_CSET_WIN_ARABIC             514
#define	RDB_K_CSET_WIN_GREEK              515
#define	RDB_K_CSET_WIN_CYRILLIC           516
#define	RDB_K_CSET_WIN_HEBREW             517

/*
 * Character sets for DOS 
 */
#define	RDB_K_CSET_DOS_LATINUS            1024
#define	RDB_K_CSET_DOS_LATIN1             1025

/*
 * Special character sets 
 */
#define	RDB_K_CSET_HEX                    2048

/*
 * UNICODE character sets 
 */
#define	RDB_K_CSET_UNICODE                4096	/* standard UCS-2 */
#define	RDB_K_CSET_UTF8                   4097	/* UTF-8 Unicode 2.0 */
#define	RDB_K_CSET_AL24UTFFSS             4098	/* UTF-8 Unicode 1.1 */

/*
 * Rdb specific character sets 
 */
#define	RDB_K_CSET_SHIFT_JIS              32760	/* %X7ff8 */
#define	RDB_K_CSET_MS_KANJI               RDB_K_CSET_SHIFT_JIS	/* synonym: SHIFT_JIS */
#define	RDB_K_CSET_DEVANAGARI             32761	/* %X7ff9 */
#define	RDB_K_CSET_TACTIS                 32762	/* %X7ffa */
#define	RDB_K_CSET_THAI                   RDB_K_CSET_TACTIS	/* synonym */
#define	RDB_K_CSET_UJIS                   32763	/* %X7ffb */
#define	RDB_K_CSET_PSEUDO_MOCS            32764	/* %X7ffc */
#define	RDB_K_CSET_BIG5                   32766	/* %X7ffe */
#define	RDB_K_CSET_COMPOUND_STRING        RDB_K_CSET_BIG5	/* obsolete */
#define	RDB_K_CSET_UNSPECIFIED            32767	/* %X7fff */

/*
 * MIA Form of use constants 
 * Note: MIXED are ODD, and FIXED are even values 
 */
#define	RDB_K_CSET_FOU_MIN                0
/* fixed octet - MCS style encoding */

#define	RDB_K_CSET_FIXED_OCTET            0

/* mixed octet + DEC '_and_ascii' practice */
#define	RDB_K_CSET_MIXED_OCTET            1

/* fixed octet - no upcasing allowed */
#define	RDB_K_CSET_FIXED_NO_UP            2

/* as in MIXED_OCTET plus SS2 as introducer to alternate single octet */
/* encoding */
#define	RDB_K_CSET_MIXED_SS2              3

/* fixed octet - upcasing only G1 ( 7 bit ) */
#define	RDB_K_CSET_FIXED_UP_G1            4

/* as in MIXED_SS2 plus SS3 as introducer to alternate double character */
/* encoding */
#define	RDB_K_CSET_MIXED_SS3              5

/* fixed octet - other */
#define	RDB_K_CSET_FIXED_OTHER            6

/* as in MIXED_OCTET plus %X'C2CB' as introducer to alternate double */
/* character encoding */
#define	RDB_K_CSET_MIXED_C2CB             7

/* mixed with leading tag ( compound str ) */
#define	RDB_K_CSET_MIXED_TAG              9

/* Mixed with SHIFT IN/OUT to specify alternate character encoding */
#define	RDB_K_CSET_MIXED_SHIFT            11

/* Mixed with binary pattern of high order bits specifying char size */
#define	RDB_K_CSET_MIXED_110              13

/* Mixed with 2nd octet in range %X'30' - %X'39' specifying 4 octet */
#define	RDB_K_CSET_MIXED_GB18030          15
 
/* make sure same as largest FOU constant */
#define	RDB_K_CSET_FOU_MAX                15

/*
 * CSET flag bit values 
 */
#define	RDB_V_CSET_CONTAINS_ASCII         0
/* all octets of the space char */
#define	RDB_V_CSET_SPACE_OCTET_REPEATS    1

/*
 * CSET max octets 
 */
/* Largest 'character' octet size */
#define	RDB_K_CSET_MAX_OCTETS_PER_CHAR    4


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   RDB_K_SUB_TYPE_<mumbo> 
 *   This section contains the tags needed by RDB_FIELD_SUB_TYPE 
 *--------------------------------------------------------------------------- 
 */

/*
 * Segmented string subtypes 
 */
/* Unspecified */
#define	RDB_K_SUB_TYPE_UNS                0
/* TEXT segments */
#define	RDB_K_SUB_TYPE_TEXT               1
/* BLR segments */
#define	RDB_K_SUB_TYPE_BLR                2
/* MBLR (metadata) segments */
#define	RDB_K_SUB_TYPE_MBLR               3
/* BINARY data in segment */
#define	RDB_K_SUB_TYPE_BINARY             4
/* OBLR (outline) segments */
#define	RDB_K_SUB_TYPE_OBLR               5
#define	RDB_K_SUB_TYPE_SQL_CLOB           6	/* database cset */
#define	RDB_K_SUB_TYPE_SQL_NCLOB          7	/* national cset */
#define	RDB_K_SUB_TYPE_SQL_BLOB           8	/* unspecified/binary */

/*
 * Reserved range for SQL/Multimedia Services 
 */
#define	RDB_K_SUB_TYPE_SQLMM_MIN          1000
#define	RDB_K_SUB_TYPE_SQLMM_MAX          1999

/*
 * User literals (internal use only) for TEXT/VARYING TEST types 
 */
/* descriptor refers to USER literal */
#define	RDB_K_SUB_TYPE_USER               -1
/* descriptor refers to NULL literal */
#define	RDB_K_SUB_TYPE_NULL               -2
/* SERdb - classification label */
#define	RDB_K_SUB_TYPE_LABEL              -3
/* text/varying text is a DBKEY */
#define	RDB_K_SUB_TYPE_DBKEY              -4
/* refers to CURRENT_USER builtin */
#define	RDB_K_SUB_TYPE_CURRENT_USER       -5
/* refers to SESSION_USER builtin */
#define	RDB_K_SUB_TYPE_SESSION_USER       -6
/* refers to SYSTEM_USER builtin */
#define	RDB_K_SUB_TYPE_SYSTEM_USER        -7
/* refers to CURRENT_UID builtin */
#define	RDB_K_SUB_TYPE_CURRENT_UID        -8
/* refers to SESSION_UID builtin */
#define	RDB_K_SUB_TYPE_SESSION_UID        -9
/* refers to SYSTEM_UID builtin */
#define	RDB_K_SUB_TYPE_SYSTEM_UID         -10

/*
 * Numeric value subtypes 
 */
#define	RDB_K_SUB_TYPE_BOOLEAN            1	/* indicate BOOLEAN type */


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   This section contains the tags needed by triggers 
 *--------------------------------------------------------------------------- 
 */

/*
 * Trigger action clumplets 
 */
#define	RDB_K_TRIGGERED_ACTION            1
#define	RDB_K_TRIGGERED_FREQUENCY         2
#define	RDB_K_TRIGGERED_CONDITION         3
#define	RDB_K_TRIGGERED_STATEMENT         4

/*
 * Trigger action frequency 
 */
#define	RDB_K_TRIGGER_ONCE                0
#define	RDB_K_TRIGGER_FOR_EACH_ROW        1

/*
 * Trigger type 
 */
#define	RDB_K_BEFORE_STORE                1
#define	RDB_K_BEFORE_ERASE                2
#define	RDB_K_BEFORE_MODIFY               3
#define	RDB_K_AFTER_STORE                 4
#define	RDB_K_AFTER_ERASE                 5
#define	RDB_K_AFTER_MODIFY                6
#define	RDB_K_INSTEAD_OF_STORE            7
#define	RDB_K_INSTEAD_OF_ERASE            8
#define	RDB_K_INSTEAD_OF_MODIFY           9


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   This section contains the tags needed by referential constraints 
 *--------------------------------------------------------------------------- 
 */

/*
 * Constraint match type 
 */
#define	RDB_K_CON_MATCH_NONE              0
#define	RDB_K_CON_MATCH_ALL               1

/*
 * Constraint type 
 */
#define	RDB_K_CON_CONDITION               1
#define	RDB_K_CON_PRIMARY_KEY             2
#define	RDB_K_CON_REFERENTIAL             3
#define	RDB_K_CON_UNIQUE                  4
#define	RDB_K_CON_VIEW_CHECK              5
#define	RDB_K_CON_NOT_NULL                6

/*
 * Single classification level table constraint 
 */
#define	RDB_K_CON_SINGLE_LEVEL            7

/*
 * Constraint referential action type 
 */
#define	RDB_K_CONACT_NONE                 0
#define	RDB_K_CONACT_CASCADE              1
#define	RDB_K_CONACT_SET_DEFAULT          2
#define	RDB_K_CONACT_SET_NULL             3

/*
 *--------------------------------------------------------------------------- 
 *   RDB_K_DUPLICATES_<mumbo> 
 *   This section contains the extension tags used with duplicates definition 
 *--------------------------------------------------------------------------- 
 */
#define	RDB_K_DUPLICATES_SORTED           0
#define	RDB_K_DUPLICATES_COMPRESSED       1

/*
 *--------------------------------------------------------------------------- 
 * RDB_K_REQTYPE_ 
 * This section constains the type of request blocks.  Used by TRACE to 
 * identify the different usage of requests 
 *--------------------------------------------------------------------------- 
 */
#define	RDB_K_REQTYPE_OTHER               0
#define	RDB_K_REQTYPE_USER_REQUEST        1
#define	RDB_K_REQTYPE_PROCEDURE           2
#define	RDB_K_REQTYPE_FUNCTION            3
#define	RDB_K_REQTYPE_TRIGGER             4
#define	RDB_K_REQTYPE_CONSTRAINT          5


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   BLR_K_<mumbo> 
 *   This section contains all the values for the Binary Language Representatio 
 *   tags.  The tags are used to describe the DML operations. 
 *--------------------------------------------------------------------------- 
 */

/*
 *----------------------------------------------------------------------------- 
 * BLR version tags 
 *----------------------------------------------------------------------------- 
 */
#define	BLR_K_VERSION2                    2
#define	BLR_K_VERSION3                    3
#define	BLR_K_VERSION4                    4

/*
 *----------------------------------------------------------------------------- 
 * BLR tags 
 *----------------------------------------------------------------------------- 
 */
#define	BLR_K_MIN                         1

/*
 * Verbs 
 */
#define	BLR_K_VERB_MIN                    1
#define	BLR_K_ASSIGNMENT                  1
/* Transfer data value */
#define	BLR_K_TRANSFER                    BLR_K_ASSIGNMENT

/* Start of list */
#define	BLR_K_BEGIN                       2
#define	BLR_K_DCL_VARIABLE                3

/* Declare port */
#define	BLR_K_DCL_PORT                    4
#define	BLR_K_MESSAGE                     BLR_K_DCL_PORT
#define	BLR_K_DECLARE_PORT                BLR_K_DCL_PORT

#define	BLR_K_ERASE                       5
/* Fetch record by number */
#define	BLR_K_FETCH                       6
/* Classical FOR loop */
#define	BLR_K_FOR                         7
#define	BLR_K_IF                          8
/* Loop like an idiot */
#define	BLR_K_LOOP                        9
#define	BLR_K_MODIFY                      10
#define	BLR_K_HANDLER                     11
/* Receive a message */
#define	BLR_K_RECEIVE                     12
#define	BLR_K_SELECT                      13
/* Send a message */
#define	BLR_K_SEND                        14
/* Store into relation */
#define	BLR_K_STORE                       15
#define	BLR_K_WHILE                       16
#define	BLR_K_LABEL                       17
#define	BLR_K_LEAVE                       18
/* Store into relation, followed by extra stmt */
#define	BLR_K_STORE2                      19
#define	BLR_K_PLACE                       20
#define	BLR_K_VERB_MAX                    20

/*
 * BLR values 
 */
#define	BLR_K_VALUE_MIN                   21
#define	BLR_K_LITERAL                     21
/* DBKEY of a stream */
#define	BLR_K_DBKEY                       22
/* Field reference */
#define	BLR_K_FIELD                       23
#define	BLR_K_FIELD_ID                    24
#define	BLR_K_PARAMETER                   25
#define	BLR_K_VARIABLE                    26
#define	BLR_K_AVERAGE                     27
#define	BLR_K_COUNT                       28
#define	BLR_K_MAXIMUM                     29
#define	BLR_K_MINIMUM                     30
#define	BLR_K_TOTAL                       31
#define	BLR_K_STDDEV                      32
#define	BLR_K_SMAX                        32	/* obsolete */
#define	BLR_K_VARIANCE                    33
#define	BLR_K_SMIN                        33	/* obsolete */
#define	BLR_K_ADD                         34
#define	BLR_K_SUBTRACT                    35
#define	BLR_K_MULTIPLY                    36
#define	BLR_K_DIVIDE                      37
#define	BLR_K_NEGATE                      38
#define	BLR_K_CONCATENATE                 39
#define	BLR_K_SUBSTR                      40
#define	BLR_K_PARAMETER2                  41
#define	BLR_K_FROM                        42
#define	BLR_K_VIA                         43
#define	BLR_K_VALUE_MAX                   43
/* BLR_K_PAREN and BLR_K_COLON are used by RDO with no collision */
/* with new values */
#define	BLR_K_EXCEPT                      44
#define	BLR_K_PAREN                       44	/* Convenient for preprocessors */
#define	BLR_K_INTERSECT                   45
#define	BLR_K_COLON                       45	/* Convenient for preprocessors */
/* Reference argument from list */
#define	BLR_K_ARGUMENT                    BLR_K_PARAMETER
#define	BLR_K_PLUS                        BLR_K_ADD
#define	BLR_K_MINUS                       BLR_K_SUBTRACT
#define	BLR_K_TIMES                       BLR_K_MULTIPLY
                                
/*
 * BLR comparisons 
 */
#define	BLR_K_EQUIVALENT                  46
#define	BLR_K_BOOL_MIN                    46
#define	BLR_K_EQL                         47
#define	BLR_K_NEQ                         48
#define	BLR_K_GTR                         49
#define	BLR_K_GEQ                         50
#define	BLR_K_LSS                         51
#define	BLR_K_LEQ                         52
#define	BLR_K_CONTAINING                  53
#define	BLR_K_MATCHES                     54
#define	BLR_K_STARTS                      55
#define	BLR_K_BETWEEN                     56
#define	BLR_K_OR                          57
#define	BLR_K_AND                         58
#define	BLR_K_NOT                         59
#define	BLR_K_ANY                         60
#define	BLR_K_MISSING                     61
#define	BLR_K_UNIQUE                      62
/* Used internally */
#define	BLR_K_IDENTITY                    63
#define	BLR_K_LIKE                        64
#define	BLR_K_ANY2                        65
#define	BLR_K_ALL                         66
#define	BLR_K_BOOL_MAX                    66

/*
 * Misc. 
 */
/* Introduces a RSE. */
#define	BLR_K_RSE                         67
#define	BLR_K_RSE_MIN                     68
#define	BLR_K_FIRST                       68
/* Fields to be fetched in RSE */
#define	BLR_K_PROJECT                     69
/* Sort list */
#define	BLR_K_SORT                        70
#define	BLR_K_BOOLEAN                     71
#define	BLR_K_RSE_MAX                     71

#define	BLR_K_ASCENDING                   72
#define	BLR_K_DESCENDING                  73
/* Sort list */
#define	BLR_K_SORTS                       BLR_K_SORT
#define	BLR_K_FIELDS                      BLR_K_PROJECT
/* Relation follow (ctx, rel_id) */
#define	BLR_K_RELATION                    74
#define	BLR_K_RELATION_ID                 75
/* End of command string */
#define	BLR_K_EOC                         76
#define	BLR_K_MAX                         76

#define	BLR_K_AGGREGATE                   77
#define	BLR_K_AGG_AVERAGE                 78
#define	BLR_K_AGG_COUNT                   79
#define	BLR_K_AGG_MAX                     80
#define	BLR_K_AGG_MAXIMUM                 BLR_K_AGG_MAX
#define	BLR_K_AGG_MIN                     81
#define	BLR_K_AGG_MINIMUM                 BLR_K_AGG_MIN
#define	BLR_K_AGG_TOTAL                   82
#define	BLR_K_CONTROL_BITS                83
#define	BLR_K_GROUP_BY                    84
#define	BLR_K_GROUP_VALUE                 85
#define	BLR_K_MAP                         86
#define	BLR_K_MERGE                       87
#define	BLR_K_PARAMETER3                  88
#define	BLR_K_USER                        89
#define	BLR_K_SUBSTR2                     90
#define	BLR_K_TIMESTAMP                   91
/*
 * Special Trigger actions 
 */
#define	BLR_K_ERROR                       92
#define	BLR_K_NULL                        93
#define	BLR_K_STATEMENT                   94

/*
 *V4.1 
 * Date/Time support BLRs 
 */
/* Alias for consistency */
#define	BLR_K_CURRENT_TIMESTAMP           BLR_K_TIMESTAMP
/* Time Only Function */
#define	BLR_K_CURRENT_TIME                95
/* Date Only Function */
#define	BLR_K_CURRENT_DATE                96
/* SQL2 CAST function */
#define	BLR_K_CAST                        97
#define	BLR_K_DESCRIPTOR                  98
/* SQL2 EXTRACT function */
#define	BLR_K_EXTRACT                     99
/* Global field reference */
#define	BLR_K_GLOBAL_FIELD                100
/*
 * MIA extensions 
 */
/* offset and length in characters not bytes */
#define	BLR_K_SUBSTR3                     101
/* Translate btw csets + fold upper/lower */
#define	BLR_K_TRANSLATE                   102

/*
 *V6.0 
 */
/* ISO SQL CASE expression */
#define	BLR_K_CASE                        103
/* transaction control in request */
#define	BLR_K_TRANSACTION                 104
/* user defined request tracing */
#define	BLR_K_TRACE                       105
/* return procedure state information */
#define	BLR_K_GET_INFO                    106
/* routine invocation (both function and procedure, external and stored) */
#define	BLR_K_FUNCTION                    107
/* join semantics */
#define	BLR_K_JOIN                        108
/* join context tag */
#define	BLR_K_CONTEXT                     109
/* SQL92 behavior - truncation len in chars. */
#define	BLR_K_PARAMETER4                  110
/* row constructor */
#define	BLR_K_VALUE_LIST                  111
#define	BLR_K_DATA_SET                    BLR_K_VALUE_LIST	/* *obsolete* */
/* POSITION substring IN string FROM start */
#define	BLR_K_POSITION                    112
/* SQL statement block */
#define	BLR_K_SUBSTATEMENT                113
/* Declare SQL style variable */
#define	BLR_K_DCL_VARIABLE2               114
/* TRIM option trim-char from string */
#define	BLR_K_TRIM                        115

/*
 *V7.0 
 */
/* Special variable for function result */
#define	BLR_K_FUNCTION_RESULT             116

/*
 *V7.1 
 */
/* Reference to global variable by name */
#define	BLR_K_GLOBAL_VARIABLE             117

/* Allow more columns for MERGE/AGGREGATE */
#define	BLR_K_MAP2                        118
#define	BLR_K_AGG_VARIANCE                119
#define	BLR_K_AGG_STDDEV                  120

/*
 * Prototype work 
 */
#define	BLR_K_OVERLAY                     121

/*
 *V7.2 
 */
#define	BLR_K_ROW_TSN                     122
#define	BLR_K_ROW_NUMBER                  123

/*
 *V7.3 
 */
#define	BLR_K_TRUE                        124
#define	BLR_K_FALSE                       125
#define	BLR_K_UNKNOWN                     126
#define	BLR_K_REPLACE                     127
#define	BLR_K_REPLACE2                    128

/* End of BLR tags */
#define	BLR_K_END                         255

/*
 *----------------------------------------------------------------------------- 
 * Record selection expressions have the form: 
 *	{<context><relation_id>}...<END> [<projects>][<boolean>][<sort>] 
 * where projects, boolean, and sort are projection field lists, booleans, 
 * and sort clauses.  Each of this, if present, is introduced with 
 * <FIELDS>, <BOOLEAN>, or <SORTS>. 
 * Fields are identified (after introducer <FIELD> for values) by 
 *	<context><field_id> 
 * where <context> identifies a context and <field_id> is the index to 
 * the field in the relation resolved by context. 
 *----------------------------------------------------------------------------- 
 */


/*
 *----------------------------------------------------------------------------- 
 * Mask literals for BLR_K_CONTROL_BITS Control Bits 
 * Remember the control bits argument is only eight bits long.  Keep the 
 * masks grouped according to usage. 
 *----------------------------------------------------------------------------- 
 */
/* Special value expression options */
#define	RDB_M_STAT_RETURN_NULL            1
#define	RDB_M_STAT_VAR_SAMPLE             2

/* Modifies BLR_K_UNIQUE */
#define	RDB_M_UNIQ_ALLOW_EMPTY            1

/* Modifies BLR_K_VIA */
#define	RDB_M_VIA_NO_RECORDS              1
#define	RDB_M_VIA_MORE_THAN_ONE_RECORD    2

/* Modifies BLR_K_CONCATENATE */
#define	RDB_M_VALIDATE_CONCATENATE        1

/* Special update actions */
#define	RDB_M_UPDACT_ONE_ROW              1	/* [0] only update one row */
#define	RDB_M_UPDACT_NO_TRIGS             2	/* [1] disable triggers */
#define	RDB_M_UPDACT_NO_CONSTR            4	/* [2] disable constraint */
#define	RDB_M_UPDACT_AUTO_OVERRIDE        8	/* [3] allow insert/update to auto */

/* Cursor control bits */
#define	RDB_M_UPDATE_CURSOR               1	/* [0] */
#define	RDB_M_SINGLETON_SELECT            2	/* [1] */
#define	RDB_M_FOR_UPDATE_ONLY             4	/* [2] update only cursor */
#define	RDB_M_SEARCHED_UPDATE             8	/* [3] SQL searched UPDATE */
#define	RDB_M_SEARCHED_DELETE             16	/* [4] SQL searched DELETE */
#define	RDB_M_LOOPED_INSERT               32	/* [5] SQL INSERT...SELECT */
#define	RDB_M_FETCH_NOWAIT                64	/* [6] SQL SELECT...NOWAIT */
#define	RDB_M_MERGE_LOOP                  128	/* [7] SQL MERGE statement */

/* Declare Variable control bits */
#define	RDB_M_VAR_NOT_UPDATABLE           1	/* variable is not updatable */

/* Routine control bits (obsolete) */
#define	RDB_M_RTN_INTRINSIC               1

/* Modify BLR_K_OVERLAY */
#define	RDB_M_OVER_USE_CHARACTERS         1
#define	RDB_M_OVER_ORA_SEMANTICS          2

/* Substring (BLR_K_SUBSTR) is used for BIT STRING */
#define	RDB_M_BIT_SUBSTRING               1

/* Operator (EQL, NEQ, GTR, LSS, GEQ, LEQ) control bit modifiers */
#define	RDB_M_NON_PAD_STR_COMPARE         1

/* Masks for BLR_K_TRANSLATE */
#define	RDB_M_XLATE_CHAR_SUBS             1

/* Masks for BLR_K_LIKE */
#define	RDB_M_LIKE_REGULAR_EXPR           1	/* aka SIMILAR operator */
#define	RDB_M_LIKE_IGNORE_CASE            2	/* uses IGNORE CASE clause */

/* Temp definitions */
#define	RDB_K_UPDACT_ONE_ROW              RDB_M_UPDACT_ONE_ROW
#define	RDB_K_UPDACT_NO_TRIGS             RDB_M_UPDACT_NO_TRIGS

/*
 *----------------------------------------------------------------------------- 
 * Subcodes for BLR_K_GET_INFO 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_INF_MIN                     0
#define	RDB_K_INF_SQLSTATE                RDB_K_INF_MIN	/* return CHAR(5) sqlstate */
#define	RDB_K_INF_SQLCODE                 1	/* return LONGWORD sqlcode */
#define	RDB_K_INF_ACTIVE_ROWCOUNT         2	/* return LONGWORD current active row */
#define	RDB_K_INF_TXN_TYPE                3	/* return LONGWORD transaction type */
#define	RDB_K_INF_ISOLATION               4	/* return LONGWORD isolation level */
#define	RDB_K_INF_ROWCOUNT                5	/* return INTEGER row count */
#define	RDB_K_INF_COMMIT_TXN_COUNT        6	/* return INTEGER count if COMMITED txn */
#define	RDB_K_INF_ROLLBACK_TXN_COUNT      7	/* return INTEGER count if ROLLED BACK txn */
#define	RDB_K_INF_TXN_ACTIVE              8	/* return CHAR(1) transaction active or not */
#define	RDB_K_INF_TXN_DISTRIBUTED         9	/* return INTEGER 2PC transaction active or not */
#define	RDB_K_INF_CURRENT_USER            10	/* return CHAR(31) routine owner username */
#define	RDB_K_INF_SESSION_USER            11	/* return CHAR(31) session username */
#define	RDB_K_INF_SYSTEM_USER             12	/* return CHAR(31) process username */
#define	RDB_K_INF_COLUMN_DEFAULT          13	/* derived type: columns SQL default */
        
#define	RDB_K_INF_CONNECTION_NAME         14	/* return CHAR(31) connection name */
#define	RDB_K_INF_CALLING_ROUTINE         15	/* return CHAR(31) routine name */

#define	RDB_K_INF_CURRENT_SEQUENCE        16	/* return BIGINT sequence number */
#define	RDB_K_INF_NEXT_SEQUENCE           17	/* return BIGINT sequence number */

#define	RDB_K_INF_PARAMETER_DEFAULT       18	/* derived type: parameters SQL default */

#define	RDB_K_INF_CURRENT_UID             19	/* return INTEGER routine owner user id */
#define	RDB_K_INF_SESSION_UID             20	/* return INTEGER session user id */
#define	RDB_K_INF_SYSTEM_UID              21	/* return INTEGER process user id */

#define	RDB_K_INF_TXN_TIMESTAMP           22	/* return TIMESTAMP of txn start */
#define	RDB_K_INF_TXN_TSN                 23	/* return QUADWORD tsn */

#define	RDB_K_INF_HS_MODE                 24	/* return CHAR(31) mode for HS */
#define	RDB_K_INF_SERVER_IDENT            25	/* return CHAR(31) pretty ident */
#define	RDB_K_INF_TXN_CHANGES             26	/* return INTEGER */
#define	RDB_K_INF_IMAGE_NAME              27	/* return VARCHAR (255) */

#define	RDB_K_INF_QG_ROW_LIMIT            28	/* return BIGINT(0) */
#define	RDB_K_INF_QG_CPU_TIME             29	/* return INTEGER(0) */
#define	RDB_K_INF_QG_ELAPSED_TIME         30	/* return INTEGER(0) */
#define	RDB_K_INF_TRACE_ENABLED           31	/* return INTEGER(0) */

#define	RDB_K_INF_TTBL_COLUMN_DEFAULT     32	/* derived type: columns SQL default */
    
#define	RDB_K_INF_INSERT_ROWCOUNT         33	/* return LONGWORD count of inserted rows */
#define	RDB_K_INF_UPDATE_ROWCOUNT         34	/* return LONGWORD count of updated rows */
    
/* END OF RANGE */
#define	RDB_K_INF_MAX                     34

/*
 *----------------------------------------------------------------------------- 
 * Trim-options for BLR_K_TRIM - describe the operations of the TRIM function 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_M_TRIM_LEADING                1	/* trim leading characters */
#define	RDB_M_TRIM_TRAILING               2	/* trim trailing characters */
#define	RDB_M_TRIM_BOTH                   (RDB_M_TRIM_LEADING | RDB_M_TRIM_TRAILING)

/*
 *----------------------------------------------------------------------------- 
 * Hold options for cursors 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_M_HOLD_NONE                   0	/* close on commit/rollback */
#define	RDB_M_HOLD_COMMIT                 1	/* hold on commit */
#define	RDB_M_HOLD_ROLLBACK               2	/* hold on rollback */
#define	RDB_M_HOLD_ALL                    (RDB_M_HOLD_COMMIT | RDB_M_HOLD_ROLLBACK)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_CONSTRAINTS relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/*    */
/* Symbolic name                     Value */
#define	RDB_K_CN_FLAGS_CONSTR_DISABLED    0
#define	RDB_K_CN_FLAGS_CONSTR_UNCHECKED   1
#define	RDB_K_CN_FLAGS_CONSTR_GEN_NAME    2	/* user supplied */
#define	RDB_K_CN_FLAGS_NOT_NULL           3
#define	RDB_K_CN_FLAGS_PRIMARY_KEY        4
#define	RDB_K_CN_FLAGS_REFERENTIAL        5
#define	RDB_K_CN_FLAGS_CONDITION          6
#define	RDB_K_CN_FLAGS_UNIQUE             7

#define	RDB_M_CN_FLAGS_CONSTR_DISABLED    (1<<RDB_K_CN_FLAGS_CONSTR_DISABLED)
#define	RDB_M_CN_FLAGS_CONSTR_UNCHECKED   (1<<RDB_K_CN_FLAGS_CONSTR_UNCHECKED)
#define	RDB_M_CN_FLAGS_CONSTR_GEN_NAME    (1<<RDB_K_CN_FLAGS_CONSTR_GEN_NAME)
#define	RDB_M_CN_FLAGS_NOT_NULL           (1<<RDB_K_CN_FLAGS_NOT_NULL)
#define	RDB_M_CN_FLAGS_PRIMARY_KEY        (1<<RDB_K_CN_FLAGS_PRIMARY_KEY)
#define	RDB_M_CN_FLAGS_REFERENTIAL        (1<<RDB_K_CN_FLAGS_REFERENTIAL)
#define	RDB_M_CN_FLAGS_CONDITION          (1<<RDB_K_CN_FLAGS_CONDITION)
#define	RDB_M_CN_FLAGS_UNIQUE             (1<<RDB_K_CN_FLAGS_UNIQUE)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_DATABASE relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name			Value */
/* -------------			----- */
#define	RDB_K_DB_FLAGS_DICT_REQUIRED      0	/* dictionary is [not] required */
#define	RDB_K_DB_FLAGS_ANSI_PROTECTION    1	/* protection is { ANSI | ACL } */
#define	RDB_K_DB_FLAGS_DICT_DATABASE      2	/* CDD_DATABASE database */
#define	RDB_K_DB_FLAGS_SECURE_RDB         3	/* SERdb database */
#define	RDB_K_DB_FLAGS_INTEGRITY          4	/* SERdb integrity preserved */
#define	RDB_K_DB_FLAGS_SINGLE_LEVEL       5	/* SERdb metadata single level */
#define	RDB_K_DB_FLAGS_MULTISCHEMA        6	/* enabled multischema */
#define	RDB_K_DB_FLAGS_MAC_POLICY_DISAB   7	/* SERdb MAC policy disabled */

#define	RDB_K_DB_FLAGS_NDX_COMPRESSED     8	/* System Indices are compressed */
#define	RDB_K_DB_FLAGS_COLLECT_WORKLOAD   9	/* Optimizer workload collection */
#define	RDB_K_DB_FLAGS_CARDUPD_DISABLED   10	/* Cardinality collection */
#define	RDB_K_DB_FLAGS_DDL_DISABLED       11	/* DDL disabled for database */
#define	RDB_K_DB_FLAGS_SEC_INTERNAL       12	/* Internal security names */
#define	RDB_K_DB_FLAGS_VALIDATE_SID       13	/* Check the system ID */
#define	RDB_K_DB_FLAGS_OBJECT_SYNONYMS    14	/* Synonyms are supported */
#define	RDB_K_DB_FLAGS_NDXPCRD_DISABLED   15	/* Don't collect prefix card on sysndx */

#define	RDB_K_DB_FLAGS_NDX_PREFIX_ALL     16	/* Complete card collect */
#define	RDB_K_DB_FLAGS_NDX_RANKED         17	/* Use pseudo ranked for sysndx */

/* Mask name				Value */
/* ---------				----- */
#define	RDB_M_DB_FLAGS_DICT_REQUIRED      (1<<RDB_K_DB_FLAGS_DICT_REQUIRED)
#define	RDB_M_DB_FLAGS_ANSI_PROTECTION    (1<<RDB_K_DB_FLAGS_ANSI_PROTECTION)
#define	RDB_M_DB_FLAGS_DICT_DATABASE      (1<<RDB_K_DB_FLAGS_DICT_DATABASE)
#define	RDB_M_DB_FLAGS_SECURE_RDB         (1<<RDB_K_DB_FLAGS_SECURE_RDB)
#define	RDB_M_DB_FLAGS_INTEGRITY          (1<<RDB_K_DB_FLAGS_INTEGRITY)
#define	RDB_M_DB_FLAGS_SINGLE_LEVEL       (1<<RDB_K_DB_FLAGS_SINGLE_LEVEL)
#define	RDB_M_DB_FLAGS_MULTISCHEMA        (1<<RDB_K_DB_FLAGS_MULTISCHEMA)
#define	RDB_M_DB_FLAGS_MAC_POLICY_DISAB   (1<<RDB_K_DB_FLAGS_MAC_POLICY_DISAB)

#define	RDB_M_DB_FLAGS_NDX_COMPRESSED     (1<<RDB_K_DB_FLAGS_NDX_COMPRESSED)
#define	RDB_M_DB_FLAGS_COLLECT_WORKLOAD   (1<<RDB_K_DB_FLAGS_COLLECT_WORKLOAD)
#define	RDB_M_DB_FLAGS_CARDUPD_DISABLED   (1<<RDB_K_DB_FLAGS_CARDUPD_DISABLED)
#define	RDB_M_DB_FLAGS_DDL_DISABLED       (1<<RDB_K_DB_FLAGS_DDL_DISABLED)
#define	RDB_M_DB_FLAGS_SEC_INTERNAL       (1<<RDB_K_DB_FLAGS_SEC_INTERNAL)
#define	RDB_M_DB_FLAGS_VALIDATE_SID       (1<<RDB_K_DB_FLAGS_VALIDATE_SID)
#define	RDB_M_DB_FLAGS_OBJECT_SYNONYMS    (1<<RDB_K_DB_FLAGS_OBJECT_SYNONYMS)
#define	RDB_M_DB_FLAGS_NDXPCRD_DISABLED   (1<<RDB_K_DB_FLAGS_NDXPCRD_DISABLED)

#define	RDB_M_DB_FLAGS_NDX_PREFIX_ALL     (1<<RDB_K_DB_FLAGS_NDX_PREFIX_ALL)
#define	RDB_M_DB_FLAGS_NDX_RANKED         (1<<RDB_K_DB_FLAGS_NDX_RANKED)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_INDICES relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name			Value */
/* -------------			----- */
#define	RDB_K_IX_FLAGS_HASHED             0	/* Index is HASHED not sorted */
#define	RDB_K_IX_FLAGS_MV_COMPRESSED      1	/* Mapping Values NULL compressed */
#define	RDB_K_IX_FLAGS_HASHED_ORDERED     2	/* HASHED with ORDERED algorithm */
#define	RDB_K_IX_FLAGS_HASHED_USER        3	/* User defined HASH algorithm */
#define	RDB_K_IX_FLAGS_RL_COMPRESSED      4	/* Run Length Compressed */
#define	RDB_K_IX_FLAGS_DISABLED           5	/* DISABLED - do not use */
#define	RDB_K_IX_FLAGS_BUILD_PENDING      6	/* Pending updates */
#define	RDB_K_IX_FLAGS_INDEX_ONLY         7	/* Index only table */
#define	RDB_K_IX_FLAGS_SUB_INDEX          8	/* Sub index for B+Tree */
#define	RDB_K_IX_FLAGS_DUP_SORTED         9	/* Duplicates are SORTED (subtrees) */
#define	RDB_K_IX_FLAGS_TEMP_TBL_INDEX     10	/* Index defined on temp table */
#define	RDB_K_IX_FLAGS_DUP_COMPRESSED     11	/* Duplicates are compressed */
#define	RDB_K_IX_FLAGS_PSEUDO_RANKED      12	/* Psuedo ranked index */
#define	RDB_K_IX_FLAGS_COLLECT_DISABLED   13	/* Prefix cardinalities disabled */
#define	RDB_K_IX_FLAGS_PREFIX_FULL        14	/* Use the full collection algorithm */
#define	RDB_K_IX_FLAGS_CONSTRAINT_INDEX   15	/* Auto generated index */
#define	RDB_K_IX_FLAGS_CODE_LEVEL1        16	/* created with new partitioning code */

/* Mask name				Value */
/* -------------			----- */
#define	RDB_M_IX_FLAGS_HASHED             (1<<RDB_K_IX_FLAGS_HASHED)
#define	RDB_M_IX_FLAGS_MV_COMPRESSED      (1<<RDB_K_IX_FLAGS_MV_COMPRESSED)
#define	RDB_M_IX_FLAGS_HASHED_ORDERED     (1<<RDB_K_IX_FLAGS_HASHED_ORDERED)
#define	RDB_M_IX_FLAGS_HASHED_USER        (1<<RDB_K_IX_FLAGS_HASHED_USER)
#define	RDB_M_IX_FLAGS_RL_COMPRESSED      (1<<RDB_K_IX_FLAGS_RL_COMPRESSED)
#define	RDB_M_IX_FLAGS_DISABLED           (1<<RDB_K_IX_FLAGS_DISABLED)
#define	RDB_M_IX_FLAGS_BUILD_PENDING      (1<<RDB_K_IX_FLAGS_BUILD_PENDING)
#define	RDB_M_IX_FLAGS_INDEX_ONLY         (1<<RDB_K_IX_FLAGS_INDEX_ONLY)
#define	RDB_M_IX_FLAGS_SUB_INDEX          (1<<RDB_K_IX_FLAGS_SUB_INDEX)
#define	RDB_M_IX_FLAGS_DUP_SORTED         (1<<RDB_K_IX_FLAGS_DUP_SORTED)
#define	RDB_M_IX_FLAGS_TEMP_TBL_INDEX     (1<<RDB_K_IX_FLAGS_TEMP_TBL_INDEX)
#define	RDB_M_IX_FLAGS_DUP_COMPRESSED     (1<<RDB_K_IX_FLAGS_DUP_COMPRESSED)
#define	RDB_M_IX_FLAGS_PSEUDO_RANKED      (1<<RDB_K_IX_FLAGS_PSEUDO_RANKED)
#define	RDB_M_IX_FLAGS_COLLECT_DISABLED   (1<<RDB_K_IX_FLAGS_COLLECT_DISABLED)
#define	RDB_M_IX_FLAGS_PREFIX_FULL        (1<<RDB_K_IX_FLAGS_PREFIX_FULL)
#define	RDB_M_IX_FLAGS_CONSTRAINT_INDEX   (1<<RDB_K_IX_FLAGS_CONSTRAINT_INDEX)
#define	RDB_M_IX_FLAGS_CODE_LEVEL1        (1<<RDB_K_IX_FLAGS_CODE_LEVEL1)

/* Alias for changed flag names */
#define	RDB_K_IX_FLAGS_DEFERRED           RDB_K_IX_FLAGS_BUILD_PENDING
#define	RDB_M_IX_FLAGS_DEFERRED           RDB_M_IX_FLAGS_BUILD_PENDING

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_INDEX_SEGMENTS relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name			Value */
/* -------------			----- */
#define	RDB_K_IK_FLAGS_DESCENDING         0

#define	RDB_M_IK_FLAGS_DESCENDING         (1<<RDB_K_IK_FLAGS_DESCENDING)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_RELATIONS relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name                     Value   	     Reason for setting */
#define	RDB_K_RL_FLAGS_VIEW               0	/* Table is a view */
#define	RDB_K_RL_FLAGS_COMP_DISABLED      1	/* Table is NOT to be compressed */
#define	RDB_K_RL_FLAGS_VIEW_CHECK         2	/* View RSE is to be checked */
#define	RDB_K_RL_FLAGS_INTERNAL           3	/* True system relation */
#define	RDB_K_RL_FLAGS_NOT_ANSI_UPDATE    4	/* info flag for SQL */
#define	RDB_K_RL_FLAGS_IMPORTED_TABLE     5	/* DBI reserved flag */
#define	RDB_K_RL_FLAGS_PASSTHRU_TABLE     6	/* DBI reserved flag */
#define	RDB_K_RL_FLAGS_PARTITION_VIEW     7	/* DBI reserved flag */
#define	RDB_K_RL_FLAGS_USE_MAP_COMP       8	/* VRP: sto map has compression */
#define	RDB_K_RL_FLAGS_TEMP_TABLE         9	/* Table is temporary */
#define	RDB_K_RL_FLAGS_GLOBAL_TEMP_TBL    10	/* Table is global temporary */
#define	RDB_K_RL_FLAGS_DELETE_ON_COMMIT   11	/* Commit options for temp tables */
#define	RDB_K_RL_FLAGS_INDEX_ONLY         12	/* Data in index only */
#define	RDB_K_RL_FLAGS_REF_TO_LOCAL_TT    13	/* Table or view references local temporary table */
#define	RDB_K_RL_FLAGS_INFO_TABLE         14	/* This is a R/O INFORMATION table */
#define	RDB_K_RL_FLAGS_MAPPED_SYSREL      15	/* This system table has a storage map */
#define	RDB_K_RL_FLAGS_ONLY_TT_MAIN_CTX   16	/* Used for TTBL priv checking */
#define	RDB_K_RL_FLAGS_HIDDEN             17	/* Table/view is hidden */
#define	RDB_K_RL_FLAGS_LARGE_MEMORY       18	/* Use large memory for temp table */

#define	RDB_M_RL_FLAGS_VIEW               (1<<RDB_K_RL_FLAGS_VIEW                 )
#define	RDB_M_RL_FLAGS_COMP_DISABLED      (1<<RDB_K_RL_FLAGS_COMP_DISABLED        )
#define	RDB_M_RL_FLAGS_VIEW_CHECK         (1<<RDB_K_RL_FLAGS_VIEW_CHECK           )
#define	RDB_M_RL_FLAGS_INTERNAL           (1<<RDB_K_RL_FLAGS_INTERNAL             )
#define	RDB_M_RL_FLAGS_NOT_ANSI_UPDATE    (1<<RDB_K_RL_FLAGS_NOT_ANSI_UPDATE      )
#define	RDB_M_RL_FLAGS_IMPORTED_TABLE     (1<<RDB_K_RL_FLAGS_IMPORTED_TABLE       )
#define	RDB_M_RL_FLAGS_PASSTHRU_TABLE     (1<<RDB_K_RL_FLAGS_PASSTHRU_TABLE       )
#define	RDB_M_RL_FLAGS_PARTITION_VIEW     (1<<RDB_K_RL_FLAGS_PARTITION_VIEW       )
#define	RDB_M_RL_FLAGS_USE_MAP_COMP       (1<<RDB_K_RL_FLAGS_USE_MAP_COMP         )
#define	RDB_M_RL_FLAGS_TEMP_TABLE         (1<<RDB_K_RL_FLAGS_TEMP_TABLE		 )
#define	RDB_M_RL_FLAGS_GLOBAL_TEMP_TBL    (1<<RDB_K_RL_FLAGS_GLOBAL_TEMP_TBL	 )
#define	RDB_M_RL_FLAGS_DELETE_ON_COMMIT   (1<<RDB_K_RL_FLAGS_DELETE_ON_COMMIT	 )
#define	RDB_M_RL_FLAGS_INDEX_ONLY         (1<<RDB_K_RL_FLAGS_INDEX_ONLY		 )
#define	RDB_M_RL_FLAGS_REF_TO_LOCAL_TT    (1<<RDB_K_RL_FLAGS_REF_TO_LOCAL_TT	 )
#define	RDB_M_RL_FLAGS_INFO_TABLE         (1<<RDB_K_RL_FLAGS_INFO_TABLE		 )
#define	RDB_M_RL_FLAGS_MAPPED_SYSREL      (1<<RDB_K_RL_FLAGS_MAPPED_SYSREL	 )
#define	RDB_M_RL_FLAGS_ONLY_TT_MAIN_CTX   (1<<RDB_K_RL_FLAGS_ONLY_TT_MAIN_CTX	 )
#define	RDB_M_RL_FLAGS_HIDDEN             (1<<RDB_K_RL_FLAGS_HIDDEN		 )
#define	RDB_M_RL_FLAGS_LARGE_MEMORY       (1<<RDB_K_RL_FLAGS_LARGE_MEMORY	 )

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_QUERY_OUTLINES relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name			Value */
/* -------------			----- */
/* Outline is invalid */
#define	RDB_K_OT_FLAGS_INVALID            0

/* Mask name */
#define	RDB_M_OT_FLAGS_INVALID            (1<<RDB_K_OT_FLAGS_INVALID)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_MODULES relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name			Value */
/* -------------			----- */
#define	RDB_K_ML_FLAGS_HIDDEN             0
#define	RDB_K_ML_FLAGS_SYSTEM             1

/* Mask name */
#define	RDB_M_ML_FLAGS_HIDDEN             (1<<RDB_K_ML_FLAGS_HIDDEN)
#define	RDB_M_ML_FLAGS_SYSTEM             (1<<RDB_K_ML_FLAGS_SYSTEM)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_ROUTINES relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name			Value */
/* -------------			----- */
#define	RDB_K_RT_FLAGS_FUNCTION           0
#define	RDB_K_RT_FLAGS_INVALID            1
#define	RDB_K_RT_FLAGS_VARIANT            2
#define	RDB_K_RT_FLAGS_CHG_TRANS_STATE    3	/* uses BLR_K_TRANSACTION */
#define	RDB_K_RT_FLAGS_SECURE_LOCATION    4 
#define	RDB_K_RT_FLAGS_SQL_PARAM_STYLE    5
#define	RDB_K_RT_FLAGS_INVALID_LANG_SEM   6  
#define	RDB_K_RT_FLAGS_THREADSAFE         7	/* Ext Rtn threadsafe? */
#define	RDB_K_RT_FLAGS_PROPAGATE_NULL     8	/* return null if passed null */
#define	RDB_K_RT_FLAGS_ANALYZED           9
#define	RDB_K_RT_FLAGS_STORE_ROWS         10	/* uses BLR_K_STORE/STORE2/PLACE */
#define	RDB_K_RT_FLAGS_MODIFY_ROWS        11	/* uses BLR_K_MODIFY */
#define	RDB_K_RT_FLAGS_ERASE_ROWS         12	/* uses BLR_K_ERASE */
#define	RDB_K_RT_FLAGS_READS_ROWS         13	/* uses BLR_K_FOR/FETCH */
#define	RDB_K_RT_FLAGS_CALLS_OUT          14	/* uses BLR_K_FUNCTION */
#define	RDB_K_RT_FLAGS_JAVA_PARAM_STYLE   15
#define	RDB_K_RT_FLAGS_PRIVATE            16	/* module private routine */
#define	RDB_K_RT_FLAGS_JAVA_BYTECODE      17
#define	RDB_K_RT_FLAGS_HIDDEN             18
#define	RDB_K_RT_FLAGS_SYSTEM             19
#define	RDB_K_RT_FLAGS_GENERATED          20
#define	RDB_K_RT_FLAGS_CURSOR_COROUTINE   21

/* Mask name */
#define	RDB_M_RT_FLAGS_FUNCTION           (1<<RDB_K_RT_FLAGS_FUNCTION)
#define	RDB_M_RT_FLAGS_INVALID            (1<<RDB_K_RT_FLAGS_INVALID)
#define	RDB_M_RT_FLAGS_VARIANT            (1<<RDB_K_RT_FLAGS_VARIANT)
#define	RDB_M_RT_FLAGS_CHG_TRANS_STATE    (1<<RDB_K_RT_FLAGS_CHG_TRANS_STATE)
#define	RDB_M_RT_FLAGS_SECURE_LOCATION    (1<<RDB_K_RT_FLAGS_SECURE_LOCATION)
#define	RDB_M_RT_FLAGS_SQL_PARAM_STYLE    (1<<RDB_K_RT_FLAGS_SQL_PARAM_STYLE)
#define	RDB_M_RT_FLAGS_INVALID_LANG_SEM   (1<<RDB_K_RT_FLAGS_INVALID_LANG_SEM)
#define	RDB_M_RT_FLAGS_THREADSAFE         (1<<RDB_K_RT_FLAGS_THREADSAFE)
#define	RDB_M_RT_FLAGS_PROPAGATE_NULL     (1<<RDB_K_RT_FLAGS_PROPAGATE_NULL)
#define	RDB_M_RT_FLAGS_ANALYZED           (1<<RDB_K_RT_FLAGS_ANALYZED)
#define	RDB_M_RT_FLAGS_STORE_ROWS         (1<<RDB_K_RT_FLAGS_STORE_ROWS)
#define	RDB_M_RT_FLAGS_MODIFY_ROWS        (1<<RDB_K_RT_FLAGS_MODIFY_ROWS)
#define	RDB_M_RT_FLAGS_ERASE_ROWS         (1<<RDB_K_RT_FLAGS_ERASE_ROWS)
#define	RDB_M_RT_FLAGS_READS_ROWS         (1<<RDB_K_RT_FLAGS_READS_ROWS)
#define	RDB_M_RT_FLAGS_CALLS_OUT          (1<<RDB_K_RT_FLAGS_CALLS_OUT)
#define	RDB_M_RT_FLAGS_JAVA_PARAM_STYLE   (1<<RDB_K_RT_FLAGS_JAVA_PARAM_STYLE)
#define	RDB_M_RT_FLAGS_PRIVATE            (1<<RDB_K_RT_FLAGS_PRIVATE)
#define	RDB_M_RT_FLAGS_JAVA_BYTECODE      (1<<RDB_K_RT_FLAGS_JAVA_BYTECODE)
#define	RDB_M_RT_FLAGS_HIDDEN             (1<<RDB_K_RT_FLAGS_HIDDEN)
#define	RDB_M_RT_FLAGS_SYSTEM             (1<<RDB_K_RT_FLAGS_SYSTEM)
#define	RDB_M_RT_FLAGS_GENERATED          (1<<RDB_K_RT_FLAGS_GENERATED)
#define	RDB_M_RT_FLAGS_CURSOR_COROUTINE   (1<<RDB_K_RT_FLAGS_CURSOR_COROUTINE)

#define	RDB_M_RT_FLAGS_CALL_STATE         (RDB_M_RT_FLAGS_ANALYZED \
					   | RDB_M_RT_FLAGS_CHG_TRANS_STATE \
					   | RDB_M_RT_FLAGS_STORE_ROWS \
					   | RDB_M_RT_FLAGS_MODIFY_ROWS \
					   | RDB_M_RT_FLAGS_ERASE_ROWS \
					   | RDB_M_RT_FLAGS_CALLS_OUT)
#define	RDB_M_RT_FLAGS_TRIGGER_STATE      (RDB_M_RT_FLAGS_ANALYZED \
					   | RDB_M_RT_FLAGS_CHG_TRANS_STATE)
#define	RDB_M_RT_FLAGS_DML_STATE          (RDB_M_RT_FLAGS_CALL_STATE \
					   | RDB_M_RT_FLAGS_READS_ROWS)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_PROFILES relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name			Value */
/* -------------			----- */
#define	RDB_K_PF_FLAGS_PROFILE_DISABLED   0
#define	RDB_K_PF_FLAGS_IDENT_EXTERNAL     1
#define	RDB_K_PF_FLAGS_IDENT_PASSWORD     2
#define	RDB_K_PF_FLAGS_SYSTEM_ROLE        3
#define	RDB_K_PF_FLAGS_ASSIGNED_QUOTA     4

/* Mask name */
#define	RDB_M_PF_FLAGS_PROFILE_DISABLED   (1<<RDB_K_PF_FLAGS_PROFILE_DISABLED)
#define	RDB_M_PF_FLAGS_IDENT_EXTERNAL     (1<<RDB_K_PF_FLAGS_IDENT_EXTERNAL)
#define	RDB_M_PF_FLAGS_IDENT_PASSWORD     (1<<RDB_K_PF_FLAGS_IDENT_PASSWORD)
#define	RDB_M_PF_FLAGS_SYSTEM_ROLE        (1<<RDB_K_PF_FLAGS_SYSTEM_ROLE)
#define	RDB_M_PF_FLAGS_ASSIGNED_QUOTA     (1<<RDB_K_PF_FLAGS_ASSIGNED_QUOTA)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_PARAMETERS relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name			Value */
/* -------------			----- */
/* is an IN or INOUT parameter */
#define	RDB_K_PA_FLAGS_IN                 0
/* is an OUT or INOUT parameter */
#define	RDB_K_PA_FLAGS_OUT                1
/* Passed by Reference and Length */
#define	RDB_K_PA_FLAGS_LENGTH             2
/* By Descriptor */
#define	RDB_K_PA_FLAGS_DESCRIPTOR         3
/* By Value */
#define	RDB_K_PA_FLAGS_VALUE              4
/* Use natural alignment */
#define	RDB_K_PA_FLAGS_ALIGN              5
/* Mode is undefined */
#define	RDB_K_PA_FLAGS_MODE_UNDEFINED     6
/* Flags for parameter action-id (cursor object only) */
#define	RDB_K_PA_FLAGS_ACTION_OPEN        7
#define	RDB_K_PA_FLAGS_ACTION_CLOSE       8
#define	RDB_K_PA_FLAGS_ACTION_FETCH       9
#define	RDB_K_PA_FLAGS_ACTION_DELETE      10
#define	RDB_K_PA_FLAGS_ACTION_INSERT      11
#define	RDB_K_PA_FLAGS_ACTION_UPDATE      12

#define	RDB_M_PA_FLAGS_IN                 (1<<RDB_K_PA_FLAGS_IN)
#define	RDB_M_PA_FLAGS_OUT                (1<<RDB_K_PA_FLAGS_OUT)
#define	RDB_M_PA_FLAGS_INOUT              (RDB_M_PA_FLAGS_IN | RDB_M_PA_FLAGS_OUT)
#define	RDB_M_PA_FLAGS_LENGTH             (1<<RDB_K_PA_FLAGS_LENGTH)
#define	RDB_M_PA_FLAGS_DESCRIPTOR         (1<<RDB_K_PA_FLAGS_DESCRIPTOR)
#define	RDB_M_PA_FLAGS_VALUE              (1<<RDB_K_PA_FLAGS_VALUE)
#define	RDB_M_PA_FLAGS_ALIGN              (1<<RDB_K_PA_FLAGS_ALIGN)
#define	RDB_M_PA_FLAGS_MODE_UNDEFINED     (1<<RDB_K_PA_FLAGS_MODE_UNDEFINED)
#define	RDB_M_PA_FLAGS_ACTION_OPEN        (1<<RDB_K_PA_FLAGS_ACTION_OPEN)
#define	RDB_M_PA_FLAGS_ACTION_CLOSE       (1<<RDB_K_PA_FLAGS_ACTION_CLOSE)
#define	RDB_M_PA_FLAGS_ACTION_FETCH       (1<<RDB_K_PA_FLAGS_ACTION_FETCH)
#define	RDB_M_PA_FLAGS_ACTION_DELETE      (1<<RDB_K_PA_FLAGS_ACTION_DELETE)
#define	RDB_M_PA_FLAGS_ACTION_INSERT      (1<<RDB_K_PA_FLAGS_ACTION_INSERT)
#define	RDB_M_PA_FLAGS_ACTION_UPDATE      (1<<RDB_K_PA_FLAGS_ACTION_UPDATE)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_INTERRELATIONS relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name                     Value   Reason for setting */
#define	RDB_K_IR_FLAGS_ENT_MODULE         0	/* entity1 is a MODULE */
#define	RDB_K_IR_FLAGS_OBJ_MODULE         1	/* object is a MODULE */
#define	RDB_K_IR_FLAGS_ENT_ROUTINE        2	/* entity2 is a ROUTINE */
#define	RDB_K_IR_FLAGS_OBJ_ROUTINE        3	/* subobject is a ROUTINE */
#define	RDB_K_IR_FLAGS_ENT_TRIGGER        4	/* entity1 is a TRIGGER */
#define	RDB_K_IR_FLAGS_OBJ_TRIGGER        5	/* object is a TRIGGER */
#define	RDB_K_IR_FLAGS_ENT_CONSTRAINT     6	/* entity1 is a CONSTRAINT */
#define	RDB_K_IR_FLAGS_OBJ_CONSTRAINT     7	/* object is a CONSTRAINT */
#define	RDB_K_IR_FLAGS_ENT_STORAGE_MAP    8	/* entity1 is a MAP */
#define	RDB_K_IR_FLAGS_OBJ_STORAGE_MAP    9	/* object is a MAP */
#define	RDB_K_IR_FLAGS_ENT_OUTLINE        10	/* entity1 is an OUTLINE */
#define	RDB_K_IR_FLAGS_OBJ_OUTLINE        11	/* object is an OUTLINE */
#define	RDB_K_IR_FLAGS_ENT_TABLE          12	/* entity2 is a TABLE */
#define	RDB_K_IR_FLAGS_OBJ_TABLE          13	/* object is a TABLE */
#define	RDB_K_IR_FLAGS_ENT_SEQUENCE       14	/* entity1 is a SEQUENCE */
#define	RDB_K_IR_FLAGS_OBJ_SEQUENCE       15	/* object is a SEQUENCE */
#define	RDB_K_IR_FLAGS_ENT_VARIABLE       16	/* entity2 is a Module variable */
#define	RDB_K_IR_FLAGS_OBJ_VARIABLE       17	/* subobject is a Module variable */
#define	RDB_K_IR_FLAGS_ENT_INDEX          18	/* entity2 is a TABLE */
#define	RDB_K_IR_FLAGS_OBJ_INDEX          19	/* object is a TABLE */

/* Mask name */
#define	RDB_M_IR_FLAGS_ENT_MODULE         (1<<RDB_K_IR_FLAGS_ENT_MODULE)
#define	RDB_M_IR_FLAGS_OBJ_MODULE         (1<<RDB_K_IR_FLAGS_OBJ_MODULE)
#define	RDB_M_IR_FLAGS_ENT_ROUTINE        (1<<RDB_K_IR_FLAGS_ENT_ROUTINE)
#define	RDB_M_IR_FLAGS_OBJ_ROUTINE        (1<<RDB_K_IR_FLAGS_OBJ_ROUTINE)
#define	RDB_M_IR_FLAGS_ENT_TRIGGER        (1<<RDB_K_IR_FLAGS_ENT_TRIGGER)
#define	RDB_M_IR_FLAGS_OBJ_TRIGGER        (1<<RDB_K_IR_FLAGS_OBJ_TRIGGER)
#define	RDB_M_IR_FLAGS_ENT_CONSTRAINT     (1<<RDB_K_IR_FLAGS_ENT_CONSTRAINT)
#define	RDB_M_IR_FLAGS_OBJ_CONSTRAINT     (1<<RDB_K_IR_FLAGS_OBJ_CONSTRAINT)
#define	RDB_M_IR_FLAGS_ENT_STORAGE_MAP    (1<<RDB_K_IR_FLAGS_ENT_STORAGE_MAP)
#define	RDB_M_IR_FLAGS_OBJ_STORAGE_MAP    (1<<RDB_K_IR_FLAGS_OBJ_STORAGE_MAP)
#define	RDB_M_IR_FLAGS_ENT_OUTLINE        (1<<RDB_K_IR_FLAGS_ENT_OUTLINE)
#define	RDB_M_IR_FLAGS_OBJ_OUTLINE        (1<<RDB_K_IR_FLAGS_OBJ_OUTLINE)
#define	RDB_M_IR_FLAGS_ENT_TABLE          (1<<RDB_K_IR_FLAGS_ENT_TABLE)
#define	RDB_M_IR_FLAGS_OBJ_TABLE          (1<<RDB_K_IR_FLAGS_OBJ_TABLE)
#define	RDB_M_IR_FLAGS_ENT_SEQUENCE       (1<<RDB_K_IR_FLAGS_ENT_SEQUENCE)
#define	RDB_M_IR_FLAGS_OBJ_SEQUENCE       (1<<RDB_K_IR_FLAGS_OBJ_SEQUENCE)
#define	RDB_M_IR_FLAGS_ENT_VARIABLE       (1<<RDB_K_IR_FLAGS_ENT_VARIABLE)
#define	RDB_M_IR_FLAGS_OBJ_VARIABLE       (1<<RDB_K_IR_FLAGS_OBJ_VARIABLE)
#define	RDB_M_IR_FLAGS_ENT_INDEX          (1<<RDB_K_IR_FLAGS_ENT_INDEX)
#define	RDB_M_IR_FLAGS_OBJ_INDEX          (1<<RDB_K_IR_FLAGS_OBJ_INDEX)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_STORAGE_MAPS relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name                     Value */
#define	RDB_K_SM_FLAGS_MIXED_FORMAT       0	/* map uses MIXED areas */
#define	RDB_K_SM_FLAGS_DO_NOT_COMPRESS    1	/* no compression */
#define	RDB_K_SM_FLAGS_NOUPDATE           2	/* no update of map columns */
#define	RDB_K_SM_FLAGS_DYNAMIC            3	/* dynamically shift data */
#define	RDB_K_SM_FLAGS_NAMED_PARTITION    4	/* user supplied */
#define	RDB_K_SM_FLAGS_PART_UNCHECKED     5	/* NO REORG used */

#define	RDB_M_SM_FLAGS_MIXED_FORMAT       (1<<RDB_K_SM_FLAGS_MIXED_FORMAT)
#define	RDB_M_SM_FLAGS_DO_NOT_COMPRESS    (1<<RDB_K_SM_FLAGS_DO_NOT_COMPRESS)
#define	RDB_M_SM_FLAGS_NOUPDATE           (1<<RDB_K_SM_FLAGS_NOUPDATE)
#define	RDB_M_SM_FLAGS_DYNAMIC            (1<<RDB_K_SM_FLAGS_DYNAMIC)
#define	RDB_M_SM_FLAGS_NAMED_PARTITION    (1<<RDB_K_SM_FLAGS_NAMED_PARTITION)
#define	RDB_M_SM_FLAGS_PART_UNCHECKED     (1<<RDB_K_SM_FLAGS_PART_UNCHECKED)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_STORAGE_MAP_AREAS relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name                     Value */
#define	RDB_K_MA_FLAGS_SEQ_FILL           0	/* segstr attribute */
#define	RDB_K_MA_FLAGS_NAMED_PARTITION    1	/* user supplied */
#define	RDB_K_MA_FLAGS_BUILD_PENDING      2	/* BUILD PARTITION needed */
#define	RDB_K_MA_FLAGS_CREATE_NOLOGGING   3	/* create with no journal */
#define	RDB_K_MA_FLAGS_COLLECT_CARD       4
    
#define	RDB_M_MA_FLAGS_SEQ_FILL           (1<<RDB_K_MA_FLAGS_SEQ_FILL)
#define	RDB_M_MA_FLAGS_NAMED_PARTITION    (1<<RDB_K_MA_FLAGS_NAMED_PARTITION)
#define	RDB_M_MA_FLAGS_BUILD_PENDING      (1<<RDB_K_MA_FLAGS_BUILD_PENDING)
#define	RDB_M_MA_FLAGS_CREATE_NOLOGGING   (1<<RDB_K_MA_FLAGS_CREATE_NOLOGGING)
#define	RDB_M_MA_FLAGS_COLLECT_CARD       (1<<RDB_K_MA_FLAGS_COLLECT_CARD)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_RELATION_CONSTRAINTS relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/*    */
/* Symbolic name                     Value */
#define	RDB_K_RC_FLAGS_UNIQ_ALLOW_EMPTY   0

#define	RDB_M_RC_FLAGS_UNIQ_ALLOW_EMPTY   (1<<RDB_K_RC_FLAGS_UNIQ_ALLOW_EMPTY)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_TRIGGERS relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name                     Value */
#define	RDB_K_TR_FLAGS_TRIGGER_DISABLED   0
#define	RDB_K_TR_FLAGS_INVALID            1
#define	RDB_K_TR_FLAGS_INVALID_LANG_SEM   2

#define	RDB_M_TR_FLAGS_TRIGGER_DISABLED   (1<<RDB_K_TR_FLAGS_TRIGGER_DISABLED)
#define	RDB_M_TR_FLAGS_INVALID            (1<<RDB_K_TR_FLAGS_INVALID)
#define	RDB_M_TR_FLAGS_INVALID_LANG_SEM   (1<<RDB_K_TR_FLAGS_INVALID_LANG_SEM)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_SEQUENCES relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name                     Value */
#define	RDB_K_SQ_FLAGS_CYCLE              0
#define	RDB_K_SQ_FLAGS_ORDER              1
#define	RDB_K_SQ_FLAGS_RANDOMIZE          2
#define	RDB_K_SQ_FLAGS_SYSTEM             3
#define	RDB_K_SQ_FLAGS_USED_NOMINVALUE    4
#define	RDB_K_SQ_FLAGS_USED_NOMAXVALUE    5
#define	RDB_K_SQ_FLAGS_COLUMN_IDENTITY    6
#define	RDB_K_SQ_FLAGS_LOCK_WAIT          7
#define	RDB_K_SQ_FLAGS_LOCK_NOWAIT        8
#define	RDB_K_SQ_FLAGS_MANUAL_UPDATE      9

#define	RDB_M_SQ_FLAGS_CYCLE              (1<<RDB_K_SQ_FLAGS_CYCLE)
#define	RDB_M_SQ_FLAGS_ORDER              (1<<RDB_K_SQ_FLAGS_ORDER)
#define	RDB_M_SQ_FLAGS_RANDOMIZE          (1<<RDB_K_SQ_FLAGS_RANDOMIZE)
#define	RDB_M_SQ_FLAGS_SYSTEM             (1<<RDB_K_SQ_FLAGS_SYSTEM)
#define	RDB_M_SQ_FLAGS_USED_NOMINVALUE    (1<<RDB_K_SQ_FLAGS_USED_NOMINVALUE)
#define	RDB_M_SQ_FLAGS_USED_NOMAXVALUE    (1<<RDB_K_SQ_FLAGS_USED_NOMAXVALUE)
#define	RDB_M_SQ_FLAGS_COLUMN_IDENTITY    (1<<RDB_K_SQ_FLAGS_COLUMN_IDENTITY)
#define	RDB_M_SQ_FLAGS_LOCK_WAIT          (1<<RDB_K_SQ_FLAGS_LOCK_WAIT)
#define	RDB_M_SQ_FLAGS_LOCK_NOWAIT        (1<<RDB_K_SQ_FLAGS_LOCK_NOWAIT)
#define	RDB_M_SQ_FLAGS_MANUAL_UPDATE      (1<<RDB_K_SQ_FLAGS_MANUAL_UPDATE)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_PRIVILEGES relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name                     Value */
#define	RDB_K_PV_FLAGS_OBJ_MOD_RTN        0
#define	RDB_K_PV_FLAGS_OBJ_SEQ            1
#define	RDB_K_PV_FLAGS_OBJ_TYP_FLD        2

#define	RDB_M_PV_FLAGS_OBJ_MOD_RTN        (1<<RDB_K_PV_FLAGS_OBJ_MOD_RTN)
#define	RDB_M_PV_FLAGS_OBJ_SEQ            (1<<RDB_K_PV_FLAGS_OBJ_SEQ)
#define	RDB_M_PV_FLAGS_OBJ_TYP_FLD        (1<<RDB_K_PV_FLAGS_OBJ_TYP_FLD)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_FIELDS relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name			Value */
/* -------------			----- */
#define	RDB_K_FL_FLAGS_SQL_VALID_IF       0
#define	RDB_K_FL_FLAGS_AUTO_INSERT        1
#define	RDB_K_FL_FLAGS_AUTO_UPDATE        2
#define	RDB_K_FL_FLAGS_NAMED_VALID_IF     3
#define	RDB_K_FL_FLAGS_COLUMN_IDENTITY    4
#define	RDB_K_FL_FLAGS_READ_ONLY          5
#define	RDB_K_FL_FLAGS_DISTINCT_TYPE      6
#define	RDB_K_FL_FLAGS_HIDDEN             7	/* domain is hidden */
#define	RDB_K_FL_FLAGS_SHARED_COMPUTED    8
#define	RDB_K_FL_FLAGS_AUTO_CONTEXT       9

/* Mask name */
#define	RDB_M_FL_FLAGS_SQL_VALID_IF       (1<<RDB_K_FL_FLAGS_SQL_VALID_IF)
#define	RDB_M_FL_FLAGS_AUTO_INSERT        (1<<RDB_K_FL_FLAGS_AUTO_INSERT)
#define	RDB_M_FL_FLAGS_AUTO_UPDATE        (1<<RDB_K_FL_FLAGS_AUTO_UPDATE)
#define	RDB_M_FL_FLAGS_NAMED_VALID_IF     (1<<RDB_K_FL_FLAGS_NAMED_VALID_IF)
#define	RDB_M_FL_FLAGS_COLUMN_IDENTITY    (1<<RDB_K_FL_FLAGS_COLUMN_IDENTITY)
#define	RDB_M_FL_FLAGS_READ_ONLY          (1<<RDB_K_FL_FLAGS_READ_ONLY)
#define	RDB_M_FL_FLAGS_DISTINCT_TYPE      (1<<RDB_K_FL_FLAGS_DISTINCT_TYPE)
#define	RDB_M_FL_FLAGS_HIDDEN             (1<<RDB_K_FL_FLAGS_HIDDEN)
#define	RDB_M_FL_FLAGS_SHARED_COMPUTED    (1<<RDB_K_FL_FLAGS_SHARED_COMPUTED)
#define	RDB_M_FL_FLAGS_AUTO_CONTEXT       (1<<RDB_K_FL_FLAGS_AUTO_CONTEXT)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_FIELD_VERSIONS relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name			Value */
/* -------------			----- */
#define	RDB_K_FV_FLAGS_NULLS_ALLOWED      0
#define	RDB_K_FV_FLAGS_UNIQUE             1
#define	RDB_K_FV_FLAGS_DYNAMIC            2
#define	RDB_K_FV_FLAGS_INDIRECT           3
#define	RDB_K_FV_FLAGS_REF_TEMP_TABLE     4
#define	RDB_K_FV_FLAGS_SQL_VALID_IF       5
#define	RDB_K_FV_FLAGS_AUTO_INSERT        6
#define	RDB_K_FV_FLAGS_AUTO_UPDATE        7
#define	RDB_K_FV_FLAGS_NAMED_VALID_IF     8
#define	RDB_K_FV_FLAGS_COLUMN_IDENTITY    9
#define	RDB_K_FV_FLAGS_READ_ONLY          10
#define	RDB_K_FV_FLAGS_DISTINCT_TYPE      11
#define	RDB_K_FV_FLAGS_AUTO_CONTEXT       12

/* Mask name */
#define	RDB_M_FV_FLAGS_NULLS_ALLOWED      (1<<RDB_K_FV_FLAGS_NULLS_ALLOWED)
#define	RDB_M_FV_FLAGS_UNIQUE             (1<<RDB_K_FV_FLAGS_UNIQUE)
#define	RDB_M_FV_FLAGS_DYNAMIC            (1<<RDB_K_FV_FLAGS_DYNAMIC)
#define	RDB_M_FV_FLAGS_INDIRECT           (1<<RDB_K_FV_FLAGS_INDIRECT)
#define	RDB_M_FV_FLAGS_REF_TEMP_TABLE     (1<<RDB_K_FV_FLAGS_REF_TEMP_TABLE)
#define	RDB_M_FV_FLAGS_SQL_VALID_IF       (1<<RDB_K_FV_FLAGS_SQL_VALID_IF)
#define	RDB_M_FV_FLAGS_AUTO_INSERT        (1<<RDB_K_FV_FLAGS_AUTO_INSERT)
#define	RDB_M_FV_FLAGS_AUTO_UPDATE        (1<<RDB_K_FV_FLAGS_AUTO_UPDATE)
#define	RDB_M_FV_FLAGS_NAMED_VALID_IF     (1<<RDB_K_FV_FLAGS_NAMED_VALID_IF)
#define	RDB_M_FV_FLAGS_COLUMN_IDENTITY    (1<<RDB_K_FV_FLAGS_COLUMN_IDENTITY)
#define	RDB_M_FV_FLAGS_READ_ONLY          (1<<RDB_K_FV_FLAGS_READ_ONLY)
#define	RDB_M_FV_FLAGS_DISTINCT_TYPE      (1<<RDB_K_FV_FLAGS_DISTINCT_TYPE)
#define	RDB_M_FV_FLAGS_AUTO_CONTEXT       (1<<RDB_K_FV_FLAGS_AUTO_CONTEXT)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_FLAGS field 
 * in the RDB_OBJECT_SYNONYMS relation.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name                     Value */
#define	RDB_K_OS_FLAGS_SYNONYM_REF        0
#define	RDB_K_OS_FLAGS_CLIENT_SYNONYM     1
#define	RDB_K_OS_FLAGS_FROM_RENAME        2

#define	RDB_M_OS_FLAGS_SYNONYM_REF        (1<<RDB_K_OS_FLAGS_SYNONYM_REF)
#define	RDB_M_OS_FLAGS_CLIENT_SYNONYM     (1<<RDB_K_OS_FLAGS_CLIENT_SYNONYM)
#define	RDB_M_OS_FLAGS_FROM_RENAME        (1<<RDB_K_OS_FLAGS_FROM_RENAME)

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names refer to bit offsets in the RDB_K_INFO_DB_CAPABILITY1 
 * mask returned by RDB_DATABASE_INFO.  We have 32 bits.... 
 *----------------------------------------------------------------------------- 
 */
/* Symbolic name			Value */
/* -------------			----- */
#define	RDB_K_C1_FLAGS_AGG_LEVEL2         0
#define	RDB_K_C1_FLAGS_RENAME             1
#define	RDB_K_C1_FLAGS_BIT_UNUSED_BIT     2
#define	RDB_K_C1_FLAGS_CLONE_TABLE        3
#define	RDB_K_C1_FLAGS_BOOLEAN_TYPE       4
#define	RDB_K_C1_FLAGS_FN_OVERLAY         5
#define	RDB_K_C1_FLAGS_FN_MOD             6
#define	RDB_K_C1_FLAGS_FN_ROUND           7
#define	RDB_K_C1_FLAGS_UDT_LEVEL1         8
#define	RDB_K_C1_FLAGS_UDT_LEVEL2         9
#define	RDB_K_C1_FLAGS_LOB_LEVEL1         10
#define	RDB_K_C1_FLAGS_LOB_LEVEL2         11
#define	RDB_K_C1_FLAGS_AUTO_TRANS_SESS    12
#define	RDB_K_C1_FLAGS_AUTO_DEFAULT       13
#define	RDB_K_C1_FLAGS_QG_EXEC_TIMEOUT    14
#define	RDB_K_C1_FLAGS_FN_TRUNC           15
#define	RDB_K_C1_FLAGS_ALTER_VIEW         16
#define	RDB_K_C1_FLAGS_TAG_MSP            17
#define	RDB_K_C1_FLAGS_VECTOR_CONCAT      18
#define	RDB_K_C1_FLAGS_RENAME_MAP         19
#define	RDB_K_C1_FLAGS_LOB_LEVEL0         20
#define	RDB_K_C1_FLAGS_REPLACE_STMT       21
#define	RDB_K_C1_FLAGS_MERGE_STMT         22
#define	RDB_K_C1_FLAGS_FN_CONCAT_WS       23
#define	RDB_K_C1_FLAGS_LIKE_IGNORE_CASE   24

#define	RDB_M_C1_FLAGS_AGG_LEVEL2         (1<<RDB_K_C1_FLAGS_AGG_LEVEL2)
#define	RDB_M_C1_FLAGS_RENAME             (1<<RDB_K_C1_FLAGS_RENAME)
#define	RDB_M_C1_FLAGS_CLONE_TABLE        (1<<RDB_K_C1_FLAGS_CLONE_TABLE)
#define	RDB_M_C1_FLAGS_BOOLEAN_TYPE       (1<<RDB_K_C1_FLAGS_BOOLEAN_TYPE)
#define	RDB_M_C1_FLAGS_FN_OVERLAY         (1<<RDB_K_C1_FLAGS_FN_OVERLAY)
#define	RDB_M_C1_FLAGS_FN_MOD             (1<<RDB_K_C1_FLAGS_FN_MOD)
#define	RDB_M_C1_FLAGS_FN_ROUND           (1<<RDB_K_C1_FLAGS_FN_ROUND)
#define	RDB_M_C1_FLAGS_UDT_LEVEL1         (1<<RDB_K_C1_FLAGS_UDT_LEVEL1)
#define	RDB_M_C1_FLAGS_UDT_LEVEL2         (1<<RDB_K_C1_FLAGS_UDT_LEVEL2)
#define	RDB_M_C1_FLAGS_LOB_LEVEL1         (1<<RDB_K_C1_FLAGS_LOB_LEVEL1)
#define	RDB_M_C1_FLAGS_LOB_LEVEL2         (1<<RDB_K_C1_FLAGS_LOB_LEVEL2)
#define	RDB_M_C1_FLAGS_AUTO_TRANS_SESS    (1<<RDB_K_C1_FLAGS_AUTO_TRANS_SESS)
#define	RDB_M_C1_FLAGS_AUTO_DEFAULT       (1<<RDB_K_C1_FLAGS_AUTO_DEFAULT)
#define	RDB_M_C1_FLAGS_QG_EXEC_TIMEOUT    (1<<RDB_K_C1_FLAGS_QG_EXEC_TIMEOUT)
#define	RDB_M_C1_FLAGS_FN_TRUNC           (1<<RDB_K_C1_FLAGS_FN_TRUNC)
#define	RDB_M_C1_FLAGS_ALTER_VIEW         (1<<RDB_K_C1_FLAGS_ALTER_VIEW)
#define	RDB_M_C1_FLAGS_TAG_MSP            (1<<RDB_K_C1_FLAGS_TAG_MSP)
#define	RDB_M_C1_FLAGS_VECTOR_CONCAT      (1<<RDB_K_C1_FLAGS_VECTOR_CONCAT)
#define	RDB_M_C1_FLAGS_RENAME_MAP         (1<<RDB_K_C1_FLAGS_RENAME_MAP)
#define	RDB_M_C1_FLAGS_LOB_LEVEL0         (1<<RDB_K_C1_FLAGS_LOB_LEVEL0)
#define	RDB_M_C1_FLAGS_REPLACE_STMT       (1<<RDB_K_C1_FLAGS_REPLACE_STMT)
#define	RDB_M_C1_FLAGS_MERGE_STMT         (1<<RDB_K_C1_FLAGS_MERGE_STMT)
#define	RDB_M_C1_FLAGS_FN_CONCAT_WS       (1<<RDB_K_C1_FLAGS_FN_CONCAT_WS)
#define	RDB_M_C1_FLAGS_LIKE_IGNORE_CASE   (1<<RDB_K_C1_FLAGS_LIKE_IGNORE_CASE)

/*
 *----------------------------------------------------------------------------- 
 * These literals define the flags in the <parameter_type> field of 
 * BLR_K_PARAMETER4. 
 *----------------------------------------------------------------------------- 
 */
/* Bit 0, indicator field included. */
#define	RDB_M_PARAM_IND_PRESENT           1

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names for translations 
 *----------------------------------------------------------------------------- 
 */
#define	BLR_K_TRANS_UPPER                 -1
#define	BLR_K_TRANS_LOWER                 -2
#define	BLR_K_TRANS_MISSING_NONE          0
#define	BLR_K_TRANS_MISSING_DEFAULT       1
#define	BLR_K_TRANS_MISSING_SPECIFIED     2
#define	BLR_K_TRANS_MISSING_MAX           2

/*
 *----------------------------------------------------------------------------- 
 * Subcodes for BLR_K_TRANSACTION 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_TXN_START                   0
#define	RDB_K_TXN_COMMIT                  1
#define	RDB_K_TXN_ROLLBACK                2
#define	RDB_K_TXN_MARK_ESTABLISH          3
#define	RDB_K_TXN_MARK_COMMIT             4
#define	RDB_K_TXN_MARK_ROLLBACK           5
#define	RDB_K_TXN_RESERVE_TABLE           6
#define	RDB_K_TXN_EVALUATE_CONSTRAINT     7
#define	RDB_K_TXN_COMMIT_RESTART          8
#define	RDB_K_TXN_ROLLBACK_RESTART        9

/*
 *----------------------------------------------------------------------------- 
 * These literals define the join bits and join-type masks for BLR_K_JOIN 
 *----------------------------------------------------------------------------- 
 */
/* Join is outer */
#define	RDB_K_JOIN_OUTER                  0
/* Left Outer */
#define	RDB_K_JOIN_LEFT                   1
/* Right Outer */
#define	RDB_K_JOIN_RIGHT                  2
/* Cross Join */
#define	RDB_K_JOIN_CROSS                  3

/* Inner join type */
#define	RDB_M_RSE_JOIN_INNER              0
/* Left Outer Join type */
#define	RDB_M_RSE_JOIN_LEFT               (1<<RDB_K_JOIN_OUTER | 1<<RDB_K_JOIN_LEFT)
/* Right Outer Join type */
#define	RDB_M_RSE_JOIN_RIGHT              (1<<RDB_K_JOIN_OUTER | 1<<RDB_K_JOIN_RIGHT)
/* Full Outer Join type */
#define	RDB_M_RSE_JOIN_FULL               (RDB_M_RSE_JOIN_LEFT | RDB_M_RSE_JOIN_RIGHT)
/* Cross Join type */
#define	RDB_M_RSE_JOIN_CROSS              (1<<RDB_K_JOIN_CROSS)

/*
 *----------------------------------------------------------------------------- 
 * Private data types for Rdb/VMS 
 *----------------------------------------------------------------------------- 
 */
/* ANSI SQL2 Date/Time */
#define	DSC_K_DTYPE_DATETIME              178
/* Extended Character */
#define	DSC_K_DTYPE_CHAR                  179
/* Extended Varying Char */
#define	DSC_K_DTYPE_VCHAR                 180
/* Boolean (true/false) data type */
#define	DSC_K_DTYPE_BOOL                  181
/* Byte Varying (single segment blob) */
#define	DSC_K_DTYPE_VBYTE                 182
/* generic user-defined types */
#define	DSC_K_DTYPE_UDT                   183

/*...new values go here... */

/* External BLOB type */
#define	DSC_K_DTYPE_BLOB                  261

/*
 *----------------------------------------------------------------------------- 
 * The following values describe the function values used by BLR_K_EXTRACT. 
 * The values YEAR to FRACTION can also be used to index the vector filled 
 * by SYS_NUMTIM. 
 *----------------------------------------------------------------------------- 
 */
/* Minimum value for literal set */
#define	BLR_K_EXT_MIN                     0
/* YEAR was requested */
#define	BLR_K_EXT_YEAR                    0
/* MONTH was requested */
#define	BLR_K_EXT_MONTH                   1
/* DAY was requested */
#define	BLR_K_EXT_DAY                     2
/* HOUR was requested */
#define	BLR_K_EXT_HOUR                    3
/* MINUTE was requested */
#define	BLR_K_EXT_MINUTE                  4
/* SECOND was requested */
#define	BLR_K_EXT_SECOND                  5
/* **internal use only by BLR_K_EXTRACT** */
#define	BLR_K_EXT_FRACTION                6
/* Reserved for future use by Oracle */
#define	BLR_K_EXT_TZ_HOUR                 7
/* Reserved for future use by Oracle */
#define	BLR_K_EXT_TZ_MINUTE               8
/* Return a number of the day of the week */
#define	BLR_K_EXT_WEEKDAY                 9
/* Length of CHAR/VARCHAR */
#define	BLR_K_EXT_LENGTH                  10
/* Maximum length in bytes of data type */
#define	BLR_K_EXT_MAX_SIZE                11
/* Length of CHAR/VARCHAR in characters */
#define	BLR_K_EXT_NLENGTH                 12
/* Julian date */
#define	BLR_K_EXT_JULIAN                  13
/* Week number of the year */
#define	BLR_K_EXT_WEEKNUMBER              14
/* Year and week number */
#define	BLR_K_EXT_YEARWEEK                15

/* Maximum value for literal set */
#define	BLR_K_EXT_MAX                     15

/*
 *----------------------------------------------------------------------------- 
 * The following values describe the bit locations for the Date/Time 
 * Subtype field. 
 *----------------------------------------------------------------------------- 
 */
/* YEAR was specified in subtype */
#define	BLR_V_DT_YEAR                     0
/* MONTH was specified in subtype */
#define	BLR_V_DT_MONTH                    1
/* DAY was specified in subtype */
#define	BLR_V_DT_DAY                      2
/* HOUR was specified in subtype */
#define	BLR_V_DT_HOUR                     3
/* MINUTE was specified in subtype */
#define	BLR_V_DT_MINUTE                   4
/* SECOND was specified in subtype */
#define	BLR_V_DT_SECOND                   5
/* Reserved for future use by Oracle */
#define	BLR_V_DT_TZ_MINUTE                6
/* Reserved for future use by Oracle */
#define	BLR_V_DT_TZ_HOUR                  7
/* Reserved and MUST BE ZERO Used as a sentinal bit during parsing */
#define	BLR_V_DT_MBZ                      8
/* If this bit is set to 1 then the datetime is an INTERVAL */
#define	BLR_V_DT_INTERVAL                 9
/* reserved for future use by Oracle Indicates that this D/T contains zone */
#define	BLR_V_DT_TIME_ZONE                10
/* Used to indicate SQL99 formatting */
#define	BLR_V_DT_SQL99_FORMAT             11

/*
 *----------------------------------------------------------------------------- 
 * The following declarations represent the bit masks which can be used to 
 * directly compare against the subtype. 
 *----------------------------------------------------------------------------- 
 */
/* data type is pre-V4.1 DATE (ADT) field - same as TIMESTAMP */
#define	BLR_M_DT_TIMESTAMP_ADT            0

/* Individual bit masks used below to build compound subtypes */
/* datetime-field is YEAR */
#define	BLR_M_DT_YEAR                     (1<<BLR_V_DT_YEAR)
/* datetime-field is MONTH */
#define	BLR_M_DT_MONTH                    (1<<BLR_V_DT_MONTH)
/* datetime-field is DAY */
#define	BLR_M_DT_DAY                      (1<<BLR_V_DT_DAY)
/* datetime-field is HOUR */
#define	BLR_M_DT_HOUR                     (1<<BLR_V_DT_HOUR)
/* datetime-field is MINUTE */
#define	BLR_M_DT_MINUTE                   (1<<BLR_V_DT_MINUTE)
/* datetime-field is SECOND */
#define	BLR_M_DT_SECOND                   (1<<BLR_V_DT_SECOND)
/* bit indicates an INTERVAL */
#define	BLR_M_DT_INTERVAL                 (1<<BLR_V_DT_INTERVAL)
/* bit indicates a SQL99 format */
#define	BLR_M_DT_SQL99_FORMAT             (1<<BLR_V_DT_SQL99_FORMAT)

/* Compound data type masks */
/* data type is TIME */
#define	BLR_M_DT_TIME                     (BLR_M_DT_HOUR | BLR_M_DT_MINUTE | BLR_M_DT_SECOND)
/* data type is DATE */
#define	BLR_M_DT_DATE                     (BLR_M_DT_YEAR | BLR_M_DT_MONTH | BLR_M_DT_DAY)
/* data type is TIMESTAMP */
#define	BLR_M_DT_TIMESTAMP                (BLR_M_DT_DATE | BLR_M_DT_TIME)

/* Bit masks for INTERVAL data types (All 13 possible combinations) */
/* interval year */
#define	BLR_M_DT_INT_YEAR                 (BLR_M_DT_INTERVAL | BLR_M_DT_YEAR)
/* interval year to month */
#define	BLR_M_DT_INT_YEAR_MONTH           (BLR_M_DT_INTERVAL | BLR_M_DT_YEAR | BLR_M_DT_MONTH)

/* interval month */
#define	BLR_M_DT_INT_MONTH                (BLR_M_DT_INTERVAL | BLR_M_DT_MONTH)

/* interval day */
#define	BLR_M_DT_INT_DAY                  (BLR_M_DT_INTERVAL | BLR_M_DT_DAY)
/* interval day to hour */
#define	BLR_M_DT_INT_DAY_HOUR             (BLR_M_DT_INTERVAL | BLR_M_DT_DAY | BLR_M_DT_HOUR)
/* interval day to minute */
#define	BLR_M_DT_INT_DAY_MINUTE           \
	(BLR_M_DT_INTERVAL | BLR_M_DT_DAY | BLR_M_DT_HOUR | BLR_M_DT_MINUTE)
/* interval day to second */
#define	BLR_M_DT_INT_DAY_SECOND           \
	(BLR_M_DT_INTERVAL | BLR_M_DT_DAY | BLR_M_DT_TIME)

/* interval hour */
#define	BLR_M_DT_INT_HOUR                 \
	(BLR_M_DT_INTERVAL | BLR_M_DT_HOUR)
/* interval hour to minute */
#define	BLR_M_DT_INT_HOUR_MINUTE          \
	(BLR_M_DT_INTERVAL | BLR_M_DT_HOUR | BLR_M_DT_MINUTE)
/* interval hour to second */
#define	BLR_M_DT_INT_HOUR_SECOND          \
	(BLR_M_DT_INTERVAL | BLR_M_DT_TIME)

/* interval minute */
#define	BLR_M_DT_INT_MINUTE               \
	(BLR_M_DT_INTERVAL | BLR_M_DT_MINUTE)
/* interval minute to second */
#define	BLR_M_DT_INT_MINUTE_SECOND        \
	(BLR_M_DT_INTERVAL | BLR_M_DT_MINUTE | BLR_M_DT_SECOND)

/* interval second */
#define	BLR_M_DT_INT_SECOND               \
	(BLR_M_DT_INTERVAL | BLR_M_DT_SECOND)


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   OBLR    -- Outline Binary Language Representation Definitions 
 *   This section contains all the tags for OBLR. 
 *--------------------------------------------------------------------------- 
 */

#define	OBLR_K_MIN                        1
#define	OBLR_K_VERSION                    1
#define	OBLR_K_BEGIN                      2
#define	OBLR_K_END                        3
#define	OBLR_K_OUTLINE_NAME               4
#define	OBLR_K_OUTLINE_MODE               5
#define	OBLR_K_OUTLINE_ID                 6
#define	OBLR_K_OUTLINE_FLAGS              7
#define	OBLR_K_COMMENT                    8
#define	OBLR_K_RELATION                   9

#define	OBLR_K_ACCESS_ANY                 10
#define	OBLR_K_ACCESS_SEQUENTIAL          11
#define	OBLR_K_ACCESS_DBKEY               12
#define	OBLR_K_ACCESS_NO_INDEX            13
#define	OBLR_K_ACCESS_INDEX               14

#define	OBLR_K_JOIN_ANY                   15
#define	OBLR_K_JOIN_CROSS                 16
#define	OBLR_K_JOIN_MATCH                 17
#define	OBLR_K_JOIN_HASH                  18
#define	OBLR_K_UNION                      19

#define	OBLR_K_QUERY                      20
#define	OBLR_K_ORDERED                    21
#define	OBLR_K_UNORDERED                  22
#define	OBLR_K_SUBQUERY                   23
#define	OBLR_K_FLOATING                   24

/* OBLR_K_MODULE_RELATION <ascic_modulename> <ascic_relname> */
#define	OBLR_K_MODULE_RELATION            25

#define	OBLR_K_MAX                        25
#define	OBLR_K_EOC                        255

/*
 *--------------------------------------------------------------------------- 
 * Outline Flags 
 *--------------------------------------------------------------------------- 
 */
#define	RDB_K_OUTL_FLG_COMPLIANCE         0
#define	RDB_K_OUTL_FLG_NODYN              1
#define	RDB_K_OUTL_FLG_ANY                2
#define	RDB_K_OUTL_FLG_FAST_FIRST         3
#define	RDB_K_OUTL_FLG_TOTAL_TIME         4

/*
 *--------------------------------------------------------------------------- 
 * outline options 
 *--------------------------------------------------------------------------- 
 */
#define	RDB_K_OUTL_OPT_MIN                1
#define	RDB_K_OUTL_OPT_CREATE             1
#define	RDB_K_OUTL_OPT_STORE              2
#define	RDB_K_OUTL_OPT_USE_STORED         3
#define	RDB_K_OUTL_OPT_USE                4
#define	RDB_K_OUTL_OPT_USE_AUGMENT        5

#define	RDB_K_OUTL_OPT_MAX                5

/*
 *--------------------------------------------------------------------------- 
 * outline modes 
 *--------------------------------------------------------------------------- 
 */
#define	RDB_K_OUTL_MODE_MIN               0
#define	RDB_K_OUTL_MODE_DEFAULT           0
#define	RDB_K_OUTL_MODE_FAST_FIRST        1
#define	RDB_K_OUTL_MODE_TOTAL_TIME        2
#define	RDB_K_OUTL_MODE_MAX               2

#define	RDB_K_CURRENT_OBLR_VERSION        1

/*
 * Masks for AIJ OPER_CLASS 
 */
#define	RDB_M_OPR_NONE                    0
#define	RDB_M_OPR_CENTRAL                 1	/* bit  0 */
#define	RDB_M_OPR_PRINT                   2	/* bit  1: not used currently */
#define	RDB_M_OPR_TAPES                   4	/* bit  2: not used currently */
#define	RDB_M_OPR_DISKS                   8	/* bit  3 */
#define	RDB_M_OPR_DEVICE                  16	/* bit  4: not used currently */
#define	RDB_M_OPR_CARDS                   32	/* bit  5: not used currently */
#define	RDB_M_OPR_NETWORK                 64	/* bit  6: not used currently */
#define	RDB_M_OPR_CLUSTER                 128	/* bit  7 */
#define	RDB_M_OPR_SECURITY                256	/* bit  8 */
#define	RDB_M_OPR_REPLY                   512	/* bit  9: not used currently */
#define	RDB_M_OPR_SOFTWARE                1024	/* bit 10: Used by Oracle OEM console */
#define	RDB_M_OPR_LICENSE                 2048	/* bit 11: not used currently */
#define	RDB_M_OPR_OPER1                   4096	/* bit 12: */
#define	RDB_M_OPR_OPER2                   8192	/* bit 13 */
#define	RDB_M_OPR_OPER3                   16384	/* bit 14 */
#define	RDB_M_OPR_OPER4                   32768	/* bit 15 */
#define	RDB_M_OPR_OPER5                   65536	/* bit 16 */
#define	RDB_M_OPR_OPER6                   131072	/* bit 17 */
#define	RDB_M_OPR_OPER7                   262144	/* bit 18 */
#define	RDB_M_OPR_OPER8                   524288	/* bit 19 */
#define	RDB_M_OPR_OPER9                   1048576	/* bit 20 */
#define	RDB_M_OPR_OPER10                  2097152	/* bit 21 */
#define	RDB_M_OPR_OPER11                  4194304	/* bit 22 */
#define	RDB_M_OPR_OPER12                  8388608	/* bit 24 */

/* RDB_M_OPR_ALL does not include the bits not currently in use */
#define	RDB_M_OPR_ALL                     RDB_M_OPR_CENTRAL | \
                          RDB_M_OPR_DISKS | \
                          RDB_M_OPR_CLUSTER | \
                          RDB_M_OPR_SECURITY | \
			  RDB_M_OPR_SOFTWARE OR	/* ignored if not available */ \
                          RDB_M_OPR_OPER1 | \
                          RDB_M_OPR_OPER2 | \
                          RDB_M_OPR_OPER3 | \
                          RDB_M_OPR_OPER4 | \
                          RDB_M_OPR_OPER5 | \
                          RDB_M_OPR_OPER6 | \
                          RDB_M_OPR_OPER7 | \
                          RDB_M_OPR_OPER8 | \
                          RDB_M_OPR_OPER9 | \
                          RDB_M_OPR_OPER10 | \
                          RDB_M_OPR_OPER11 | \
                          RDB_M_OPR_OPER12


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   This section contains all the tags for segmented string manipulation. 
 *--------------------------------------------------------------------------- 
 */

/*
 *--------------------------------------------------------------------------- 
 * Options for the RDB_GET_SEGMENT call 
 *--------------------------------------------------------------------------- 
 */
#define	RDB_K_SCROLL_MIN                  0
/* Next segment */
#define	RDB_K_SCROLL_NEXT                 0
/* Prior segment */
#define	RDB_K_SCROLL_PRIOR                1
/* First segment */
#define	RDB_K_SCROLL_FIRST                2
/* Last segment */
#define	RDB_K_SCROLL_LAST                 3
/* Segment relative to last fetch */
#define	RDB_K_SCROLL_RELATIVE             4
/* Absolute reference to segment */
#define	RDB_K_SCROLL_ABSOLUTE             5
#define	RDB_K_SCROLL_MAX                  5

/*
 *--------------------------------------------------------------------------- 
 * Bit meanings for the OPERATION_FLAGS in RDB_OPEN_SEGMENTED_STRING call 
 *--------------------------------------------------------------------------- 
 */
/* bit 0 enables SCROLL LIST CURSOR */
#define	RDB_V_BLOB_ENABLE_SCROLL          0
/* bit 1 forces GET to truncate segment if output buffer is too small */
#define	RDB_V_BLOB_GET_TRUNCATE           1
#define	RDB_V_BLOB_DISABLE_PART_GET       RDB_V_BLOB_GET_TRUNCATE	/* obsolete */
/* bit 2 disables space filling (request interface only) */
#define	RDB_V_BLOB_GET_NOFILL             2
/* bit 3-5 identifies create options as different table types */
#define	RDB_V_BLOB_CREATE_LOCAL           3
#define	RDB_V_BLOB_CREATE_SCRATCH         4
#define	RDB_V_BLOB_CREATE_TABLE           5

/* Mask name				Value */
/* -------------			----- */
#define	RDB_M_BLOB_ENABLE_SCROLL          (1<<RDB_V_BLOB_ENABLE_SCROLL)
#define	RDB_M_BLOB_GET_TRUNCATE           (1<<RDB_V_BLOB_GET_TRUNCATE)
#define	RDB_M_BLOB_GET_NOFILL             (1<<RDB_V_BLOB_GET_NOFILL)
#define	RDB_M_BLOB_CREATE_LOCAL           (1<<RDB_V_BLOB_CREATE_LOCAL)
#define	RDB_M_BLOB_CREATE_SCRATCH         (1<<RDB_V_BLOB_CREATE_SCRATCH)
#define	RDB_M_BLOB_CREATE_TABLE           (1<<RDB_V_BLOB_CREATE_TABLE)


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   This section contains all the tags for internal communication. 
 *--------------------------------------------------------------------------- 
 */

/*
 *--------------------------------------------------------------------------- 
 * Control values 
 *--------------------------------------------------------------------------- 
 */
#define	RDB_K_INTCOM_MIN                  1
#define	RDB_K_INTCOM_END                  1
#define	RDB_K_INTCOM_TRUNCATED            2
#define	RDB_K_INTCOM_ERROR                3


/*
 *--------------------------------------------------------------------------- 
 * Internal communication tags 
 *--------------------------------------------------------------------------- 
 */
/* This tag has the format: */
/*   RDB_K_INTCOM_FUNCTION <length> {<ascic_string><address>} */
#define	RDB_K_INTCOM_FUNCTION             4

/*   RDB_K_INTCOM_USER_UIC <length> { uic value} */
#define	RDB_K_INTCOM_USER_UIC             5

/*	RDB_K_INTCOM_TRUSTED_BUF - passes the address of the special buffer */
#define	RDB_K_INTCOM_TRUSTED_BUF          6

/* All transactions on this attachment will follow XA rules. */
/* e.g. tids will be longer. */
#define	RDB_K_INTCOM_XA_COMPLIANT         7

/* This attach is for the purposes of recovering broken XA transactions. */
/* KODA may have to bypass some locks, as normally you can't attach to */
/* a DB that is awaiting recovery. */
#define	RDB_K_INTCOM_XA_RECOVERY          8

/* External function call backs use two client context values on ATTACH */
/* the current context (representing an external function) */
/* and the parent context (representing where the ATTACH was done inside */
/* of which the external function is executing). */
#define	RDB_K_INTCOM_CLIENT_CTX           9
#define	RDB_K_INTCOM_PARENT_CLIENT_CTX    10

#define	RDB_K_INTCOM_MAX                  10

/*
 *--------------------------------------------------------------------------- 
 * External Routine Notification types 
 * NOTE: The values are documented and passed to external routines as params. 
 *       Precise ordering is crucial. Values 1 thru 255 are reserved to Rdb. 
 *--------------------------------------------------------------------------- 
 */
#define	RDB_K_RTX_NOTIFY_MIN              1
#define	RDB_K_RTX_NOTIFY_ACTV_START       1	/*  1 */
#define	RDB_K_RTX_NOTIFY_ACTV_END         2	/*  2 */
#define	RDB_K_RTX_NOTIFY_CONN_START       3	/*  3 */
#define	RDB_K_RTX_NOTIFY_CONN_END         4	/*  4 */
#define	RDB_K_RTX_NOTIFY_TRAN_START       5	/*  5 */
#define	RDB_K_RTX_NOTIFY_TRAN_COMMIT      6	/*  6 */
#define	RDB_K_RTX_NOTIFY_TRAN_ROLLBACK    7	/*  7 */
#define	RDB_K_RTX_NOTIFY_STMT_START       8	/*  8 */
#define	RDB_K_RTX_NOTIFY_STMT_FAILURE     9	/*  9 */
#define	RDB_K_RTX_NOTIFY_STMT_SUCCESS     10	/* 10 */
#define	RDB_K_RTX_NOTIFY_MAX              10

/*
 *--------------------------------------------------------------------------- 
 * External Routine error types 
 *--------------------------------------------------------------------------- 
 */
#define	RDB_K_RTX_ERR_MIN                 1
#define	RDB_K_RTX_ERR_ACTIVATE            1
#define	RDB_K_RTX_ERR_ACT_INSTALL         2
#define	RDB_K_RTX_ERR_BIND_BODY_ENT       3
#define	RDB_K_RTX_ERR_BIND_NTFY_ENT       4
#define	RDB_K_RTX_ERR_EXECUTE             5
#define	RDB_K_RTX_ERR_NOTIFY              6
#define	RDB_K_RTX_ERR_DEACTIVATE          7
#define	RDB_K_RTX_ERR_CANCEL              8
#define	RDB_K_RTX_ERR_CLIENT_SITE         9
#define	RDB_K_RTX_ERR_SERVER_SITE         10
#define	RDB_K_RTX_ERR_UNKNOWN             11
#define	RDB_K_RTX_ERR_MAX                 11


/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 *   MBLR_K_<mumbo> 
 *   MBLR_K_<yyy>_<mumbo> 
 *   This section contains all the values for the Metadata Binary Language 
 *   Representation tags.  The tags are used to describe the DDL operations. 
 *--------------------------------------------------------------------------- 
 */

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names for source language set 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_LANGUAGE_UNDEFINED          0
#define	RDB_K_LANGUAGE_ADA                1
#define	RDB_K_LANGUAGE_C                  2
#define	RDB_K_LANGUAGE_COBOL              3
#define	RDB_K_LANGUAGE_FORTRAN            4
#define	RDB_K_LANGUAGE_PASCAL             5
#define	RDB_K_LANGUAGE_MUMPS              6
#define	RDB_K_LANGUAGE_BASIC              7
#define	RDB_K_LANGUAGE_GENERAL            8
#define	RDB_K_LANGUAGE_PLI                9
#define	RDB_K_LANGUAGE_SQL                10
#define	RDB_K_LANGUAGE_JAVA               11

/*
 *----------------------------------------------------------------------------- 
 * These symbolic names for parameter modes 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_MODE_UNDEFINED              0
#define	RDB_K_MODE_IN                     1
#define	RDB_K_MODE_OUT                    2
#define	RDB_K_MODE_INOUT                  3
#define	RDB_K_MODE_RETURN                 4
#define	RDB_K_MODE_CAST_FROM              5

/*
 *----------------------------------------------------------------------------- 
 * Symbolic names for parameter mechanisms 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_MECH_REFERENCE              0
#define	RDB_K_MECH_DESCRIPTOR             1
#define	RDB_K_MECH_VALUE                  2
#define	RDB_K_MECH_LENGTH                 3

/*
 *----------------------------------------------------------------------------- 
 * Symbolic names for external routine execution options 
 *----------------------------------------------------------------------------- 
 * External routine execution sites 
 */
/* Client process node */
#define	RDB_K_RTX_SITE_CLIENT             0
/* Server process node */
#define	RDB_K_RTX_SITE_SERVER             1

/*
 * External routine deactivation scopes 
 */
#define	RDB_K_RTX_DEACTIVATE_MIN          1
/* End of defining DB connect scope */
#define	RDB_K_RTX_DEACTIVATE_CONN         1
/* End of defining DB transaction scope */
#define	RDB_K_RTX_DEACTIVATE_TRAN         2
/* End of defining DB statement scope */
#define	RDB_K_RTX_DEACTIVATE_STMT         3
#define	RDB_K_RTX_DEACTIVATE_MAX          3

/*
 *----------------------------------------------------------------------------- 
 * Different types of special tables and commit options (re: MBLR_K_TABLE_TYPE) 
 *----------------------------------------------------------------------------- 
 */
#define	RDB_K_TBL_TEMP_GLOBAL             0
#define	RDB_K_TBL_TEMP_LOCAL              1
#define	RDB_K_TBL_TEMP_SCRATCH            2
#define	RDB_K_TBL_DERIVED_DATA            3	/* INFORMATION table */
#define	RDB_K_TBL_VIEW                    4
#define	RDB_K_TBL_DATA                    5

#define	RDB_K_TBLCMT_NONE                 0
#define	RDB_K_TBLCMT_PRESERVE             1	/* preserve data on commit */
#define	RDB_K_TBLCMT_DELETE               2	/* delete data on commit */

/*
 *----------------------------------------------------------------------------- 
 * MBLR_K_POSITION (when used in MBLR_K_CHANGE on MBLR_K_RELATION_DEF) allows 
 * options for ordering 
 *----------------------------------------------------------------------------- 
 */

#define	RDB_K_POS_BEFORE                  0
#define	RDB_K_POS_AFTER                   1

/*
 *----------------------------------------------------------------------------- 
 * MBLR operation tags 
 *----------------------------------------------------------------------------- 
 */
/* Alter an existing definition */
#define	MBLR_K_CHANGE                     1
/* Create a new definition */
#define	MBLR_K_DEFINE                     2
/* Drop a definition */
#define	MBLR_K_DELETE                     3
/* Alter a definition and cascade the change */
#define	MBLR_K_CHANGE_CASCADE             4
/* Drop a definition and cascade the change */
#define	MBLR_K_DELETE_CASCADE             5
/* Create a new definition, or replace one of the same name */
#define	MBLR_K_DEFINE_REPLACE             6
/* Declare a definition (temporary memory version) */
#define	MBLR_K_DECLARE_LOCAL              7

/* Maximum operation */
#define	MBLR_K_OPERATION                  7

/*
 *----------------------------------------------------------------------------- 
 * MBLR tags 
 * Note: that many of these tags are marked as obsolete.  It seems they were 
 * defined but never used.  They are gradually being reused, but they must be 
 * retained for older versions of Rdb.  Because this is a non-version specific 
 * definition file. 
 *----------------------------------------------------------------------------- 
 */

#define	MBLR_K_DUPLICATES_SETUP           1	/* duplicates setup definition */
#define	MBLR_K_AIJ                        1	/* obsolete */
#define	MBLR_K_DUPLICATES_END             2	/* end of duplicates setup */
#define	MBLR_K_ALLOCATION                 2	/* obsolete */
#define	MBLR_K_TRUNCATE                   3	/* truncate data */
#define	MBLR_K_BUFFERS                    3	/* obsolete */
#define	MBLR_K_TABLE_TYPE                 4	/* temp/derived tables */
#define	MBLR_K_BUFFER_LEN                 4	/* obsolete */
#define	MBLR_K_CDD_PATH                   5
#define	MBLR_K_CHANGE_FIELD               6
#define	MBLR_K_CONSTRAINT                 7
#define	MBLR_K_CONSTRAINT_DEF             8
#define	MBLR_K_CONSTRAINT_END             9
#define	MBLR_K_DESCRIPTOR                 10
#define	MBLR_K_DEFINE_FIELD               11
#define	MBLR_K_DELETE_FIELD               12
#define	MBLR_K_DTR_DEF_VAL                13
#define	MBLR_K_DTR_EDIT_STR               14
#define	MBLR_K_DTR_QRY_HDR                15
#define	MBLR_K_DTR_QRY_HDR_LINE           16
#define	MBLR_K_DTR_QRY_HDR_END            17
#define	MBLR_K_DUPLICATES                 18
#define	MBLR_K_FIELD_DEF                  19
#define	MBLR_K_FIELD_END                  20
#define	MBLR_K_FIELD_EXPRESSION           21
#define	MBLR_K_FIELD_NAM                  22
#define	MBLR_K_FIELD_NOUPDATE             23
#define	MBLR_K_FIELD_UPDATE               24
#define	MBLR_K_INDEX_ONLY                 25	/* INDEX ONLY table */
#define	MBLR_K_FILE                       25	/* obsolete */
#define	MBLR_K_INDEX_DEF                  26
#define	MBLR_K_INDEX_END                  27
#define	MBLR_K_MISSING_VALUE              28
#define	MBLR_K_PARTITION                  29
#define	MBLR_K_NUM_BUFF                   29	/* obsolete */
#define	MBLR_K_BUFFER_SIZE                30
#define	MBLR_K_PAGE_SIZE                  30	/* obsolete */
#define	MBLR_K_RELATION_DEF               31
#define	MBLR_K_RELATION_END               32
#define	MBLR_K_RELATION_NAME              33
#define	MBLR_K_RSE                        34
#define	MBLR_K_VALID_IF                   35
#define	MBLR_K_VIEW_DEF                   36
#define	MBLR_K_VIEW_END                   37
#define	MBLR_K_CHANGE_ATTRIBUTES          38
#define	MBLR_K_DELETE_ATTRIBUTES          39
#define	MBLR_K_COMMIT                     40
#define	MBLR_K_UPDATE                     41
#define	MBLR_K_DTR_QRY_NAM                42
#define	MBLR_K_VALID_IF_SOURCE            43
#define	MBLR_K_COMPUTED_BY_SOURCE         44
#define	MBLR_K_RSE_SOURCE                 45
#define	MBLR_K_CONSTRAINT_SOURCE          46
#define	MBLR_K_PARTIAL_BLR                47
#define	MBLR_K_ABSTIM                     47	/* obsolete */
#define	MBLR_K_DCL_GLOBAL_VARIABLE        48
#define	MBLR_K_OPEN_CLOSE                 48	/* obsolete */
#define	MBLR_K_INCREMENT_BY               49
#define	MBLR_K_VOLLAB                     49	/* obsolete */
#define	MBLR_K_OBJECT_FLAGS               50
#define	MBLR_K_SEQUENCE_FLAGS             MBLR_K_OBJECT_FLAGS	/* synonym */
#define	MBLR_K_NUMBER_OF_USERS            MBLR_K_OBJECT_FLAGS	/* obsolete */
#define	MBLR_K_DESCRIPTION_SOURCE         51
#define	MBLR_K_SUB_TYPE                   52
#define	MBLR_K_SEGMENT_LENGTH             53
#define	MBLR_K_RELATION_ACL               54
#define	MBLR_K_DATABASE_ACL               55
#define	MBLR_K_CONTINUOUS_FLAG            56
#define	MBLR_K_TRANSFER_DEF               57
#define	MBLR_K_TRANSFER_END               58
#define	MBLR_K_SELECTION_BLR              59
#define	MBLR_K_SEQUENCE_DEF               60
#define	MBLR_K_OPEN                       60	/* obsolete */
#define	MBLR_K_SEQUENCE_END               61
#define	MBLR_K_CLOSE                      61	/* obsolete */
#define	MBLR_K_NOJOURNAL                  62
#define	MBLR_K_PARTITION_NAME             63
#define	MBLR_K_EXIT                       63	/* obsolete */
#define	MBLR_K_OVERFLOW_AREA_DEF          64	/* overflow area definition */
#define	MBLR_K_DELETION                   64	/* obsolete */
#define	MBLR_K_OVERFLOW_AREA_END          65	/* end of overflow area */
#define	MBLR_K_CLUSTER                    65	/* obsolete */

#define	MBLR_K_EXTENSION                  66
#define	MBLR_K_STORAGE_MAP_DEF            67
#define	MBLR_K_STORAGE_MAP_END            68
#define	MBLR_K_STORAGE_MAP_COMPRESS       69
#define	MBLR_K_STORAGE_AREA_DEF           70
#define	MBLR_K_STORAGE_AREA_NAME          71
#define	MBLR_K_STORAGE_AREA_BLR           72
#define	MBLR_K_STORAGE_AREA_END           73
#define	MBLR_K_STORAGE_VIA_INDEX          74
#define	MBLR_K_HASHED_INDEX               75
#define	MBLR_K_STORAGE_MAP_SOURCE         76
#define	MBLR_K_INDEX_FIELD_ASCENDING      77
#define	MBLR_K_INDEX_FIELD_DESCENDING     78
#define	MBLR_K_DEFAULT_VALUE              79
#define	MBLR_K_CHECK_OPTION               80
#define	MBLR_K_TRIGGER_DEF                81
#define	MBLR_K_TRIGGER_END                82
#define	MBLR_K_TRIGGER_BEFORE_STORE       83
#define	MBLR_K_TRIGGER_BEFORE_ERASE       84
#define	MBLR_K_TRIGGER_BEFORE_MODIFY      85
#define	MBLR_K_TRIGGER_AFTER_STORE        86
#define	MBLR_K_TRIGGER_AFTER_ERASE        87
#define	MBLR_K_TRIGGER_AFTER_MODIFY       88
#define	MBLR_K_TRIGGER_CONTEXT            89
#define	MBLR_K_TRIGGER_ACTION             90
#define	MBLR_K_TRIGGER_ACTION_END         91
#define	MBLR_K_TRIGGER_OLD_CONTEXT        92
#define	MBLR_K_TRIGGER_NEW_CONTEXT        93
#define	MBLR_K_TRIGGER_FOR_EACH_ROW       94
#define	MBLR_K_TRIGGER_CONDITION          95
#define	MBLR_K_TRIGGER_STATEMENT          96
#define	MBLR_K_TRIGGER_SOURCE             97
#define	MBLR_K_RELATION_CONSTRAINT_DEF    98
#define	MBLR_K_RELATION_CONSTRAINT_END    99
#define	MBLR_K_REL_CONSTRAINT_SOURCE      100
#define	MBLR_K_RELATION_CONSTRAINT        101
#define	MBLR_K_FIELD_CONSTRAINT           102
#define	MBLR_K_CONDITION                  103
#define	MBLR_K_NOT_NULL                   104
#define	MBLR_K_PRIMARY_KEY                105
#define	MBLR_K_UNIQUE_KEY                 106
#define	MBLR_K_FOREIGN_KEY                107
#define	MBLR_K_KEY_END                    108
#define	MBLR_K_MATCH_ALL                  109
#define	MBLR_K_MODIFY_ACTION              110
#define	MBLR_K_ERASE_ACTION               111

/* future SQL-92 work */
#define	MBLR_K_CASCADE                    112
/* future SQL-92 work */
#define	MBLR_K_SET_NULL                   113
/* future SQL-92 work */
#define	MBLR_K_SET_DEFAULT                114

#define	MBLR_K_DELETE_CONSTRAINT          115
#define	MBLR_K_STORAGE_MAP_REORGANIZE     116
#define	MBLR_K_COLLATION_DEF              117
#define	MBLR_K_COLLATION                  118
#define	MBLR_K_COLLATION_END              119
#define	MBLR_K_FIELD_ACL                  120
#define	MBLR_K_GRANTEE                    121
#define	MBLR_K_USER_VISIBLE_NAME          122
#define	MBLR_K_POSITION                   123
#define	MBLR_K_AFTER_UIC                  124
#define	MBLR_K_DEFINE_PRIVILEGE           125
#define	MBLR_K_DELETE_PRIVILEGE           126
#define	MBLR_K_GRANTOR                    127
#define	MBLR_K_ACL_END                    128
#define	MBLR_K_INDEX_FIELD_SIZE           129
#define	MBLR_K_INDEX_FIELD_MAPPING        130
#define	MBLR_K_SEGMENTS                   131

/* UNUSED */
#define	MBLR_K_DEFAULT                    132

#define	MBLR_K_FIELD_NAM_LIST             133
#define	MBLR_K_FIELD_NAM_END              134
/* SERdb Single Level table constraint */
#define	MBLR_K_SINGLE_LEVEL               135
/* SERdb Security classification */
#define	MBLR_K_CLASSIFICATION             136

/*
 *++ 
 * The following items (also MBLR_K_USER_VISIBLE_NAME defined above, and 
 * MBLR_K_SCHEMA_AUTH_ID defined below) are used for SQL multischema support 
 */
#define	MBLR_K_CATALOG_DEF                137
#define	MBLR_K_CATALOG_ID                 138
#define	MBLR_K_CATALOG_END                139
#define	MBLR_K_SCHEMA_DEF                 140
#define	MBLR_K_SCHEMA_ID                  141
#define	MBLR_K_SCHEMA_END                 142
#define	MBLR_K_SYNONYM_DEF                143
#define	MBLR_K_SYNONYM_END                144
/* LAREA Thresholds */
#define	MBLR_K_THRESHOLD                  145
/* Mschema AUTH ID */
#define	MBLR_K_OBJECT_OWNER               146
/* (provide synonym) */
#define	MBLR_K_SCHEMA_AUTH_ID             MBLR_K_OBJECT_OWNER

/*
 *-- 
 */
/* SQL Flag setting */
#define	MBLR_K_VIEW_NOT_UPDATEABLE        147
/* segstr storage set */
#define	MBLR_K_AREA_SET                   148
/* constraint evaluation */
#define	MBLR_K_UPDATE_NOT_DEFERRABLE      149
/* mapping value descriptors */
#define	MBLR_K_INDEX_FIELD_MAPPING_DSC    150

/*
 *++ 
 * DBI (Database Integrator) special tags 
 */
#define	MBLR_K_IMPORT_TABLE               151
#define	MBLR_K_LINK_TABLE                 152
#define	MBLR_K_LINK_NAME                  153
#define	MBLR_K_LINK_DEF                   154
#define	MBLR_K_LINK_CONNECT               155
#define	MBLR_K_LINK_END                   156
#define	MBLR_K_CHANGE_PROXY               157
#define	MBLR_K_DEFINE_PROXY               158
#define	MBLR_K_DELETE_PROXY               159
#define	MBLR_K_PROXY_ACCESS_INFO          160
#define	MBLR_K_LINK_USER                  161
#define	MBLR_K_DEFAULT_PARTITION          162
#define	MBLR_K_PARTITION_DEF              163
#define	MBLR_K_PARTITION_END              164
#define	MBLR_K_PARTITION_QUALIFIER        165
#define	MBLR_K_REIMPORT_TABLE             166
#define	MBLR_K_UPDATE_TABLE_STATISTICS    167

/*
 *-- 
 *++ 
 * Tags for functions/stored procedures 
 */

/* routine definition */
#define	MBLR_K_ROUTINE_DEF                168
/* routine definition end */
#define	MBLR_K_ROUTINE_END                169
/* routine language */
#define	MBLR_K_LANGUAGE                   170
#define	MBLR_K_DEFINE_ROUTINE             171
#define	MBLR_K_DELETE_ROUTINE             172
/* type of parameter */
#define	MBLR_K_MODE                       173
/* module definition */
#define	MBLR_K_MODULE_DEF                 174
/* module def end */
#define	MBLR_K_MODULE_END                 175
/* def db object priv. */
#define	MBLR_K_OBJECT_ACL                 176
/* object BLR */
#define	MBLR_K_OBJECT_BLR                 177
/* object source */
#define	MBLR_K_OBJECT_SOURCE              178
/* parameter mechanism */
#define	MBLR_K_PARAMETER_MECHANISM        179

/*
 *-- 
 */
/* outline definition */
#define	MBLR_K_OUTLINE_DEF                180
/* end of outline */
#define	MBLR_K_OUTLINE_END                181
/* unique BLR id */
#define	MBLR_K_SIGNATURE                  182
/* name of object */
#define	MBLR_K_OBJECT_NAME                183
#define	MBLR_K_OUTLINE_NAME               MBLR_K_OBJECT_NAME	/* (obsolete) */

/* Tags to define the MIN and MAX for sequences */
#define	MBLR_K_MAXIMUM_VALUE              184
#define	MBLR_K_MINIMUM_VALUE              185

/* tags for the profile support */
#define	MBLR_K_PROFILE_DEF                186
#define	MBLR_K_PROFILE_END                187
#define	MBLR_K_DEFINE_PROFILE             188
#define	MBLR_K_DELETE_PROFILE             189

/* Misc V7.1 tags */
#define	MBLR_K_END_ATTRIBUTES             190
#define	MBLR_K_CHANGE_PROFILE             191
#define	MBLR_K_TYPE_DEF                   192
#define	MBLR_K_TYPE_END                   193

/* Set the HIDDEN flag for the object */
#define	MBLR_K_HIDDEN_OBJECT              194
#define	MBLR_K_DELETE_FIELD_CASCADE       195

/* Instead of triggers (for view) */
#define	MBLR_K_TRIGGER_INSTEAD_OF         196
#define	MBLR_K_IDENTITY                   197
#define	MBLR_K_DEFAULT_SOURCE             198


/*
 * Note: please reserve 255 as the MBLR_K_EXTENDER 
 */

#define	MBLR_K_LAST_ITEM                  199

/*
 *----------------------------------------------------------------------------- 
 * MBLR version tags 
 *----------------------------------------------------------------------------- 
 */
#define	MBLR_K_VERSION_1                  1
#define	MBLR_K_VERSION_2                  2

/*
 * MBLR tags ranges 
 */
#define	MBLR_K_FIRST                      1
#define	MBLR_K_LAST                       MBLR_K_LAST_ITEM

/*
 *----------------------------------------------------------------------------- 
 * MBLR_K_EXT_<mumbo> 
 * MBLR extension tags 
 *----------------------------------------------------------------------------- 
 */

#define	MBLR_K_EXT_INDEX_NODE_SIZE        1
#define	MBLR_K_EXT_INDEX_PERCENT_FILL     2
#define	MBLR_K_EXT_AREA_NAME              3	/* (OBSOLETE) */
#define	MBLR_K_EXT_COMPRESSION            4
#define	MBLR_K_EXT_TRACE                  5	/* (OBSOLETE) */
#define	MBLR_K_EXT_AIJ_BUFFERS            6	/* (OBSOLETE) */
/* Ext Rtn image location */
#define	MBLR_K_EXT_LOCATION               7
/* Ext Rtn body entry point */
#define	MBLR_K_EXT_ENTRY_POINT            8
/* Ext Rtn I/O limit */
#define	MBLR_K_EXT_NUMBER_OF_IOS          9
/* Ext Rtn Instruction limit */
#define	MBLR_K_EXT_CPU_INSTRUCTIONS       10
/* Ext Rtn notify entry point */
/* (also maintain EXT_CLEANUP for backward compatibility) */
#define	MBLR_K_EXT_NOTIFY_ENTRY_POINT     11
#define	MBLR_K_EXT_CLEANUP                MBLR_K_EXT_NOTIFY_ENTRY_POINT
/* compression attribute */
#define	MBLR_K_EXT_MIN_RUN_LENGTH         12
/* compressed octets */
#define	MBLR_K_EXT_COMP_SPACE_OCTETS      13
/* subtype of HASH */
#define	MBLR_K_EXT_HASH_TYPE              14
/* maint for index */
#define	MBLR_K_EXT_MAINTENANCE            15
/* is routine variant */
#define	MBLR_K_EXT_VARIANT                16
/* default tpb for module */
#define	MBLR_K_EXT_DEFAULT_TXN            17
/* compact params for rtn */
#define	MBLR_K_EXT_SQL_PARAMETERS         18
/* select * dependency */
#define	MBLR_K_EXT_LANG_TBL_DEPENDENCY    19
/* for stored procedures */
#define	MBLR_K_EXT_COMPILE_OPTIONS        20
/* Ext Rtn image security type */
#define	MBLR_K_EXT_SECURE_LOCATION        21
/* Ext Rtn param style */
#define	MBLR_K_EXT_SQL_PARAM_STYLE        22
/* Ext Rtn execution site */
#define	MBLR_K_EXT_EXECUTION_SITE         23
/* Ext Rtn notify on database connect beg/end */
#define	MBLR_K_EXT_NOTIFY_CONN            24
/* Ext Rtn notify on transaction beg/end */
#define	MBLR_K_EXT_NOTIFY_TRAN            25
/* Ext Rtn notify on statement beg/end */
#define	MBLR_K_EXT_NOTIFY_STMT            26
/* Ext Rtn notify on activation/deactivation */
#define	MBLR_K_EXT_NOTIFY_ACTIVATE        27
/* Ext Rtn image deactivation scope */
#define	MBLR_K_EXT_DEACTIVATE_IMAGE       28
/* Temporary DDL for this module */
#define	MBLR_K_EXT_TEMPORARY_DDL          29
/* subtype of SORT */
#define	MBLR_K_EXT_SORT_TYPE              30
/* add new tag which directs use of the definition as SQL semantics */
#define	MBLR_K_EXT_SQL_SEMANTICS          31
/* tags which control defaults for query governor */
#define	MBLR_K_EXT_LIMIT_COMP_CPU_TIME    32
#define	MBLR_K_EXT_LIMIT_COMP_TIME        33
#define	MBLR_K_EXT_LIMIT_QRY_ROWS         34
/* tag for the default transaction modes */
#define	MBLR_K_EXT_TXN_MODES              35
/* tag to describe the security domain */
#define	MBLR_K_EXT_SECURITY_DOMAIN        36
/* tag to pass encrypted password */
#define	MBLR_K_EXT_ACCESS_PASSWORD        37
/* tag to indicate if the external routine is threadsafe or not */
#define	MBLR_K_EXT_THREADSAFE             38
/* tag to enable NULL propagation */
#define	MBLR_K_EXT_PROPAGATE_NULL         39
/* tag to list SID's on Windows NT */
#define	MBLR_K_EXT_OS_SECURITY_ID         40
#define	MBLR_K_EXT_OS_SECURITY_ID_W       41
#define	MBLR_K_EXT_CARD_COLLECT           42
#define	MBLR_K_EXT_PRIOR_PARTITION_BLR    43
#define	MBLR_K_EXT_DEFAULT2_SOURCE        44
#define	MBLR_K_EXT_VALID_IF_NAME          45
#define	MBLR_K_EXT_COLLATION_NAME         46
#define	MBLR_K_EXT_LOCAL_ROUTINE          47
#define	MBLR_K_EXT_INDEX_CARDINALITY      48
#define	MBLR_K_EXT_JAVA_BYTECODE          49
#define	MBLR_K_EXT_JAVA_JARNAME           50 
#define	MBLR_K_EXT_JAVA_CLASSNAME         51

#define	MBLR_K_EXT_LAST_ITEM              52	/* ** Last item number */

/*
 * The MBLR_K_EXT_SQL_PARAMETERS buffer is also encoded in TLV format. 
 */
#define	RDB_K_SQLPAR_VERSION              1
#define	RDB_K_SQLPAR_MIN                  RDB_K_SQLPAR_VERSION
#define	RDB_K_SQLPAR_SQLCODE_INDEX        2
#define	RDB_K_SQLPAR_SQLSTATE_INDEX       3
#define	RDB_K_SQLPAR_SEND_MSG             4
#define	RDB_K_SQLPAR_RCV_MSG              5
#define	RDB_K_SQLPAR_ALWAYS_NULL_INDEX    6
#define	RDB_K_SQLPAR_NEVER_NULL_INDEX     7
#define	RDB_K_SQLPAR_OPEN_ACTION          8
#define	RDB_K_SQLPAR_CLOSE_ACTION         9
#define	RDB_K_SQLPAR_DELETE_ACTION        10
#define	RDB_K_SQLPAR_FETCH_ACTION         11
#define	RDB_K_SQLPAR_INSERT_ACTION        12
#define	RDB_K_SQLPAR_UPDATE_ACTION        13
#define	RDB_K_SQLPAR_MAX                  13

/*
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 * RDB_K_OTYP_ 
 * These literals are the types used by RDB_OBJECT_SEQUENCES 
 *--------------------------------------------------------------------------- 
 */

#define	RDB_K_OTYP_MS_RELATION            MBLR_K_RELATION_DEF
#define	RDB_K_OTYP_MS_VIEW                MBLR_K_VIEW_DEF
#define	RDB_K_OTYP_MS_COLLATION           MBLR_K_COLLATION_DEF
#define	RDB_K_OTYP_MS_CONSTRAINT          MBLR_K_CONSTRAINT_DEF
#define	RDB_K_OTYP_MS_FIELD               MBLR_K_FIELD_DEF
#define	RDB_K_OTYP_MS_INDEX               MBLR_K_INDEX_DEF
#define	RDB_K_OTYP_MS_STORAGE_MAP         MBLR_K_STORAGE_MAP_DEF
#define	RDB_K_OTYP_MS_TRIGGER             MBLR_K_TRIGGER_DEF
#define	RDB_K_OTYP_MS_SEQUENCE            MBLR_K_SEQUENCE_DEF
#define	RDB_K_OTYP_MS_MODULE              MBLR_K_MODULE_DEF
#define	RDB_K_OTYP_MS_ROUTINE             MBLR_K_ROUTINE_DEF
#define	RDB_K_OTYP_MS_TYPE                MBLR_K_TYPE_DEF

#define	RDB_K_OTYP_UNKNOWN                0

#define	RDB_K_OTYP_DIRECTORY              -1
#define	RDB_K_OTYP_FIELD                  -2	/* aka DOMAIN */
#define	RDB_K_OTYP_FUNCTION               -3
#define	RDB_K_OTYP_LIBRARY                -4
#define	RDB_K_OTYP_MODULE                 -5
#define	RDB_K_OTYP_PROCEDURE              -6
#define	RDB_K_OTYP_RELATION               -7
#define	RDB_K_OTYP_SEQUENCE               -8
#define	RDB_K_OTYP_SYNONYM                -9
#define	RDB_K_OTYP_TYPE                   -10	/* aka user defined type */
#define	RDB_K_OTYP_VIEW                   -11
#define	RDB_K_OTYP_OUTLINE                -12
#define	RDB_K_OTYP_TRIGGER                -13
#define	RDB_K_OTYP_CONSTRAINT             -14
#define	RDB_K_OTYP_USER                   -15
#define	RDB_K_OTYP_ROLE                   -16
#define	RDB_K_OTYP_PROFILE                -17
#define	RDB_K_OTYP_COLUMN                 -18
#define	RDB_K_OTYP_INDEX                  -19
#define	RDB_K_OTYP_STORAGE_MAP            -20

/*
 *----------------------------------------------------------------------------- 
 * MBLR_K_STORAGE_MAP_REORG_<mumbo> 
 * MBLR storage map reorg tags 
 *----------------------------------------------------------------------------- 
 */
#define	MBLR_K_STORAGE_MAP_REORG_FIRST    0
#define	MBLR_K_STORAGE_MAP_REORG_NONE     0
#define	MBLR_K_STORAGE_MAP_REORG_AREAS    1
#define	MBLR_K_STORAGE_MAP_REORG_PAGES    2
#define	MBLR_K_STORAGE_MAP_REORG_PARTS    3

#define	MBLR_K_STORAGE_MAP_REORG_LAST     3


/*
 *----------------------------------------------------------------------------- 
 * Segmented string storage map MBLR 
 *----------------------------------------------------------------------------- 
 */
#define	MBLR_K_FILL_MIN                   1
#define	MBLR_K_FILL_RANDOM                1
#define	MBLR_K_FILL_SEQUENTIAL            2
#define	MBLR_K_FILL_MAX                   2

/*
 *----------------------------------------------------------------------------- 
 * Item codes used for MBLR_K_EXTENSION 
 *----------------------------------------------------------------------------- 
 */
/* Options for MBLR_K_EXT_HASH_TYPE */
#define	MBLR_K_HASH_USER_DEFINED          0	/* A user defined external HASH function */
#define	MBLR_K_HASH_CRC                   1	/* Traditional CRC Hash Algorithm */
#define	MBLR_K_HASH_MODULO                2	/* Use the modulo of the first four bytes */

/* Options for MBLR_K_EXT_SORT_TYPE */
#define	MBLR_K_SORT_UNRANKED              0	/* Traditional Rdb Btree */
#define	MBLR_K_SORT_P_RANKED_BSTAR        1	/* Pseudo-ranked B*tree */
#define	MBLR_K_SORT_P_RANKED_BPLUS        2	/* Pseudo-ranked B+tree */
#define	MBLR_K_SORT_P_RANKED_HYBRID       3	/* Pseudo-ranked Hybrid tree */

/* Options for MBLR_K_EXT_MAINTENANCE */
#define	MBLR_K_MAINT_ENABLED              0	/* Re-enable maintenance if deferred */
#define	MBLR_K_MAINT_DISABLED             1	/* Disable index usage */
#define	MBLR_K_MAINT_DEFERRED             2	/* Defer updates, possibly using journal */

/* Options for MBLR_K_EXT_CARD_COLLECT */
#define	MBLR_K_COLLECT_DISABLED           0	/* No collection */
#define	MBLR_K_COLLECT_ENABLED            1	/* Collection enabled */
#define	MBLR_K_COLLECT_FULL               2	/* Full collection */

/* Options for MBLR_K_EXT_SQL_PARAM_STYLE */
#define	MBLR_K_PARAM_STYLE_GENERAL        0
#define	MBLR_K_PARAM_STYLE_SQL            1
#define	MBLR_K_PARAM_STYLE_JAVA           2

/*
 *------------------------------------------------------------------------ 
 * Tag values for MBLR_K_PARTITION 
 *------------------------------------------------------------------------ 
 */
#define	RDB_K_PART_UPDATE_STATIC          0
#define	RDB_K_PART_UPDATE_DYNAMIC         1
#define	RDB_K_PART_NOUPDATE               2






#ifdef VMS
#define RDB$K_MAX_SYNONYM_CHAIN          RDB_K_MAX_SYNONYM_CHAIN
#define RDB$K_MESSAGE_VECTOR_SIZE        RDB_K_MESSAGE_VECTOR_SIZE
#define RDB$K_SYSFLG_USER                RDB_K_SYSFLG_USER
#define RDB$K_SYSFLG_SYSTEM              RDB_K_SYSFLG_SYSTEM
#define RDB$K_SYSFLG_LAYERED             RDB_K_SYSFLG_LAYERED
#define RDB$K_DB_TYPE_UNKNOWN            RDB_K_DB_TYPE_UNKNOWN
#define RDB$K_DB_TYPE_MIN                RDB_K_DB_TYPE_MIN
#define RDB$K_DB_TYPE_VMS                RDB_K_DB_TYPE_VMS
#define RDB$K_DB_TYPE_DECRDB             RDB_K_DB_TYPE_DECRDB
#define RDB$K_DB_TYPE_RDB                RDB_K_DB_TYPE_RDB
#define RDB$K_DB_TYPE_ELAN               RDB_K_DB_TYPE_ELAN
#define RDB$K_DB_TYPE_VIDA               RDB_K_DB_TYPE_VIDA
#define RDB$K_DB_TYPE_VIDA2              RDB_K_DB_TYPE_VIDA2
#define RDB$K_DB_TYPE_VIDAO              RDB_K_DB_TYPE_VIDAO
#define RDB$K_DB_TYPE_NSDS               RDB_K_DB_TYPE_NSDS
#define RDB$K_DB_TYPE_DAF                RDB_K_DB_TYPE_DAF
#define RDB$K_DB_TYPE_BRIDGE             RDB_K_DB_TYPE_BRIDGE
#define RDB$K_DB_TYPE_DBI                RDB_K_DB_TYPE_DBI
#define RDB$K_DB_TYPE_EDASQL             RDB_K_DB_TYPE_EDASQL
#define RDB$K_DB_TYPE_SQL400             RDB_K_DB_TYPE_SQL400
#define RDB$K_DB_TYPE_SQLACC             RDB_K_DB_TYPE_SQLACC
#define RDB$K_DB_TYPE_SYBASE             RDB_K_DB_TYPE_SYBASE
#define RDB$K_DB_TYPE_ORACLE             RDB_K_DB_TYPE_ORACLE
#define RDB$K_DB_TYPE_DB2                RDB_K_DB_TYPE_DB2
#define RDB$K_DB_TYPE_SQLNK              RDB_K_DB_TYPE_SQLNK
#define RDB$K_DB_TYPE_ODBC               RDB_K_DB_TYPE_ODBC
#define RDB$K_DB_TYPE_NREL               RDB_K_DB_TYPE_NREL
#define RDB$K_DB_TYPE_MAX                RDB_K_DB_TYPE_MAX
#define RDB$K_FACILITY_ALL               RDB_K_FACILITY_ALL
#define RDB$K_FACILITY_RDB_VMS           RDB_K_FACILITY_RDB_VMS
#define RDB$K_FACILITY_DECRDB            RDB_K_FACILITY_DECRDB
#define RDB$K_FACILITY_RDB               RDB_K_FACILITY_RDB
#define RDB$K_FACILITY_RDB_ELN           RDB_K_FACILITY_RDB_ELN
#define RDB$K_FACILITY_VIDA              RDB_K_FACILITY_VIDA
#define RDB$K_FACILITY_VIDA2             RDB_K_FACILITY_VIDA2
#define RDB$K_FACILITY_VIDAO             RDB_K_FACILITY_VIDAO
#define RDB$K_FACILITY_NSDS              RDB_K_FACILITY_NSDS
#define RDB$K_FACILITY_DAF               RDB_K_FACILITY_DAF
#define RDB$K_FACILITY_BRIDGE            RDB_K_FACILITY_BRIDGE
#define RDB$K_FACILITY_DBI               RDB_K_FACILITY_DBI
#define RDB$K_FACILITY_EDASQL            RDB_K_FACILITY_EDASQL
#define RDB$K_FACILITY_SQL400            RDB_K_FACILITY_SQL400
#define RDB$K_FACILITY_SQLACC            RDB_K_FACILITY_SQLACC
#define RDB$K_FACILITY_SYBASE            RDB_K_FACILITY_SYBASE
#define RDB$K_FACILITY_ORACLE            RDB_K_FACILITY_ORACLE
#define RDB$K_FACILITY_DB2               RDB_K_FACILITY_DB2
#define RDB$K_FACILITY_SQLNK             RDB_K_FACILITY_SQLNK
#define RDB$K_FACILITY_ODBC              RDB_K_FACILITY_ODBC
#define RDB$K_FACILITY_NREL              RDB_K_FACILITY_NREL
#define RDB$K_SECURE_VERSION1            RDB_K_SECURE_VERSION1
#define RDB$K_SECURE_VERSION2            RDB_K_SECURE_VERSION2
#define RDB$K_SECURE_FAC_UNKNOWN         RDB_K_SECURE_FAC_UNKNOWN
#define RDB$K_SECURE_FAC_VMS             RDB_K_SECURE_FAC_VMS
#define RDB$K_SECURE_FAC_DECRDB          RDB_K_SECURE_FAC_DECRDB
#define RDB$K_SECURE_FAC_RDB             RDB_K_SECURE_FAC_RDB
#define RDB$K_SECURE_FAC_ELN             RDB_K_SECURE_FAC_ELN
#define RDB$K_SECURE_FAC_REMOTE          RDB_K_SECURE_FAC_REMOTE
#define RDB$K_SECURE_FAC_VIDA            RDB_K_SECURE_FAC_VIDA
#define RDB$K_SECURE_FAC_VIDA2           RDB_K_SECURE_FAC_VIDA2
#define RDB$K_SECURE_FAC_VIDAO           RDB_K_SECURE_FAC_VIDAO
#define RDB$K_SECURE_FAC_NSDS            RDB_K_SECURE_FAC_NSDS
#define RDB$K_SECURE_FAC_DAF             RDB_K_SECURE_FAC_DAF
#define RDB$K_SECURE_FAC_BRIDGE          RDB_K_SECURE_FAC_BRIDGE
#define RDB$K_SECURE_FAC_DBI             RDB_K_SECURE_FAC_DBI
#define RDB$K_SECURE_FAC_EDASQL          RDB_K_SECURE_FAC_EDASQL
#define RDB$K_SECURE_FAC_SQL400          RDB_K_SECURE_FAC_SQL400
#define RDB$K_SECURE_FAC_SQLACC          RDB_K_SECURE_FAC_SQLACC
#define RDB$K_SECURE_FAC_SYBASE          RDB_K_SECURE_FAC_SYBASE
#define RDB$K_SECURE_FAC_ORACLE          RDB_K_SECURE_FAC_ORACLE
#define RDB$K_SECURE_FAC_DB2             RDB_K_SECURE_FAC_DB2
#define RDB$K_SECURE_FAC_SQLNK           RDB_K_SECURE_FAC_SQLNK
#define RDB$K_SECURE_FAC_ODBC            RDB_K_SECURE_FAC_ODBC
#define RDB$K_SECURE_FAC_NREL            RDB_K_SECURE_FAC_NREL
#define RDB$K_SECURE_MIN                 RDB_K_SECURE_MIN
#define RDB$K_SECURE_USER_NAME           RDB_K_SECURE_USER_NAME
#define RDB$K_SECURE_USER_PWD            RDB_K_SECURE_USER_PWD
#define RDB$K_SECURE_CONNECTION_NAME     RDB_K_SECURE_CONNECTION_NAME
#define RDB$K_SECURE_CANCEL_CONNECTION   RDB_K_SECURE_CANCEL_CONNECTION
#define RDB$K_SECURE_OVERRIDE_PRIVS      RDB_K_SECURE_OVERRIDE_PRIVS
#define RDB$K_SECURE_REFRESH_UIC         RDB_K_SECURE_REFRESH_UIC
#define RDB$K_SECURE_MAX                 RDB_K_SECURE_MAX
#define RDB$K_HANDLE_MIN                 RDB_K_HANDLE_MIN
#define RDB$K_HANDLE_DATABASE            RDB_K_HANDLE_DATABASE
#define RDB$K_HANDLE_TRANSACTION         RDB_K_HANDLE_TRANSACTION
#define RDB$K_HANDLE_REQUEST             RDB_K_HANDLE_REQUEST
#define RDB$K_HANDLE_SEGMENTED_STRING    RDB_K_HANDLE_SEGMENTED_STRING
#define RDB$K_HANDLE_MARKPOINT           RDB_K_HANDLE_MARKPOINT
#define RDB$K_HANDLE_NOTREQUIRED         RDB_K_HANDLE_NOTREQUIRED
#define RDB$K_HANDLE_MAX                 RDB_K_HANDLE_MAX
#define RDB$K_PLTFRM_MIN                 RDB_K_PLTFRM_MIN
#define RDB$K_PLTFRM_VMS                 RDB_K_PLTFRM_VMS
#define RDB$K_PLTFRM_UNIX                RDB_K_PLTFRM_UNIX
#define RDB$K_PLTFRM_WNT                 RDB_K_PLTFRM_WNT
#define RDB$K_PLTFRM_MAX                 RDB_K_PLTFRM_MAX
#define RDB$K_CALLBACK_MIN               RDB_K_CALLBACK_MIN
#define RDB$K_CALLBACK_UNKNOWN           RDB_K_CALLBACK_UNKNOWN
#define RDB$K_CALLBACK_COMMITTED         RDB_K_CALLBACK_COMMITTED
#define RDB$K_CALLBACK_ROLLEDBACK        RDB_K_CALLBACK_ROLLEDBACK
#define RDB$K_CALLBACK_FAILED            RDB_K_CALLBACK_FAILED
#define RDB$K_CALLBACK_MAX               RDB_K_CALLBACK_MAX
#define RDB$K_PROFILE_MIN                RDB_K_PROFILE_MIN
#define RDB$K_PROFILE_QUOTAS             RDB_K_PROFILE_QUOTAS
#define RDB$K_PROFILE_ROLES              RDB_K_PROFILE_ROLES
#define RDB$K_PROFILE_DEFAULT_ROLES      RDB_K_PROFILE_DEFAULT_ROLES
#define RDB$K_PROFILE_USERS              RDB_K_PROFILE_USERS
#define RDB$K_PROFILE_UNKNOWN            RDB_K_PROFILE_UNKNOWN
#define RDB$K_PROFILE_MAX                RDB_K_PROFILE_MAX
#define RDB$K_PRF_DB_CREATOR_ID          RDB_K_PRF_DB_CREATOR_ID
#define RDB$K_PRF_DEFAULT_ID             RDB_K_PRF_DEFAULT_ID
#define RDB$K_PRF_PUBLIC_ID              RDB_K_PRF_PUBLIC_ID
#define RDB$K_PRF_BATCH_ID               RDB_K_PRF_BATCH_ID
#define RDB$K_PRF_DIALUP_ID              RDB_K_PRF_DIALUP_ID
#define RDB$K_PRF_INTERACTIVE_ID         RDB_K_PRF_INTERACTIVE_ID
#define RDB$K_PRF_LOCAL_ID               RDB_K_PRF_LOCAL_ID
#define RDB$K_PRF_NETWORK_ID             RDB_K_PRF_NETWORK_ID
#define RDB$K_PRF_REMOTE_ID              RDB_K_PRF_REMOTE_ID
#define RDB$K_PRF_ALL                    RDB_K_PRF_ALL
#define RDB$K_PRF_ANY_CATALOG            RDB_K_PRF_ANY_CATALOG
#define RDB$K_PRF_ANY_COLLATION          RDB_K_PRF_ANY_COLLATION
#define RDB$K_PRF_ANY_FIELD              RDB_K_PRF_ANY_FIELD
#define RDB$K_PRF_ANY_FUNCTION           RDB_K_PRF_ANY_FUNCTION
#define RDB$K_PRF_ANY_INDEX              RDB_K_PRF_ANY_INDEX
#define RDB$K_PRF_ANY_MODULE             RDB_K_PRF_ANY_MODULE
#define RDB$K_PRF_ANY_OUTLINE            RDB_K_PRF_ANY_OUTLINE
#define RDB$K_PRF_ANY_PROCEDURE          RDB_K_PRF_ANY_PROCEDURE
#define RDB$K_PRF_ANY_PROFILE            RDB_K_PRF_ANY_PROFILE
#define RDB$K_PRF_ANY_RELATION           RDB_K_PRF_ANY_RELATION
#define RDB$K_PRF_ANY_REF_ROLE           RDB_K_PRF_ANY_REF_ROLE
#define RDB$K_PRF_ANY_REF_SYSPRIV        RDB_K_PRF_ANY_REF_SYSPRIV
#define RDB$K_PRF_ANY_ROLE               RDB_K_PRF_ANY_ROLE
#define RDB$K_PRF_ANY_SCHEMA             RDB_K_PRF_ANY_SCHEMA
#define RDB$K_PRF_ANY_SEQUENCE           RDB_K_PRF_ANY_SEQUENCE
#define RDB$K_PRF_ANY_STOMAP             RDB_K_PRF_ANY_STOMAP
#define RDB$K_PRF_ANY_SYNONYM            RDB_K_PRF_ANY_SYNONYM
#define RDB$K_PRF_ANY_TRIGGER            RDB_K_PRF_ANY_TRIGGER
#define RDB$K_PRF_ANY_TYPE               RDB_K_PRF_ANY_TYPE
#define RDB$K_PRF_ANY_USER               RDB_K_PRF_ANY_USER
#define RDB$K_PRF_ANY_VIEW               RDB_K_PRF_ANY_VIEW
#define RDB$K_PRF_ANY_TEMP_TABLE         RDB_K_PRF_ANY_TEMP_TABLE
#define RDB$M_PRF_ALL                    RDB_M_PRF_ALL
#define RDB$M_PRF_ANY_CATALOG            RDB_M_PRF_ANY_CATALOG
#define RDB$M_PRF_ANY_COLLATION          RDB_M_PRF_ANY_COLLATION
#define RDB$M_PRF_ANY_FIELD              RDB_M_PRF_ANY_FIELD
#define RDB$M_PRF_ANY_FUNCTION           RDB_M_PRF_ANY_FUNCTION
#define RDB$M_PRF_ANY_INDEX              RDB_M_PRF_ANY_INDEX
#define RDB$M_PRF_ANY_MODULE             RDB_M_PRF_ANY_MODULE
#define RDB$M_PRF_ANY_OUTLINE            RDB_M_PRF_ANY_OUTLINE
#define RDB$M_PRF_ANY_PROCEDURE          RDB_M_PRF_ANY_PROCEDURE
#define RDB$M_PRF_ANY_PROFILE            RDB_M_PRF_ANY_PROFILE
#define RDB$M_PRF_ANY_RELATION           RDB_M_PRF_ANY_RELATION
#define RDB$M_PRF_ANY_REF_ROLE           RDB_M_PRF_ANY_REF_ROLE
#define RDB$M_PRF_ANY_REF_SYSPRIV        RDB_M_PRF_ANY_REF_SYSPRIV
#define RDB$M_PRF_ANY_ROLE               RDB_M_PRF_ANY_ROLE
#define RDB$M_PRF_ANY_SCHEMA             RDB_M_PRF_ANY_SCHEMA
#define RDB$M_PRF_ANY_SEQUENCE           RDB_M_PRF_ANY_SEQUENCE
#define RDB$M_PRF_ANY_STOMAP             RDB_M_PRF_ANY_STOMAP
#define RDB$M_PRF_ANY_SYNONYM            RDB_M_PRF_ANY_SYNONYM
#define RDB$M_PRF_ANY_TRIGGER            RDB_M_PRF_ANY_TRIGGER
#define RDB$M_PRF_ANY_TYPE               RDB_M_PRF_ANY_TYPE
#define RDB$M_PRF_ANY_USER               RDB_M_PRF_ANY_USER
#define RDB$M_PRF_ANY_VIEW               RDB_M_PRF_ANY_VIEW
#define RDB$M_PRF_ANY_TEMP_TABLE         RDB_M_PRF_ANY_TEMP_TABLE
#define RDB$K_LEVEL_ORALVL_2             RDB_K_LEVEL_ORALVL_2
#define RDB$K_LEVEL_ORALVL_1             RDB_K_LEVEL_ORALVL_1
#define RDB$K_LEVEL_NONE                 RDB_K_LEVEL_NONE
#define RDB$K_LEVEL_SQL92_ENTRY          RDB_K_LEVEL_SQL92_ENTRY
#define RDB$K_LEVEL_SQL92_TRANS          RDB_K_LEVEL_SQL92_TRANS
#define RDB$K_LEVEL_SQL92_INT            RDB_K_LEVEL_SQL92_INT
#define RDB$K_LEVEL_SQL92_FULL           RDB_K_LEVEL_SQL92_FULL
#define RDB$K_LEVEL_SQL99                RDB_K_LEVEL_SQL99
#define RDB$K_LEVEL_SQL3                 RDB_K_LEVEL_SQL3
#define RDB$K_CHANGE_DISABLE             RDB_K_CHANGE_DISABLE
#define RDB$K_CHANGE_ENABLE              RDB_K_CHANGE_ENABLE
#define RDB$K_CHANGE_ENABLE_NOCHECK      RDB_K_CHANGE_ENABLE_NOCHECK
#define RDB$K_PART_MODE_DEFINE           RDB_K_PART_MODE_DEFINE
#define RDB$K_PART_MODE_MIN              RDB_K_PART_MODE_MIN
#define RDB$K_PART_MODE_DELETE           RDB_K_PART_MODE_DELETE
#define RDB$K_PART_MODE_MOVE             RDB_K_PART_MODE_MOVE
#define RDB$K_PART_MODE_COMMENT          RDB_K_PART_MODE_COMMENT
#define RDB$K_PART_MODE_RENAME           RDB_K_PART_MODE_RENAME
#define RDB$K_PART_MODE_ERASE            RDB_K_PART_MODE_ERASE
#define RDB$K_PART_MODE_BUILD            RDB_K_PART_MODE_BUILD
#define RDB$K_PART_MODE_REBUILD          RDB_K_PART_MODE_REBUILD
#define RDB$K_PART_MODE_TRUNCATE         RDB_K_PART_MODE_TRUNCATE
#define RDB$K_PART_MODE_MAX              RDB_K_PART_MODE_MAX
#define RDB$K_AUTOMATIC_NEVER            RDB_K_AUTOMATIC_NEVER
#define RDB$K_AUTOMATIC_INSERT           RDB_K_AUTOMATIC_INSERT
#define RDB$K_AUTOMATIC_UPDATE           RDB_K_AUTOMATIC_UPDATE
#define RDB$K_AUTOMATIC_ALWAYS           RDB_K_AUTOMATIC_ALWAYS
#define RDB$K_VLIST_DATA_SET             RDB_K_VLIST_DATA_SET
#define RDB$K_VLIST_LEAST                RDB_K_VLIST_LEAST
#define RDB$K_VLIST_GREATEST             RDB_K_VLIST_GREATEST
#define RDB$K_VLIST_LEAST_ORA            RDB_K_VLIST_LEAST_ORA
#define RDB$K_VLIST_GREATEST_ORA         RDB_K_VLIST_GREATEST_ORA
#define RDB$K_VLIST_ROUND_NUMERIC        RDB_K_VLIST_ROUND_NUMERIC
#define RDB$K_VLIST_ROUND_ADT            RDB_K_VLIST_ROUND_ADT
#define RDB$K_VLIST_TRUNC_NUMERIC        RDB_K_VLIST_TRUNC_NUMERIC
#define RDB$K_VLIST_TRUNC_ADT            RDB_K_VLIST_TRUNC_ADT
#define RDB$K_VLIST_CONCAT               RDB_K_VLIST_CONCAT
#define RDB$K_VLIST_CONCAT_ORA           RDB_K_VLIST_CONCAT_ORA
#define RDB$K_VLIST_BIN_TO_NUM           RDB_K_VLIST_BIN_TO_NUM
#define RDB$K_VLIST_CONCAT_WS            RDB_K_VLIST_CONCAT_WS
#define RDB$K_VLIST_CONCAT_WS_ORA        RDB_K_VLIST_CONCAT_WS_ORA
#define RDB$K_DPB_VERSION1               RDB_K_DPB_VERSION1
#define RDB$K_DPB_VERSION2               RDB_K_DPB_VERSION2
#define RDB$K_DPB_MIN                    RDB_K_DPB_MIN
#define RDB$K_DPB_CDD_PATHNAME           RDB_K_DPB_CDD_PATHNAME
#define RDB$K_DPB_ALLOCATION             RDB_K_DPB_ALLOCATION
#define RDB$K_DPB_AIJ                    RDB_K_DPB_AIJ
#define RDB$K_DPB_PAGE_SIZE              RDB_K_DPB_PAGE_SIZE
#define RDB$K_DPB_NUM_BUFF               RDB_K_DPB_NUM_BUFF
#define RDB$K_DPB_BUFFER_LENGTH          RDB_K_DPB_BUFFER_LENGTH
#define RDB$K_DPB_DEBUG                  RDB_K_DPB_DEBUG
#define RDB$K_DPB_GARBAGE_COLLECT        RDB_K_DPB_GARBAGE_COLLECT
#define RDB$K_DPB_VERIFY                 RDB_K_DPB_VERIFY
#define RDB$K_DPB_SWEEP                  RDB_K_DPB_SWEEP
#define RDB$K_DPB_ENABLE_JOURNAL         RDB_K_DPB_ENABLE_JOURNAL
#define RDB$K_DPB_DISABLE_JOURNAL        RDB_K_DPB_DISABLE_JOURNAL
#define RDB$K_DPB_DBKEY_SCOPE            RDB_K_DPB_DBKEY_SCOPE
#define RDB$K_DPB_NUM_USERS              RDB_K_DPB_NUM_USERS
#define RDB$K_DPB_DB_EXTENT              RDB_K_DPB_DB_EXTENT
#define RDB$K_DPB_EXT_DB_MIN_NUM_PAGES   RDB_K_DPB_EXT_DB_MIN_NUM_PAGES
#define RDB$K_DPB_EXT_DB_MAX_NUM_PAGES   RDB_K_DPB_EXT_DB_MAX_NUM_PAGES
#define RDB$K_DPB_EXT_DB_PCT_GROWTH      RDB_K_DPB_EXT_DB_PCT_GROWTH
#define RDB$K_DPB_SNP_ALLOCATION         RDB_K_DPB_SNP_ALLOCATION
#define RDB$K_DPB_SNP_ENABLED            RDB_K_DPB_SNP_ENABLED
#define RDB$K_DPB_SNP_DISABLED           RDB_K_DPB_SNP_DISABLED
#define RDB$K_DPB_SNP_EXTENT             RDB_K_DPB_SNP_EXTENT
#define RDB$K_DPB_EXT_SNP_MIN_NUM_PAGES  RDB_K_DPB_EXT_SNP_MIN_NUM_PAGES
#define RDB$K_DPB_EXT_SNP_MAX_NUM_PAGES  RDB_K_DPB_EXT_SNP_MAX_NUM_PAGES
#define RDB$K_DPB_EXT_SNP_PCT_GROWTH     RDB_K_DPB_EXT_SNP_PCT_GROWTH
#define RDB$K_DPB_AIJ_CONTINUOUS         RDB_K_DPB_AIJ_CONTINUOUS
#define RDB$K_DPB_AIJ_ONCE               RDB_K_DPB_AIJ_ONCE
#define RDB$K_DPB_AIJ_SPOOL_FILE         RDB_K_DPB_AIJ_SPOOL_FILE
#define RDB$K_DPB_DESCRIPTION_SOURCE     RDB_K_DPB_DESCRIPTION_SOURCE
#define RDB$K_DPB_CONVERT                RDB_K_DPB_CONVERT
#define RDB$K_DPB_SNAPSHOT               RDB_K_DPB_SNAPSHOT
#define RDB$K_DPB_OPEN_MANUAL            RDB_K_DPB_OPEN_MANUAL
#define RDB$K_DPB_OPEN_AUTOMATIC         RDB_K_DPB_OPEN_AUTOMATIC
#define RDB$K_DPB_DEFINE_STORAGE         RDB_K_DPB_DEFINE_STORAGE
#define RDB$K_DPB_CHANGE_STORAGE         RDB_K_DPB_CHANGE_STORAGE
#define RDB$K_DPB_STORAGE_NAME           RDB_K_DPB_STORAGE_NAME
#define RDB$K_DPB_FILESPEC               RDB_K_DPB_FILESPEC
#define RDB$K_DPB_EXTENSIBLE             RDB_K_DPB_EXTENSIBLE
#define RDB$K_DPB_SNP_DEFERRED           RDB_K_DPB_SNP_DEFERRED
#define RDB$K_DPB_NUM_NODES              RDB_K_DPB_NUM_NODES
#define RDB$K_DPB_FILE_TYPE              RDB_K_DPB_FILE_TYPE
#define RDB$K_DPB_CDD_MAINTAINED         RDB_K_DPB_CDD_MAINTAINED
#define RDB$K_DPB_CDD_REQUIRED           RDB_K_DPB_CDD_REQUIRED
#define RDB$K_DPB_SEGMENT_AREA           RDB_K_DPB_SEGMENT_AREA
#define RDB$K_DPB_SPAMS                  RDB_K_DPB_SPAMS
#define RDB$K_DPB_SPAM_THRESHOLD_1       RDB_K_DPB_SPAM_THRESHOLD_1
#define RDB$K_DPB_SPAM_THRESHOLD_2       RDB_K_DPB_SPAM_THRESHOLD_2
#define RDB$K_DPB_SPAM_THRESHOLD_3       RDB_K_DPB_SPAM_THRESHOLD_3
#define RDB$K_DPB_SPAM_INTERVAL          RDB_K_DPB_SPAM_INTERVAL
#define RDB$K_DPB_AIJ_ALLOCATION         RDB_K_DPB_AIJ_ALLOCATION
#define RDB$K_DPB_AIJ_EXTENT             RDB_K_DPB_AIJ_EXTENT
#define RDB$K_DPB_DBR_BUFFERS            RDB_K_DPB_DBR_BUFFERS
#define RDB$K_DPB_END_STORAGE_AREA       RDB_K_DPB_END_STORAGE_AREA
#define RDB$K_DPB_MAX                    RDB_K_DPB_MAX
#define RDB$K_DPB_DBKEY_SCOPE_TRANS      RDB_K_DPB_DBKEY_SCOPE_TRANS
#define RDB$K_DPB_DBKEY_SCOPE_ATTACH     RDB_K_DPB_DBKEY_SCOPE_ATTACH
#define RDB$K_DPB_SNP_DEFERRED_NO        RDB_K_DPB_SNP_DEFERRED_NO
#define RDB$K_DPB_SNP_DEFERRED_YES       RDB_K_DPB_SNP_DEFERRED_YES
#define RDB$K_DPB_EXT_DICT_IGNORED       RDB_K_DPB_EXT_DICT_IGNORED
#define RDB$K_DPB_EXT_DICT_REQUIRED      RDB_K_DPB_EXT_DICT_REQUIRED
#define RDB$K_DPB_CLI_DICT_IGNORED       RDB_K_DPB_CLI_DICT_IGNORED
#define RDB$K_DPB_CLI_DICT_MAINTAINED    RDB_K_DPB_CLI_DICT_MAINTAINED
#define RDB$K_DPB_CLI_DICT_UNLINK        RDB_K_DPB_CLI_DICT_UNLINK
#define RDB$K_DPB_DICT_DATABASE_NO       RDB_K_DPB_DICT_DATABASE_NO
#define RDB$K_DPB_DICT_DATABASE_YES      RDB_K_DPB_DICT_DATABASE_YES
#define RDB$K_DPB_MULTISCHEMA_NO         RDB_K_DPB_MULTISCHEMA_NO
#define RDB$K_DPB_MULTISCHEMA_YES        RDB_K_DPB_MULTISCHEMA_YES
#define RDB$K_DPB_GB_OFF                 RDB_K_DPB_GB_OFF
#define RDB$K_DPB_GB_ON                  RDB_K_DPB_GB_ON
#define RDB$K_DPB_CHKPNT_OFF             RDB_K_DPB_CHKPNT_OFF
#define RDB$K_DPB_CHKPNT_ON              RDB_K_DPB_CHKPNT_ON
#define RDB$K_DPB_FT_PARTITIONED         RDB_K_DPB_FT_PARTITIONED
#define RDB$K_DPB_FT_CLUSTERED           RDB_K_DPB_FT_CLUSTERED
#define RDB$K_DPB_PROT_DEFAULT           RDB_K_DPB_PROT_DEFAULT
#define RDB$K_DPB_PROT_ANSI_COMPLIANT    RDB_K_DPB_PROT_ANSI_COMPLIANT
#define RDB$M_DPB_SWP_PAGES              RDB_M_DPB_SWP_PAGES
#define RDB$M_DPB_SWP_RECORDS            RDB_M_DPB_SWP_RECORDS
#define RDB$M_DPB_SWP_INDICES            RDB_M_DPB_SWP_INDICES
#define RDB$M_DPB_SWP_TRANSACTIONS       RDB_M_DPB_SWP_TRANSACTIONS
#define RDB$K_DPB2_MIN                   RDB_K_DPB2_MIN
#define RDB$K_DPB2_DBKEY_SCOPE           RDB_K_DPB2_DBKEY_SCOPE
#define RDB$K_DPB2_AIJ                   RDB_K_DPB2_AIJ
#define RDB$K_DPB2_ALLOCATION            RDB_K_DPB2_ALLOCATION
#define RDB$K_DPB2_PAGE_SIZE             RDB_K_DPB2_PAGE_SIZE
#define RDB$K_DPB2_NUM_BUFF              RDB_K_DPB2_NUM_BUFF
#define RDB$K_DPB2_BUFFER_LENGTH         RDB_K_DPB2_BUFFER_LENGTH
#define RDB$K_DPB2_NUM_USERS             RDB_K_DPB2_NUM_USERS
#define RDB$K_DPB2_EXT_DB_MIN_NUM_PAGES  RDB_K_DPB2_EXT_DB_MIN_NUM_PAGES
#define RDB$K_DPB2_EXT_DB_MAX_NUM_PAGES  RDB_K_DPB2_EXT_DB_MAX_NUM_PAGES
#define RDB$K_DPB2_EXT_DB_PCT_GROWTH     RDB_K_DPB2_EXT_DB_PCT_GROWTH
#define RDB$K_DPB2_SNP_ALLOCATION        RDB_K_DPB2_SNP_ALLOCATION
#define RDB$K_DPB2_SNP_FLAG              RDB_K_DPB2_SNP_FLAG
#define RDB$K_DPB2_EXT_SNP_MIN_NUMPAGES  RDB_K_DPB2_EXT_SNP_MIN_NUMPAGES
#define RDB$K_DPB2_EXT_SNP_MAX_NUMPAGES  RDB_K_DPB2_EXT_SNP_MAX_NUMPAGES
#define RDB$K_DPB2_EXT_SNP_PCT_GROWTH    RDB_K_DPB2_EXT_SNP_PCT_GROWTH
#define RDB$K_DPB2_DB_EXTENT             RDB_K_DPB2_DB_EXTENT
#define RDB$K_DPB2_CDD_PATHNAME          RDB_K_DPB2_CDD_PATHNAME
#define RDB$K_DPB2_AIJ_ALLOCATION        RDB_K_DPB2_AIJ_ALLOCATION
#define RDB$K_DPB2_AIJ_EXTENT            RDB_K_DPB2_AIJ_EXTENT
#define RDB$K_DPB2_DBR_BUFFERS           RDB_K_DPB2_DBR_BUFFERS
#define RDB$K_DPB2_SNP_ENABLED           RDB_K_DPB2_SNP_ENABLED
#define RDB$K_DPB2_SNP_DISABLED          RDB_K_DPB2_SNP_DISABLED
#define RDB$K_DPB2_SNP_EXTENT            RDB_K_DPB2_SNP_EXTENT
#define RDB$K_DPB2_SPAM_THRESHOLD_1      RDB_K_DPB2_SPAM_THRESHOLD_1
#define RDB$K_DPB2_SPAM_THRESHOLD_2      RDB_K_DPB2_SPAM_THRESHOLD_2
#define RDB$K_DPB2_SPAM_THRESHOLD_3      RDB_K_DPB2_SPAM_THRESHOLD_3
#define RDB$K_DPB2_AIJ_CONTINUOUS        RDB_K_DPB2_AIJ_CONTINUOUS
#define RDB$K_DPB2_AIJ_ONCE              RDB_K_DPB2_AIJ_ONCE
#define RDB$K_DPB2_AIJ_SPOOL_FILE        RDB_K_DPB2_AIJ_SPOOL_FILE
#define RDB$K_DPB2_DESCRIPTION_SOURCE    RDB_K_DPB2_DESCRIPTION_SOURCE
#define RDB$K_DPB2_CONVERT               RDB_K_DPB2_CONVERT
#define RDB$K_DPB2_SNAPSHOT              RDB_K_DPB2_SNAPSHOT
#define RDB$K_DPB2_OPEN_MANUAL           RDB_K_DPB2_OPEN_MANUAL
#define RDB$K_DPB2_OPEN_AUTOMATIC        RDB_K_DPB2_OPEN_AUTOMATIC
#define RDB$K_DPB2_DEFINE_STORAGE        RDB_K_DPB2_DEFINE_STORAGE
#define RDB$K_DPB2_CHANGE_STORAGE        RDB_K_DPB2_CHANGE_STORAGE
#define RDB$K_DPB2_STORAGE_NAME          RDB_K_DPB2_STORAGE_NAME
#define RDB$K_DPB2_FILESPEC              RDB_K_DPB2_FILESPEC
#define RDB$K_DPB2_EXTENSIBLE            RDB_K_DPB2_EXTENSIBLE
#define RDB$K_DPB2_SNP_DEFERRED          RDB_K_DPB2_SNP_DEFERRED
#define RDB$K_DPB2_NUM_NODES             RDB_K_DPB2_NUM_NODES
#define RDB$K_DPB2_FILE_TYPE             RDB_K_DPB2_FILE_TYPE
#define RDB$K_DPB2_CDD_MAINTAINED        RDB_K_DPB2_CDD_MAINTAINED
#define RDB$K_DPB2_CDD_REQUIRED          RDB_K_DPB2_CDD_REQUIRED
#define RDB$K_DPB2_SEGMENT_AREA          RDB_K_DPB2_SEGMENT_AREA
#define RDB$K_DPB2_SPAMS                 RDB_K_DPB2_SPAMS
#define RDB$K_DPB2_SPAM_INTERVAL         RDB_K_DPB2_SPAM_INTERVAL
#define RDB$K_DPB2_END_STORAGE_AREA      RDB_K_DPB2_END_STORAGE_AREA
#define RDB$K_DPB2_ALG                   RDB_K_DPB2_ALG
#define RDB$K_DPB2_DELETE_STORAGE        RDB_K_DPB2_DELETE_STORAGE
#define RDB$K_DPB2_LAYERED_ACCESS        RDB_K_DPB2_LAYERED_ACCESS
#define RDB$K_DPB2_REQUEST_SCOPE         RDB_K_DPB2_REQUEST_SCOPE
#define RDB$K_DPB2_READ_ONLY             RDB_K_DPB2_READ_ONLY
#define RDB$K_DPB2_PROTECTION            RDB_K_DPB2_PROTECTION
#define RDB$K_DPB2_COLLATION_SEQUENCE    RDB_K_DPB2_COLLATION_SEQUENCE
#define RDB$K_DPB2_DDTM_NOTINVOLVED      RDB_K_DPB2_DDTM_NOTINVOLVED
#define RDB$K_DPB2_FROM_JSV              RDB_K_DPB2_FROM_JSV
#define RDB$K_DPB2_CDD_DICTIONARY        RDB_K_DPB2_CDD_DICTIONARY
#define RDB$K_DPB2_CHECK_ACCESS          RDB_K_DPB2_CHECK_ACCESS
#define RDB$K_DPB2_KEEP_INTEGRITY        RDB_K_DPB2_KEEP_INTEGRITY
#define RDB$K_DPB2_META_LEVEL            RDB_K_DPB2_META_LEVEL
#define RDB$K_DPB2_WORM                  RDB_K_DPB2_WORM
#define RDB$K_DPB2_MULTISCHEMA           RDB_K_DPB2_MULTISCHEMA
#define RDB$K_DPB2_IMAGE_NAME            RDB_K_DPB2_IMAGE_NAME
#define RDB$K_DPB2_GB_ENABLED            RDB_K_DPB2_GB_ENABLED
#define RDB$K_DPB2_GB_NUM_BUFF           RDB_K_DPB2_GB_NUM_BUFF
#define RDB$K_DPB2_GB_NUM_PER_USER       RDB_K_DPB2_GB_NUM_PER_USER
#define RDB$K_DPB2_FC_CHKPT_INTERVAL     RDB_K_DPB2_FC_CHKPT_INTERVAL
#define RDB$K_DPB2_FC_CHKPT_ENABLED      RDB_K_DPB2_FC_CHKPT_ENABLED
#define RDB$K_DPB2_FC_CHKPT_TIME         RDB_K_DPB2_FC_CHKPT_TIME
#define RDB$K_DPB2_CARRY_OVER            RDB_K_DPB2_CARRY_OVER
#define RDB$K_DPB2_LOCK_TIMEOUT          RDB_K_DPB2_LOCK_TIMEOUT
#define RDB$K_DPB2_FC_COMMIT_TO_JOURNAL  RDB_K_DPB2_FC_COMMIT_TO_JOURNAL
#define RDB$K_DPB2_FC_TRANS_INTERVAL     RDB_K_DPB2_FC_TRANS_INTERVAL
#define RDB$K_DPB2_DEF_CSET_ID           RDB_K_DPB2_DEF_CSET_ID
#define RDB$K_DPB2_NAT_CSET_ID           RDB_K_DPB2_NAT_CSET_ID
#define RDB$K_DPB2_ROOT_FILE_ACL_TYPE    RDB_K_DPB2_ROOT_FILE_ACL_TYPE
#define RDB$K_DPB2_ROOT_FILE_ACL         RDB_K_DPB2_ROOT_FILE_ACL
#define RDB$K_DPB2_DB_EXTENT_ENABLED     RDB_K_DPB2_DB_EXTENT_ENABLED
#define RDB$K_DPB2_NAM_CSET_ID           RDB_K_DPB2_NAM_CSET_ID
#define RDB$K_DPB2_MAC_POLICY            RDB_K_DPB2_MAC_POLICY
#define RDB$K_DPB2_PRESTART_TXN          RDB_K_DPB2_PRESTART_TXN
#define RDB$K_DPB2_AIJ_CACHE_FILE        RDB_K_DPB2_AIJ_CACHE_FILE
#define RDB$K_DPB2_AIJ_BCK_SERVER        RDB_K_DPB2_AIJ_BCK_SERVER
#define RDB$K_DPB2_AIJ_SUPERCEDE         RDB_K_DPB2_AIJ_SUPERCEDE
#define RDB$K_DPB2_AIJ_LOG_SERVER        RDB_K_DPB2_AIJ_LOG_SERVER
#define RDB$K_DPB2_JOURNAL_OVERWRITE     RDB_K_DPB2_JOURNAL_OVERWRITE
#define RDB$K_DPB2_DEFINE_JOURNAL        RDB_K_DPB2_DEFINE_JOURNAL
#define RDB$K_DPB2_CHANGE_JOURNAL        RDB_K_DPB2_CHANGE_JOURNAL
#define RDB$K_DPB2_JOURNAL_NAME          RDB_K_DPB2_JOURNAL_NAME
#define RDB$K_DPB2_DELETE_JOURNAL        RDB_K_DPB2_DELETE_JOURNAL
#define RDB$K_DPB2_JOURNAL_NOTIFY        RDB_K_DPB2_JOURNAL_NOTIFY
#define RDB$K_DPB2_USE_JOURNAL           RDB_K_DPB2_USE_JOURNAL
#define RDB$K_DPB2_END_JOURNAL           RDB_K_DPB2_END_JOURNAL
#define RDB$K_DPB2_RESERVE_JOURNAL       RDB_K_DPB2_RESERVE_JOURNAL
#define RDB$K_DPB2_RESERVE_STORAGE       RDB_K_DPB2_RESERVE_STORAGE
#define RDB$K_DPB2_RESTRICTED_ACCESS     RDB_K_DPB2_RESTRICTED_ACCESS
#define RDB$K_DPB2_STATISTICS            RDB_K_DPB2_STATISTICS
#define RDB$K_DPB2_IDX_COMPRESSION       RDB_K_DPB2_IDX_COMPRESSION
#define RDB$K_DPB2_AREA_LOCKING          RDB_K_DPB2_AREA_LOCKING
#define RDB$K_DPB2_TEMP_PROXY            RDB_K_DPB2_TEMP_PROXY
#define RDB$K_DPB2_DEFAULT_LINK          RDB_K_DPB2_DEFAULT_LINK
#define RDB$K_DPB2_SQL92_SEMANTICS       RDB_K_DPB2_SQL92_SEMANTICS
#define RDB$K_DPB2_GB_INHIB_FLAG         RDB_K_DPB2_GB_INHIB_FLAG
#define RDB$K_DPB2_ASYNCH_ENABLED        RDB_K_DPB2_ASYNCH_ENABLED
#define RDB$K_DPB2_NOTIFY_OP_CLASS       RDB_K_DPB2_NOTIFY_OP_CLASS
#define RDB$K_DPB2_SHUTDOWN_TIME         RDB_K_DPB2_SHUTDOWN_TIME
#define RDB$K_DPB2_ASYNCH_PREFETCH       RDB_K_DPB2_ASYNCH_PREFETCH
#define RDB$K_DPB2_ABW_CLEAN_BUFFERS     RDB_K_DPB2_ABW_CLEAN_BUFFERS
#define RDB$K_DPB2_ASYNCH_BATCHWRITE     RDB_K_DPB2_ASYNCH_BATCHWRITE
#define RDB$K_DPB2_APF_DEPTH             RDB_K_DPB2_APF_DEPTH
#define RDB$K_DPB2_PARTITIONED_LOCK      RDB_K_DPB2_PARTITIONED_LOCK
#define RDB$K_DPB2_GB_TRANSFER           RDB_K_DPB2_GB_TRANSFER
#define RDB$K_DPB2_INCR_BACKUP           RDB_K_DPB2_INCR_BACKUP
#define RDB$K_DPB2_ABW_MAX_BUFFERS       RDB_K_DPB2_ABW_MAX_BUFFERS
#define RDB$K_DPB2_AREA_ADD_MULTITHREAD  RDB_K_DPB2_AREA_ADD_MULTITHREAD
#define RDB$K_DPB2_DEFAULT_STORAGE       RDB_K_DPB2_DEFAULT_STORAGE
#define RDB$K_DPB2_DEFAULT_TEMPLATE      RDB_K_DPB2_DEFAULT_TEMPLATE
#define RDB$K_DPB2_D_ASYNCH_PREFETCH     RDB_K_DPB2_D_ASYNCH_PREFETCH
#define RDB$K_DPB2_DAPF_DEPTH            RDB_K_DPB2_DAPF_DEPTH
#define RDB$K_DPB2_DAPF_THRESHOLD        RDB_K_DPB2_DAPF_THRESHOLD
#define RDB$K_DPB2_USE_CACHE             RDB_K_DPB2_USE_CACHE
#define RDB$K_DPB2_DEFINE_CACHE          RDB_K_DPB2_DEFINE_CACHE
#define RDB$K_DPB2_CHANGE_CACHE          RDB_K_DPB2_CHANGE_CACHE
#define RDB$K_DPB2_DELETE_CACHE          RDB_K_DPB2_DELETE_CACHE
#define RDB$K_DPB2_CACHE_NAME            RDB_K_DPB2_CACHE_NAME
#define RDB$K_DPB2_RESERVE_CACHE         RDB_K_DPB2_RESERVE_CACHE
#define RDB$K_DPB2_WORKLOAD_ENABLED      RDB_K_DPB2_WORKLOAD_ENABLED
#define RDB$K_DPB2_FILESPEC_EDIT         RDB_K_DPB2_FILESPEC_EDIT
#define RDB$K_DPB2_END_CACHE             RDB_K_DPB2_END_CACHE
#define RDB$K_DPB2_CARD_UPDATE_ENABLED   RDB_K_DPB2_CARD_UPDATE_ENABLED
#define RDB$K_DPB2_DDL_ENABLED           RDB_K_DPB2_DDL_ENABLED
#define RDB$K_DPB2_RESERVE_TEMPLATE      RDB_K_DPB2_RESERVE_TEMPLATE
#define RDB$K_DPB2_DEFER_CARD_UPDATE     RDB_K_DPB2_DEFER_CARD_UPDATE
#define RDB$K_DPB2_DEFINE_TXN_MODES      RDB_K_DPB2_DEFINE_TXN_MODES
#define RDB$K_DPB2_CHANGE_TXN_MODES      RDB_K_DPB2_CHANGE_TXN_MODES
#define RDB$K_DPB2_INTERNAL_USE          RDB_K_DPB2_INTERNAL_USE
#define RDB$K_DPB2_MEMORY_MAPPING        RDB_K_DPB2_MEMORY_MAPPING
#define RDB$K_DPB2_CHECKSUM              RDB_K_DPB2_CHECKSUM
#define RDB$K_DPB2_SNP_CHECKSUM          RDB_K_DPB2_SNP_CHECKSUM
#define RDB$K_DPB2_CACHE_REPLACE         RDB_K_DPB2_CACHE_REPLACE
#define RDB$K_DPB2_RC_LOCATION           RDB_K_DPB2_RC_LOCATION
#define RDB$K_DPB2_RC_SWEEP_INTERVAL     RDB_K_DPB2_RC_SWEEP_INTERVAL
#define RDB$K_DPB2_RC_RESERVED_RECS      RDB_K_DPB2_RC_RESERVED_RECS
#define RDB$K_DPB2_RC_SWEEP_THRESHOLDS   RDB_K_DPB2_RC_SWEEP_THRESHOLDS
#define RDB$K_DPB2_RC_SWEEP_RECS         RDB_K_DPB2_RC_SWEEP_RECS
#define RDB$K_DPB2_RESERVE_SEQUENCES     RDB_K_DPB2_RESERVE_SEQUENCES
#define RDB$K_DPB2_RC_CHKPT_DEST         RDB_K_DPB2_RC_CHKPT_DEST
#define RDB$K_DPB2_RC_CHKPT_TIME         RDB_K_DPB2_RC_CHKPT_TIME
#define RDB$K_DPB2_SECURITY_POLICY       RDB_K_DPB2_SECURITY_POLICY
#define RDB$K_DPB2_BUFFER_TYPE           RDB_K_DPB2_BUFFER_TYPE
#define RDB$K_DPB2_DISPLAY_CSET_ID       RDB_K_DPB2_DISPLAY_CSET_ID
#define RDB$K_DPB2_SECURITY_CREATOR_ID   RDB_K_DPB2_SECURITY_CREATOR_ID
#define RDB$K_DPB2_OBJECT_SYNONYMS       RDB_K_DPB2_OBJECT_SYNONYMS
#define RDB$K_DPB2_LOGMINER              RDB_K_DPB2_LOGMINER
#define RDB$K_DPB2_NDX_PREFIX_CARD       RDB_K_DPB2_NDX_PREFIX_CARD
#define RDB$K_DPB2_NDX_TYPE              RDB_K_DPB2_NDX_TYPE
#define RDB$K_DPB2_GALAXY_SUPPORT        RDB_K_DPB2_GALAXY_SUPPORT
#define RDB$K_DPB2_SHARED_INSTANCE       RDB_K_DPB2_SHARED_INSTANCE
#define RDB$K_DPB2_FC_CHKPT_TXN          RDB_K_DPB2_FC_CHKPT_TXN
#define RDB$K_DPB2_GB_ALLOCATION         RDB_K_DPB2_GB_ALLOCATION
#define RDB$K_DPB2_MAX                   RDB_K_DPB2_MAX
#define RDB$K_DPB2_OFF                   RDB_K_DPB2_OFF
#define RDB$K_DPB2_ON                    RDB_K_DPB2_ON
#define RDB$K_DPB2_UNKNOWN               RDB_K_DPB2_UNKNOWN
#define RDB$K_DPB2_COLLECT_DISABLED      RDB_K_DPB2_COLLECT_DISABLED
#define RDB$K_DPB2_COLLECT_ENABLED       RDB_K_DPB2_COLLECT_ENABLED
#define RDB$K_DPB2_COLLECT_FULL          RDB_K_DPB2_COLLECT_FULL
#define RDB$K_DPB2_LOGMINER_ENABLED      RDB_K_DPB2_LOGMINER_ENABLED
#define RDB$K_DPB2_LOGMINER_CONTINUOUS   RDB_K_DPB2_LOGMINER_CONTINUOUS
#define RDB$M_DPB2_LOGMINER_DISABLED     RDB_M_DPB2_LOGMINER_DISABLED
#define RDB$M_DPB2_LOGMINER_ENABLED      RDB_M_DPB2_LOGMINER_ENABLED
#define RDB$M_DPB2_LOGMINER_CONTINUOUS   RDB_M_DPB2_LOGMINER_CONTINUOUS
#define RDB$K_DPB2_NDX_TYPE_SORTED       RDB_K_DPB2_NDX_TYPE_SORTED
#define RDB$K_DPB2_NDX_TYPE_RANKED       RDB_K_DPB2_NDX_TYPE_RANKED
#define RDB$K_DPB2_MEMMAP_VLM            RDB_K_DPB2_MEMMAP_VLM
#define RDB$K_DPB2_MEMMAP_SYSBUF         RDB_K_DPB2_MEMMAP_SYSBUF
#define RDB$K_DPB2_MEMMAP_WINDOW_CNT     RDB_K_DPB2_MEMMAP_WINDOW_CNT
#define RDB$K_DPB2_MEMMAP_RESIDENT       RDB_K_DPB2_MEMMAP_RESIDENT
#define RDB$K_DPB2_MEMMAP_WORKING_SET    RDB_K_DPB2_MEMMAP_WORKING_SET
#define RDB$K_DPB2_REQUEST_SCOPE_ATTACH  RDB_K_DPB2_REQUEST_SCOPE_ATTACH
#define RDB$K_DPB2_REQUEST_SCOPE_PROG    RDB_K_DPB2_REQUEST_SCOPE_PROG
#define RDB$K_DPB2_CLTN_MIN              RDB_K_DPB2_CLTN_MIN
#define RDB$K_DPB2_CLTN_NAME             RDB_K_DPB2_CLTN_NAME
#define RDB$K_DPB2_CLTN_DESCRIPTION      RDB_K_DPB2_CLTN_DESCRIPTION
#define RDB$K_DPB2_CLTN_SEQUENCE_TABLE   RDB_K_DPB2_CLTN_SEQUENCE_TABLE
#define RDB$K_DPB2_CLTN_MAX              RDB_K_DPB2_CLTN_MAX
#define RDB$K_DPB2_LOCK_RECORD           RDB_K_DPB2_LOCK_RECORD
#define RDB$K_DPB2_LOCK_PAGE             RDB_K_DPB2_LOCK_PAGE
#define RDB$K_DPB2_KEEP_INTEGRITY_NO     RDB_K_DPB2_KEEP_INTEGRITY_NO
#define RDB$K_DPB2_KEEP_INTEGRITY_YES    RDB_K_DPB2_KEEP_INTEGRITY_YES
#define RDB$K_DPB2_META_LEVEL_MULTI      RDB_K_DPB2_META_LEVEL_MULTI
#define RDB$K_DPB2_META_LEVEL_SINGLE     RDB_K_DPB2_META_LEVEL_SINGLE
#define RDB$K_DPB2_ALG_ENABLED           RDB_K_DPB2_ALG_ENABLED
#define RDB$K_DPB2_ALG_DISABLED          RDB_K_DPB2_ALG_DISABLED
#define RDB$K_DPB2_ROOT_FILE_ACL_NO      RDB_K_DPB2_ROOT_FILE_ACL_NO
#define RDB$K_DPB2_ROOT_FILE_ACL_YES     RDB_K_DPB2_ROOT_FILE_ACL_YES
#define RDB$K_DPB2_JTYPE_AIJ             RDB_K_DPB2_JTYPE_AIJ
#define RDB$K_DPB2_JTYPE_RUJ             RDB_K_DPB2_JTYPE_RUJ
#define RDB$K_DPB2_ATYPE_STORAGE         RDB_K_DPB2_ATYPE_STORAGE
#define RDB$K_DPB2_ATYPE_TEMPLATE        RDB_K_DPB2_ATYPE_TEMPLATE
#define RDB$K_DPB2_DELETE_RESTRICT       RDB_K_DPB2_DELETE_RESTRICT
#define RDB$K_DPB2_DELETE_CASCADE        RDB_K_DPB2_DELETE_CASCADE
#define RDB$K_DPB2_CHKPT_ALL_TO_FILE     RDB_K_DPB2_CHKPT_ALL_TO_FILE
#define RDB$K_DPB2_CHKPT_UPD_TO_FILE     RDB_K_DPB2_CHKPT_UPD_TO_FILE
#define RDB$K_DPB2_CHKPT_UPD_TO_DB       RDB_K_DPB2_CHKPT_UPD_TO_DB
#define RDB$K_DPB2_SECURITY_EXTERNAL     RDB_K_DPB2_SECURITY_EXTERNAL
#define RDB$K_DPB2_SECURITY_INTERNAL_ID  RDB_K_DPB2_SECURITY_INTERNAL_ID
#define RDB$K_DPB2_SECURITY_INTERNAL_NM  RDB_K_DPB2_SECURITY_INTERNAL_NM
#define RDB$K_DPB2_SECURITY_EXTERNAL_PS  RDB_K_DPB2_SECURITY_EXTERNAL_PS
#define RDB$K_DPB2_BUFTYPE_LOCAL         RDB_K_DPB2_BUFTYPE_LOCAL
#define RDB$K_DPB2_BUFTYPE_GLOBAL        RDB_K_DPB2_BUFTYPE_GLOBAL
#define RDB$K_TXN_MODE_CONCURRENT_READ   RDB_K_TXN_MODE_CONCURRENT_READ
#define RDB$K_TXN_MODE_CONCURRENT_WRITE  RDB_K_TXN_MODE_CONCURRENT_WRITE
#define RDB$K_TXN_MODE_PROTECTED_READ    RDB_K_TXN_MODE_PROTECTED_READ
#define RDB$K_TXN_MODE_PROTECTED_WRITE   RDB_K_TXN_MODE_PROTECTED_WRITE
#define RDB$K_TXN_MODE_EXCLUSIVE_READ    RDB_K_TXN_MODE_EXCLUSIVE_READ
#define RDB$K_TXN_MODE_EXCLUSIVE_WRITE   RDB_K_TXN_MODE_EXCLUSIVE_WRITE
#define RDB$K_TXN_MODE_READ_ONLY         RDB_K_TXN_MODE_READ_ONLY
#define RDB$K_TXN_MODE_BATCH_UPDATE      RDB_K_TXN_MODE_BATCH_UPDATE
#define RDB$M_TXN_MODE_CONCURRENT_READ   RDB_M_TXN_MODE_CONCURRENT_READ
#define RDB$M_TXN_MODE_CONCURRENT_WRITE  RDB_M_TXN_MODE_CONCURRENT_WRITE
#define RDB$M_TXN_MODE_PROTECTED_READ    RDB_M_TXN_MODE_PROTECTED_READ
#define RDB$M_TXN_MODE_PROTECTED_WRITE   RDB_M_TXN_MODE_PROTECTED_WRITE
#define RDB$M_TXN_MODE_EXCLUSIVE_READ    RDB_M_TXN_MODE_EXCLUSIVE_READ
#define RDB$M_TXN_MODE_EXCLUSIVE_WRITE   RDB_M_TXN_MODE_EXCLUSIVE_WRITE
#define RDB$M_TXN_MODE_READ_ONLY         RDB_M_TXN_MODE_READ_ONLY
#define RDB$M_TXN_MODE_BATCH_UPDATE      RDB_M_TXN_MODE_BATCH_UPDATE
#define RDB$M_TXN_MODE_CONCURRENT_ALL    RDB_M_TXN_MODE_CONCURRENT_ALL
#define RDB$M_TXN_MODE_PROTECTED_ALL     RDB_M_TXN_MODE_PROTECTED_ALL
#define RDB$M_TXN_MODE_EXCLUSIVE_ALL     RDB_M_TXN_MODE_EXCLUSIVE_ALL
#define RDB$M_TXN_MODE_READ_WRITE        RDB_M_TXN_MODE_READ_WRITE
#define RDB$M_TXN_MODE_ALL               RDB_M_TXN_MODE_ALL
#define RDB$M_TXN_MODE_NONE              RDB_M_TXN_MODE_NONE
#define RDB$K_ES_FIELD_SEP               RDB_K_ES_FIELD_SEP
#define RDB$K_ES_SEQUENCE                RDB_K_ES_SEQUENCE
#define RDB$K_ES_MIN                     RDB_K_ES_MIN
#define RDB$K_ES_YEAR                    RDB_K_ES_YEAR
#define RDB$K_ES_MONTH                   RDB_K_ES_MONTH
#define RDB$K_ES_HOUR                    RDB_K_ES_HOUR
#define RDB$K_ES_MINUTE                  RDB_K_ES_MINUTE
#define RDB$K_ES_JULIAN_DAY              RDB_K_ES_JULIAN_DAY
#define RDB$K_ES_DAY                     RDB_K_ES_DAY
#define RDB$K_ES_WEEKDAY                 RDB_K_ES_WEEKDAY
#define RDB$K_ES_DAY_OF_EPIC             RDB_K_ES_DAY_OF_EPIC
#define RDB$K_ES_MAX                     RDB_K_ES_MAX
#define RDB$K_EVAL_COMMIT_TIME           RDB_K_EVAL_COMMIT_TIME
#define RDB$K_EVAL_UPDATE_TIME           RDB_K_EVAL_UPDATE_TIME
#define RDB$K_EVAL_NOT_DEFERRABLE        RDB_K_EVAL_NOT_DEFERRABLE
#define TPB$K_VERSION                    TPB_K_VERSION
#define TPB$K_OPT_MIN                    TPB_K_OPT_MIN
#define TPB$K_DEGREE3                    TPB_K_DEGREE3
#define TPB$K_DEGREE2                    TPB_K_DEGREE2
#define TPB$K_SHARED                     TPB_K_SHARED
#define TPB$K_PROTECTED                  TPB_K_PROTECTED
#define TPB$K_EXCLUSIVE                  TPB_K_EXCLUSIVE
#define TPB$K_WAIT                       TPB_K_WAIT
#define TPB$K_NOWAIT                     TPB_K_NOWAIT
#define TPB$K_READ                       TPB_K_READ
#define TPB$K_WRITE                      TPB_K_WRITE
#define TPB$K_LOCK_READ                  TPB_K_LOCK_READ
#define TPB$K_LOCK_WRITE                 TPB_K_LOCK_WRITE
#define TPB$K_VERB_TIME                  TPB_K_VERB_TIME
#define TPB$K_COMMIT_TIME                TPB_K_COMMIT_TIME
#define TPB$K_BATCH_UPDATE               TPB_K_BATCH_UPDATE
#define TPB$K_RETAIN_LOCKS               TPB_K_RETAIN_LOCKS
#define TPB$K_AUTO_LOCKS                 TPB_K_AUTO_LOCKS
#define TPB$K_NOAUTO_LOCKS               TPB_K_NOAUTO_LOCKS
#define TPB$K_DEFER_INDEX_UPDATES        TPB_K_DEFER_INDEX_UPDATES
#define TPB$K_2PC_TRANSACTION            TPB_K_2PC_TRANSACTION
#define TPB$K_DDTM_NOTINVOLVED           TPB_K_DDTM_NOTINVOLVED
#define TPB$K_FROM_JSV                   TPB_K_FROM_JSV
#define TPB$K_WAIT_INTERVAL              TPB_K_WAIT_INTERVAL
#define TPB$K_UNIQUE_ID                  TPB_K_UNIQUE_ID
#define TPB$K_ISOLATION_LEVEL1           TPB_K_ISOLATION_LEVEL1
#define TPB$K_ISOLATION_LEVEL2           TPB_K_ISOLATION_LEVEL2
#define TPB$K_ISOLATION_LEVEL3           TPB_K_ISOLATION_LEVEL3
#define TPB$K_ISOLATION_LEVEL0           TPB_K_ISOLATION_LEVEL0
#define TPB$K_LOCK_DDL                   TPB_K_LOCK_DDL
#define TPB$K_PARTITION                  TPB_K_PARTITION
#define TPB$K_UTILITY_READ               TPB_K_UTILITY_READ
#define TPB$K_BUFFER_NAME                TPB_K_BUFFER_NAME
#define TPB$K_OPT_MAX                    TPB_K_OPT_MAX
#define RDB$K_INFO_MIN                   RDB_K_INFO_MIN
#define RDB$K_INFO_FILLER                RDB_K_INFO_FILLER
#define RDB$K_INFO_END                   RDB_K_INFO_END
#define RDB$K_INFO_TRUNCATED             RDB_K_INFO_TRUNCATED
#define RDB$K_INFO_ERROR                 RDB_K_INFO_ERROR
#define RDB$K_INFO_MAX                   RDB_K_INFO_MAX
#define RDB$K_INFO_DB_MIN                RDB_K_INFO_DB_MIN
#define RDB$K_INFO_DB_ID                 RDB_K_INFO_DB_ID
#define RDB$K_INFO_DB_READS              RDB_K_INFO_DB_READS
#define RDB$K_INFO_DB_WRITES             RDB_K_INFO_DB_WRITES
#define RDB$K_INFO_DB_FETCHES            RDB_K_INFO_DB_FETCHES
#define RDB$K_INFO_DB_MARKS              RDB_K_INFO_DB_MARKS
#define RDB$K_INFO_DB_ASTS               RDB_K_INFO_DB_ASTS
#define RDB$K_INFO_DB_AST_WRITES         RDB_K_INFO_DB_AST_WRITES
#define RDB$K_INFO_DB_IMPLEMENTATION     RDB_K_INFO_DB_IMPLEMENTATION
#define RDB$K_INFO_DB_VERSION            RDB_K_INFO_DB_VERSION
#define RDB$K_INFO_DB_BASE_LEVEL         RDB_K_INFO_DB_BASE_LEVEL
#define RDB$K_INFO_DB_PAGE_SIZE          RDB_K_INFO_DB_PAGE_SIZE
#define RDB$K_INFO_DB_NUMBER_BUFFERS     RDB_K_INFO_DB_NUMBER_BUFFERS
#define RDB$K_INFO_DB_LIMBO              RDB_K_INFO_DB_LIMBO
#define RDB$K_INFO_DB_NAME               RDB_K_INFO_DB_NAME
#define RDB$K_INFO_DB_STO_AREA_STATS     RDB_K_INFO_DB_STO_AREA_STATS
#define RDB$K_INFO_DB_ALLOCATION         RDB_K_INFO_DB_ALLOCATION
#define RDB$K_INFO_DB_EXTENT_MIN         RDB_K_INFO_DB_EXTENT_MIN
#define RDB$K_INFO_DB_EXTENT_MAX         RDB_K_INFO_DB_EXTENT_MAX
#define RDB$K_INFO_DB_EXTENT_PRCNT       RDB_K_INFO_DB_EXTENT_PRCNT
#define RDB$K_INFO_DB_SNP_EXTENT_MIN     RDB_K_INFO_DB_SNP_EXTENT_MIN
#define RDB$K_INFO_DB_SNP_EXTENT_MAX     RDB_K_INFO_DB_SNP_EXTENT_MAX
#define RDB$K_INFO_DB_SNP_EXTENT_PRCNT   RDB_K_INFO_DB_SNP_EXTENT_PRCNT
#define RDB$K_INFO_DB_SNP_ALLOCATION     RDB_K_INFO_DB_SNP_ALLOCATION
#define RDB$K_INFO_DB_SNP_FILE           RDB_K_INFO_DB_SNP_FILE
#define RDB$K_INFO_DB_AREA_FILE          RDB_K_INFO_DB_AREA_FILE
#define RDB$K_INFO_DB_AREA_TYPE          RDB_K_INFO_DB_AREA_TYPE
#define RDB$K_INFO_DB_AREA_NAME          RDB_K_INFO_DB_AREA_NAME
#define RDB$K_INFO_DB_STO_AREA_LIST      RDB_K_INFO_DB_STO_AREA_LIST
#define RDB$K_INFO_DB_SEGMENT_AREA       RDB_K_INFO_DB_SEGMENT_AREA
#define RDB$K_INFO_DB_NUMBER_USERS       RDB_K_INFO_DB_NUMBER_USERS
#define RDB$K_INFO_DB_NUMBER_NODES       RDB_K_INFO_DB_NUMBER_NODES
#define RDB$K_INFO_DB_NUMBER_DBR_BFRS    RDB_K_INFO_DB_NUMBER_DBR_BFRS
#define RDB$K_INFO_DB_SNP_ENABLED        RDB_K_INFO_DB_SNP_ENABLED
#define RDB$K_INFO_DB_SNP_DEFERRED       RDB_K_INFO_DB_SNP_DEFERRED
#define RDB$K_INFO_DB_AIJ_ALLOCATION     RDB_K_INFO_DB_AIJ_ALLOCATION
#define RDB$K_INFO_DB_AIJ_EXTENSION      RDB_K_INFO_DB_AIJ_EXTENSION
#define RDB$K_INFO_DB_BUFFER_SIZE        RDB_K_INFO_DB_BUFFER_SIZE
#define RDB$K_INFO_DB_AREA_ACCESS_MODE   RDB_K_INFO_DB_AREA_ACCESS_MODE
#define RDB$K_INFO_DB_MFDB               RDB_K_INFO_DB_MFDB
#define RDB$K_INFO_DB_REMOTE_NODE        RDB_K_INFO_DB_REMOTE_NODE
#define RDB$K_INFO_DB_ALLOCATION_MAX     RDB_K_INFO_DB_ALLOCATION_MAX
#define RDB$K_INFO_DB_SNP_ALLOC_MAX      RDB_K_INFO_DB_SNP_ALLOC_MAX
#define RDB$K_INFO_DB_AUDIT_EVENTS       RDB_K_INFO_DB_AUDIT_EVENTS
#define RDB$K_INFO_DB_AUDIT_ALARM_NAME   RDB_K_INFO_DB_AUDIT_ALARM_NAME
#define RDB$K_INFO_DB_AUDIT_FILE_NAME    RDB_K_INFO_DB_AUDIT_FILE_NAME
#define RDB$K_INFO_DB_AUDIT_FLAGS        RDB_K_INFO_DB_AUDIT_FLAGS
#define RDB$K_INFO_DB_INTEGRITY          RDB_K_INFO_DB_INTEGRITY
#define RDB$K_INFO_DB_SINGLE_LEVEL       RDB_K_INFO_DB_SINGLE_LEVEL
#define RDB$K_INFO_DB_ALG_COUNT          RDB_K_INFO_DB_ALG_COUNT
#define RDB$K_INFO_DB_SPAM_INTERVAL      RDB_K_INFO_DB_SPAM_INTERVAL
#define RDB$K_INFO_DB_AREA_THRESHOLD     RDB_K_INFO_DB_AREA_THRESHOLD
#define RDB$K_INFO_DB_LAREA_THRESHOLD    RDB_K_INFO_DB_LAREA_THRESHOLD
#define RDB$K_INFO_DB_GB_ENABLED         RDB_K_INFO_DB_GB_ENABLED
#define RDB$K_INFO_DB_GB_NUM_BUFF        RDB_K_INFO_DB_GB_NUM_BUFF
#define RDB$K_INFO_DB_GB_NUM_PER_USER    RDB_K_INFO_DB_GB_NUM_PER_USER
#define RDB$K_INFO_DB_FC_CHKPT_INTERVAL  RDB_K_INFO_DB_FC_CHKPT_INTERVAL
#define RDB$K_INFO_DB_FC_CHKPT_ENABLED   RDB_K_INFO_DB_FC_CHKPT_ENABLED
#define RDB$K_INFO_DB_FC_CHKPT_TIME      RDB_K_INFO_DB_FC_CHKPT_TIME
#define RDB$K_INFO_DB_AIJ_FILE_NAME      RDB_K_INFO_DB_AIJ_FILE_NAME
#define RDB$K_INFO_DB_LCKOPT_ENABLED     RDB_K_INFO_DB_LCKOPT_ENABLED
#define RDB$K_INFO_DB_LOCK_TIMEOUT       RDB_K_INFO_DB_LOCK_TIMEOUT
#define RDB$K_INFO_DB_FC_COMMIT_TO_JRNL  RDB_K_INFO_DB_FC_COMMIT_TO_JRNL
#define RDB$K_INFO_DB_FC_TSN_INTERVAL    RDB_K_INFO_DB_FC_TSN_INTERVAL
#define RDB$K_INFO_DB_MULTISCHEMA        RDB_K_INFO_DB_MULTISCHEMA
#define RDB$K_INFO_DB_CSET               RDB_K_INFO_DB_CSET
#define RDB$K_INFO_DB_STO_AREA_COUNT     RDB_K_INFO_DB_STO_AREA_COUNT
#define RDB$K_INFO_DB_ROOT_FILE_ACL      RDB_K_INFO_DB_ROOT_FILE_ACL
#define RDB$K_INFO_DB_EXTENT_ENABLED     RDB_K_INFO_DB_EXTENT_ENABLED
#define RDB$K_INFO_DB_MAC_POLICY         RDB_K_INFO_DB_MAC_POLICY
#define RDB$K_INFO_DB_AIJ_LIST           RDB_K_INFO_DB_AIJ_LIST
#define RDB$K_INFO_DB_AIJ_COUNT          RDB_K_INFO_DB_AIJ_COUNT
#define RDB$K_INFO_DB_AIJ_NAME           RDB_K_INFO_DB_AIJ_NAME
#define RDB$K_INFO_DB_AIJ_STATS          RDB_K_INFO_DB_AIJ_STATS
#define RDB$K_INFO_DB_AIJ_FREE           RDB_K_INFO_DB_AIJ_FREE
#define RDB$K_INFO_DB_STO_AREA_FREE      RDB_K_INFO_DB_STO_AREA_FREE
#define RDB$K_INFO_DB_STATISTICS         RDB_K_INFO_DB_STATISTICS
#define RDB$K_INFO_DB_AIJ_SPOOL_FILE     RDB_K_INFO_DB_AIJ_SPOOL_FILE
#define RDB$K_INFO_DB_AIJ_CACHE_FILE     RDB_K_INFO_DB_AIJ_CACHE_FILE
#define RDB$K_INFO_DB_AIJ_SUPERSEDE      RDB_K_INFO_DB_AIJ_SUPERSEDE
#define RDB$K_INFO_DB_AIJ_BCK_SERVER     RDB_K_INFO_DB_AIJ_BCK_SERVER
#define RDB$K_INFO_DB_AIJ_LOG_SERVER     RDB_K_INFO_DB_AIJ_LOG_SERVER
#define RDB$K_INFO_DB_AIJ_OVERWRITE      RDB_K_INFO_DB_AIJ_OVERWRITE
#define RDB$K_INFO_DB_AIJ_ENABLED        RDB_K_INFO_DB_AIJ_ENABLED
#define RDB$K_INFO_DB_IDX_COMPRESSION    RDB_K_INFO_DB_IDX_COMPRESSION
#define RDB$K_INFO_DB_AREA_LOCKING       RDB_K_INFO_DB_AREA_LOCKING
#define RDB$K_INFO_DB_RESTRICTED_ACCESS  RDB_K_INFO_DB_RESTRICTED_ACCESS
#define RDB$K_INFO_DB_AIJ_NOTIFY         RDB_K_INFO_DB_AIJ_NOTIFY
#define RDB$K_INFO_DB_ACTIVE_JOURNAL     RDB_K_INFO_DB_ACTIVE_JOURNAL
#define RDB$K_INFO_DB_DEFAULT_LINK       RDB_K_INFO_DB_DEFAULT_LINK
#define RDB$K_INFO_DB_OPEN_MODE          RDB_K_INFO_DB_OPEN_MODE
#define RDB$K_INFO_DB_SHUTDOWN_TIME      RDB_K_INFO_DB_SHUTDOWN_TIME
#define RDB$K_INFO_DB_ASYNCH_PREFETCH    RDB_K_INFO_DB_ASYNCH_PREFETCH
#define RDB$K_INFO_DB_ABW_CLEAN_BUFFERS  RDB_K_INFO_DB_ABW_CLEAN_BUFFERS
#define RDB$K_INFO_DB_ASYNCH_BATCHWRITE  RDB_K_INFO_DB_ASYNCH_BATCHWRITE
#define RDB$K_INFO_DB_APF_DEPTH          RDB_K_INFO_DB_APF_DEPTH
#define RDB$K_INFO_DB_PARTITIONED_LOCK   RDB_K_INFO_DB_PARTITIONED_LOCK
#define RDB$K_INFO_DB_GB_TRANSFER        RDB_K_INFO_DB_GB_TRANSFER
#define RDB$K_INFO_DB_INCR_BACKUP        RDB_K_INFO_DB_INCR_BACKUP
#define RDB$K_INFO_DB_ABW_MAX_BUFFERS    RDB_K_INFO_DB_ABW_MAX_BUFFERS
#define RDB$K_INFO_DB_DEF_STORAGE_NAME   RDB_K_INFO_DB_DEF_STORAGE_NAME
#define RDB$K_INFO_DB_DEF_TEMPLATE_NAME  RDB_K_INFO_DB_DEF_TEMPLATE_NAME
#define RDB$K_INFO_DB_D_ASYNCH_PREFETCH  RDB_K_INFO_DB_D_ASYNCH_PREFETCH
#define RDB$K_INFO_DB_DAPF_DEPTH         RDB_K_INFO_DB_DAPF_DEPTH
#define RDB$K_INFO_DB_DAPF_THRESHOLD     RDB_K_INFO_DB_DAPF_THRESHOLD
#define RDB$K_INFO_DB_CACHE_NAME         RDB_K_INFO_DB_CACHE_NAME
#define RDB$K_INFO_DB_CACHE_LIST         RDB_K_INFO_DB_CACHE_LIST
#define RDB$K_INFO_DB_CACHE_COUNT        RDB_K_INFO_DB_CACHE_COUNT
#define RDB$K_INFO_DB_CACHE_STATS        RDB_K_INFO_DB_CACHE_STATS
#define RDB$K_INFO_DB_CACHE_FREE         RDB_K_INFO_DB_CACHE_FREE
#define RDB$K_INFO_DB_TEMPLATE_FREE      RDB_K_INFO_DB_TEMPLATE_FREE
#define RDB$K_INFO_DB_WORKLOAD_ENABLED   RDB_K_INFO_DB_WORKLOAD_ENABLED
#define RDB$K_INFO_DB_CARD_UPD_ENABLED   RDB_K_INFO_DB_CARD_UPD_ENABLED
#define RDB$K_INFO_DB_DDL_ENABLED        RDB_K_INFO_DB_DDL_ENABLED
#define RDB$K_INFO_DB_AIJ_EDIT_STRING    RDB_K_INFO_DB_AIJ_EDIT_STRING
#define RDB$K_INFO_DB_ROW_CACHE_ENABLED  RDB_K_INFO_DB_ROW_CACHE_ENABLED
#define RDB$K_INFO_DB_RUJ_FILE_LOCATION  RDB_K_INFO_DB_RUJ_FILE_LOCATION
#define RDB$K_INFO_DB_TEMPLATE_ENABLED   RDB_K_INFO_DB_TEMPLATE_ENABLED
#define RDB$K_INFO_DB_TXN_MODES_ENABLED  RDB_K_INFO_DB_TXN_MODES_ENABLED
#define RDB$K_INFO_DB_MEMORY_MAPPING     RDB_K_INFO_DB_MEMORY_MAPPING
#define RDB$K_INFO_DB_CHECKSUM_FLAG      RDB_K_INFO_DB_CHECKSUM_FLAG
#define RDB$K_INFO_DB_SNP_CHECKSUM_FLAG  RDB_K_INFO_DB_SNP_CHECKSUM_FLAG
#define RDB$K_INFO_DB_CACHE_REPLACE      RDB_K_INFO_DB_CACHE_REPLACE
#define RDB$K_INFO_DB_CACHE_SWEEP_INTVL  RDB_K_INFO_DB_CACHE_SWEEP_INTVL
#define RDB$K_INFO_DB_CACHE_LOCATION     RDB_K_INFO_DB_CACHE_LOCATION
#define RDB$K_INFO_DB_CACHE_RSVD_RECS    RDB_K_INFO_DB_CACHE_RSVD_RECS
#define RDB$K_INFO_DB_CACHE_SWEEP_RECS   RDB_K_INFO_DB_CACHE_SWEEP_RECS
#define RDB$K_INFO_DB_CACHE_THRESHOLDS   RDB_K_INFO_DB_CACHE_THRESHOLDS
#define RDB$K_INFO_DB_SEQUENCES_FREE     RDB_K_INFO_DB_SEQUENCES_FREE
#define RDB$K_INFO_DB_SORT_STATS_LIST    RDB_K_INFO_DB_SORT_STATS_LIST
#define RDB$K_INFO_DB_CACHE_CHKPT_TIME   RDB_K_INFO_DB_CACHE_CHKPT_TIME
#define RDB$K_INFO_DB_CACHE_CHKPT_DEST   RDB_K_INFO_DB_CACHE_CHKPT_DEST
#define RDB$K_INFO_DB_SECURITY_POLICY    RDB_K_INFO_DB_SECURITY_POLICY
#define RDB$K_INFO_DB_SEQUENCE_COUNT     RDB_K_INFO_DB_SEQUENCE_COUNT
#define RDB$K_INFO_DB_RUJ_BUFFER_TYPE    RDB_K_INFO_DB_RUJ_BUFFER_TYPE
#define RDB$K_INFO_DB_OBJECT_SYNONYMS    RDB_K_INFO_DB_OBJECT_SYNONYMS
#define RDB$K_INFO_DB_TXN_MODES_CURRENT  RDB_K_INFO_DB_TXN_MODES_CURRENT
#define RDB$K_INFO_DB_SESSION_DEF_TXN    RDB_K_INFO_DB_SESSION_DEF_TXN
#define RDB$K_INFO_DB_NDX_TYPE           RDB_K_INFO_DB_NDX_TYPE
#define RDB$K_INFO_DB_NDX_PRF_COLLECT    RDB_K_INFO_DB_NDX_PRF_COLLECT
#define RDB$K_INFO_DB_LOGMINER_ENABLED   RDB_K_INFO_DB_LOGMINER_ENABLED
#define RDB$K_INFO_DB_PRESTARTED_TXN     RDB_K_INFO_DB_PRESTARTED_TXN
#define RDB$K_INFO_DB_GALAXY_ENABLED     RDB_K_INFO_DB_GALAXY_ENABLED
#define RDB$K_INFO_DB_SHARED_INSTANCE    RDB_K_INFO_DB_SHARED_INSTANCE
#define RDB$K_INFO_DB_FC_CHKPT_TXN       RDB_K_INFO_DB_FC_CHKPT_TXN
#define RDB$K_INFO_DB_CAPABILITY1        RDB_K_INFO_DB_CAPABILITY1
#define RDB$K_INFO_DB_VERSION_ORA        RDB_K_INFO_DB_VERSION_ORA
#define RDB$K_INFO_DB_FULL_VERSION       RDB_K_INFO_DB_FULL_VERSION
#define RDB$K_INFO_DB_QG_CPU_TIME        RDB_K_INFO_DB_QG_CPU_TIME
#define RDB$K_INFO_DB_QG_ELAPSED_TIME    RDB_K_INFO_DB_QG_ELAPSED_TIME
#define RDB$K_INFO_DB_QG_ROW_LIMIT       RDB_K_INFO_DB_QG_ROW_LIMIT
#define RDB$K_INFO_DB_MAX                RDB_K_INFO_DB_MAX
#define RDB$K_INFO_DB_IMPL_UNKNOWN       RDB_K_INFO_DB_IMPL_UNKNOWN
#define RDB$K_INFO_DB_IMPL_VMS           RDB_K_INFO_DB_IMPL_VMS
#define RDB$K_INFO_DB_IMPL_DECRDB        RDB_K_INFO_DB_IMPL_DECRDB
#define RDB$K_INFO_DB_IMPL_RDB           RDB_K_INFO_DB_IMPL_RDB
#define RDB$K_INFO_DB_IMPL_ELAN          RDB_K_INFO_DB_IMPL_ELAN
#define RDB$K_INFO_DB_IMPL_ELAN_DEV      RDB_K_INFO_DB_IMPL_ELAN_DEV
#define RDB$K_INFO_DB_IMPL_DDAL_Y        RDB_K_INFO_DB_IMPL_DDAL_Y
#define RDB$K_INFO_DB_IMPL_ELAN_Y        RDB_K_INFO_DB_IMPL_ELAN_Y
#define RDB$K_INFO_DB_IMPL_JRI           RDB_K_INFO_DB_IMPL_JRI
#define RDB$K_INFO_DB_IMPL_REM_CLIENT    RDB_K_INFO_DB_IMPL_REM_CLIENT
#define RDB$K_INFO_DB_IMPL_JSV           RDB_K_INFO_DB_IMPL_JSV
#define RDB$K_INFO_DB_IMPL_REM_SERVER    RDB_K_INFO_DB_IMPL_REM_SERVER
#define RDB$K_INFO_DB_IMPL_SERVER        RDB_K_INFO_DB_IMPL_SERVER
#define RDB$K_INFO_DB_IMPL_MACHINE       RDB_K_INFO_DB_IMPL_MACHINE
#define RDB$K_INFO_DB_IMPL_VIDA          RDB_K_INFO_DB_IMPL_VIDA
#define RDB$K_INFO_DB_IMPL_IDB_PC        RDB_K_INFO_DB_IMPL_IDB_PC
#define RDB$K_INFO_DB_IMPL_IDB           RDB_K_INFO_DB_IMPL_IDB
#define RDB$K_INFO_DB_IMPL_VIDA2_VMS     RDB_K_INFO_DB_IMPL_VIDA2_VMS
#define RDB$K_INFO_DB_IMPL_VIDA2_MVS     RDB_K_INFO_DB_IMPL_VIDA2_MVS
#define RDB$K_INFO_DB_IMPL_CICS          RDB_K_INFO_DB_IMPL_CICS
#define RDB$K_INFO_DB_IMPL_DB2           RDB_K_INFO_DB_IMPL_DB2
#define RDB$K_INFO_DB_IMPL_VIDAOC        RDB_K_INFO_DB_IMPL_VIDAOC
#define RDB$K_INFO_DB_IMPL_VIDAOS        RDB_K_INFO_DB_IMPL_VIDAOS
#define RDB$K_INFO_DB_IMPL_ORACLE        RDB_K_INFO_DB_IMPL_ORACLE
#define RDB$K_INFO_DB_IMPL_NSDS          RDB_K_INFO_DB_IMPL_NSDS
#define RDB$K_INFO_DB_IMPL_DAF           RDB_K_INFO_DB_IMPL_DAF
#define RDB$K_INFO_DB_IMPL_BRIDGE        RDB_K_INFO_DB_IMPL_BRIDGE
#define RDB$K_INFO_DB_IMPL_SERDB         RDB_K_INFO_DB_IMPL_SERDB
#define RDB$K_INFO_DB_IMPL_DBI           RDB_K_INFO_DB_IMPL_DBI
#define RDB$K_INFO_DB_IMPL_EDASQL        RDB_K_INFO_DB_IMPL_EDASQL
#define RDB$K_INFO_DB_IMPL_SQL400        RDB_K_INFO_DB_IMPL_SQL400
#define RDB$K_INFO_DB_IMPL_SQLACC        RDB_K_INFO_DB_IMPL_SQLACC
#define RDB$K_INFO_DB_IMPL_SYBASE        RDB_K_INFO_DB_IMPL_SYBASE
#define RDB$K_INFO_DB_IMPL_LSYB          RDB_K_INFO_DB_IMPL_LSYB
#define RDB$K_INFO_DB_IMPL_LEDA          RDB_K_INFO_DB_IMPL_LEDA
#define RDB$K_INFO_DB_IMPL_LDB2          RDB_K_INFO_DB_IMPL_LDB2
#define RDB$K_INFO_DB_IMPL_LORA          RDB_K_INFO_DB_IMPL_LORA
#define RDB$K_INFO_DB_IMPL_SQLNK         RDB_K_INFO_DB_IMPL_SQLNK
#define RDB$K_INFO_DB_IMPL_ODBC          RDB_K_INFO_DB_IMPL_ODBC
#define RDB$K_INFO_DB_IMPL_NREL          RDB_K_INFO_DB_IMPL_NREL
#define RDB$K_INFO_DB_IMPL_LRED          RDB_K_INFO_DB_IMPL_LRED
#define RDB$K_INFO_DB_IMPL_MAX           RDB_K_INFO_DB_IMPL_MAX
#define RDB$K_INFO_DB_CLASS_DBMS         RDB_K_INFO_DB_CLASS_DBMS
#define RDB$K_INFO_DB_CLASS_Y_VALVE      RDB_K_INFO_DB_CLASS_Y_VALVE
#define RDB$K_INFO_DB_CLASS_REM_INT      RDB_K_INFO_DB_CLASS_REM_INT
#define RDB$K_INFO_DB_CLASS_REM_SRVR     RDB_K_INFO_DB_CLASS_REM_SRVR
#define RDB$K_INFO_REQ_MIN               RDB_K_INFO_REQ_MIN
#define RDB$K_INFO_REQ_NUM_MSGS          RDB_K_INFO_REQ_NUM_MSGS
#define RDB$K_INFO_REQ_MAX_MSG           RDB_K_INFO_REQ_MAX_MSG
#define RDB$K_INFO_REQ_MAX_SEND          RDB_K_INFO_REQ_MAX_SEND
#define RDB$K_INFO_REQ_MAX_RECEIVE       RDB_K_INFO_REQ_MAX_RECEIVE
#define RDB$K_INFO_REQ_STATE             RDB_K_INFO_REQ_STATE
#define RDB$K_INFO_REQ_MSG_NUMBER        RDB_K_INFO_REQ_MSG_NUMBER
#define RDB$K_INFO_REQ_MSG_SIZE          RDB_K_INFO_REQ_MSG_SIZE
#define RDB$K_INFO_REQ_COST              RDB_K_INFO_REQ_COST
#define RDB$K_INFO_REQ_EST_ROWS          RDB_K_INFO_REQ_EST_ROWS
#define RDB$K_INFO_REQ_OPT_PREF          RDB_K_INFO_REQ_OPT_PREF
#define RDB$K_SET_REQ_OPT_PREF           RDB_K_SET_REQ_OPT_PREF
#define RDB$K_SET_REQ_MAX_COMP_TIME      RDB_K_SET_REQ_MAX_COMP_TIME
#define RDB$K_SET_REQ_MAX_ROWS           RDB_K_SET_REQ_MAX_ROWS
#define RDB$K_SET_REQ_FOR_UPDATE         RDB_K_SET_REQ_FOR_UPDATE
#define RDB$K_INFO_REQ_FOR_UPDATE        RDB_K_INFO_REQ_FOR_UPDATE
#define RDB$K_SET_REQ_NAME               RDB_K_SET_REQ_NAME
#define RDB$K_SET_REQ_MAX_COMP_CPU       RDB_K_SET_REQ_MAX_COMP_CPU
#define RDB$K_SET_REQ_TRANS_ACTION       RDB_K_SET_REQ_TRANS_ACTION
#define RDB$K_INFO_REQ_TRANS_ACTION      RDB_K_INFO_REQ_TRANS_ACTION
#define RDB$K_SET_REQ_MODULE_NAME        RDB_K_SET_REQ_MODULE_NAME
#define RDB$K_SET_REQ_ROUTINE_NAME       RDB_K_SET_REQ_ROUTINE_NAME
#define RDB$K_SET_REQ_NULL_PARAMETERS    RDB_K_SET_REQ_NULL_PARAMETERS
#define RDB$K_SET_REQ_CHAR_LENGTH        RDB_K_SET_REQ_CHAR_LENGTH
#define RDB$K_SET_REQ_OUTL_MODE          RDB_K_SET_REQ_OUTL_MODE
#define RDB$K_SET_REQ_OUTL_OPTION        RDB_K_SET_REQ_OUTL_OPTION
#define RDB$K_SET_REQ_OUTL_NAME          RDB_K_SET_REQ_OUTL_NAME
#define RDB$K_SET_REQ_WARN_TRUNC         RDB_K_SET_REQ_WARN_TRUNC
#define RDB$K_SET_REQ_WARN_ELIM_NULL     RDB_K_SET_REQ_WARN_ELIM_NULL
#define RDB$K_SET_REQ_HOLD_OPEN          RDB_K_SET_REQ_HOLD_OPEN
#define RDB$K_SET_REQ_OUTL_OBLR          RDB_K_SET_REQ_OUTL_OBLR
#define RDB$K_SET_REQ_OUTL_COMPL         RDB_K_SET_REQ_OUTL_COMPL
#define RDB$K_SET_REQ_OPT_SEQ            RDB_K_SET_REQ_OPT_SEQ
#define RDB$K_SET_REQ_MAX_QRY_TIME       RDB_K_SET_REQ_MAX_QRY_TIME
#define RDB$K_SET_REQ_MAX_QRY_CPU        RDB_K_SET_REQ_MAX_QRY_CPU
#define RDB$K_SET_REQ_MAX_QRY_IO         RDB_K_SET_REQ_MAX_QRY_IO
#define RDB$K_SET_REQ_OPT_SEL            RDB_K_SET_REQ_OPT_SEL
#define RDB$K_SET_REQ_IS_COMPOUND        RDB_K_SET_REQ_IS_COMPOUND
#define RDB$K_SET_REQ_CURSOR_NAME        RDB_K_SET_REQ_CURSOR_NAME
#define RDB$K_SET_REQ_SYSTEM_QUERY       RDB_K_SET_REQ_SYSTEM_QUERY
#define RDB$K_SET_REQ_AUTO_TRANSLATE     RDB_K_SET_REQ_AUTO_TRANSLATE
#define RDB$K_INFO_REQ_MAX               RDB_K_INFO_REQ_MAX
#define RDB$K_INFO_REQ_STATE_ACTIVE      RDB_K_INFO_REQ_STATE_ACTIVE
#define RDB$K_INFO_REQ_STATE_INACTIVE    RDB_K_INFO_REQ_STATE_INACTIVE
#define RDB$K_INFO_REQ_STATE_SEND        RDB_K_INFO_REQ_STATE_SEND
#define RDB$K_INFO_REQ_STATE_RECEIVE     RDB_K_INFO_REQ_STATE_RECEIVE
#define RDB$K_INFO_REQ_STATE_SELECT      RDB_K_INFO_REQ_STATE_SELECT
#define RDB$K_INFO_REQ_STATE_MAX         RDB_K_INFO_REQ_STATE_MAX
#define RDB$K_INFO_TRA_MIN               RDB_K_INFO_TRA_MIN
#define RDB$K_INFO_TRA_ID                RDB_K_INFO_TRA_ID
#define RDB$K_INFO_TRA_TYPE              RDB_K_INFO_TRA_TYPE
#define RDB$K_INFO_TRA_ISOLATION_LEVEL   RDB_K_INFO_TRA_ISOLATION_LEVEL
#define RDB$K_INFO_TRA_MAX               RDB_K_INFO_TRA_MAX
#define RDB$K_INFO_BLOB_MIN              RDB_K_INFO_BLOB_MIN
#define RDB$K_INFO_BLOB_NUM_SEGMENTS     RDB_K_INFO_BLOB_NUM_SEGMENTS
#define RDB$K_INFO_BLOB_MAX_SEGMENT      RDB_K_INFO_BLOB_MAX_SEGMENT
#define RDB$K_INFO_BLOB_TOTAL_LENGTH     RDB_K_INFO_BLOB_TOTAL_LENGTH
#define RDB$K_INFO_BLOB_CURRENT_SEGMENT  RDB_K_INFO_BLOB_CURRENT_SEGMENT
#define RDB$K_INFO_BLOB_MAX              RDB_K_INFO_BLOB_MAX
#define RDB$K_BLOB_TABLE_NAME            RDB_K_BLOB_TABLE_NAME
#define RDB$K_BLOB_COLUMN_NAME           RDB_K_BLOB_COLUMN_NAME
#define RDB$K_BLOB_CURSOR_NAME           RDB_K_BLOB_CURSOR_NAME
#define RDB$K_BLOB_REQUEST_HANDLE        RDB_K_BLOB_REQUEST_HANDLE
#define RDB$K_BLOB_MODULE_NAME           RDB_K_BLOB_MODULE_NAME
#define RDB$K_BLOB_SCRATCH_TABLE_ID      RDB_K_BLOB_SCRATCH_TABLE_ID
#define RDB$K_BLOB_MAX                   RDB_K_BLOB_MAX
#define RDB$K_LOB_MODE_DSRI              RDB_K_LOB_MODE_DSRI
#define RDB$K_LOB_MODE_ORA               RDB_K_LOB_MODE_ORA
#define RDB$K_LOB_MODE_SQL99             RDB_K_LOB_MODE_SQL99
#define RDB$K_LOB_MODE_LIST_UDT          RDB_K_LOB_MODE_LIST_UDT
#define RDB$K_TXN_DB_HANDLE              RDB_K_TXN_DB_HANDLE
#define RDB$K_TXN_ATTRIBUTES             RDB_K_TXN_ATTRIBUTES
#define RDB$K_TXN_TRANSACTION_ID         RDB_K_TXN_TRANSACTION_ID
#define RDB$K_TXN_INIT_HANDLE            RDB_K_TXN_INIT_HANDLE
#define RDB$K_TXN_MAX                    RDB_K_TXN_MAX
#define RDB$K_INFO_STAREA_MODE_RW        RDB_K_INFO_STAREA_MODE_RW
#define RDB$K_INFO_STAREA_MODE_RO        RDB_K_INFO_STAREA_MODE_RO
#define RDB$K_INFO_STAREA_MODE_WORM      RDB_K_INFO_STAREA_MODE_WORM
#define RDB$K_INFO_OPT_PREF_TT           RDB_K_INFO_OPT_PREF_TT
#define RDB$K_INFO_OPT_PREF_FF           RDB_K_INFO_OPT_PREF_FF
#define RDB$K_INFO_OPT_PREF_NONE         RDB_K_INFO_OPT_PREF_NONE
#define RDB$K_INFO_OPT_PREF_TT_OVERRIDE  RDB_K_INFO_OPT_PREF_TT_OVERRIDE
#define RDB$K_INFO_OPT_PREF_FF_OVERRIDE  RDB_K_INFO_OPT_PREF_FF_OVERRIDE
#define RDB$K_INFO_OPT_PREF_NN_OVERRIDE  RDB_K_INFO_OPT_PREF_NN_OVERRIDE
#define RDB$K_INFO_OPT_PREF_SAMPLED      RDB_K_INFO_OPT_PREF_SAMPLED
#define RDB$K_INFO_OPT_PREF_AGGRESSIVE   RDB_K_INFO_OPT_PREF_AGGRESSIVE
#define RDB$K_INFO_OUTL_COMPL_OPTIONAL   RDB_K_INFO_OUTL_COMPL_OPTIONAL
#define RDB$K_INFO_OUTL_COMPL_MANDATORY  RDB_K_INFO_OUTL_COMPL_MANDATORY
#define RDB$K_INFO_MEMMAP_SYSBUF         RDB_K_INFO_MEMMAP_SYSBUF
#define RDB$K_INFO_MEMMAP_VLM            RDB_K_INFO_MEMMAP_VLM
#define RDB$K_INFO_MEMMAP_WINDOW_CNT     RDB_K_INFO_MEMMAP_WINDOW_CNT
#define RDB$K_INFO_MEMMAP_RESIDENT       RDB_K_INFO_MEMMAP_RESIDENT
#define RDB$K_INFO_MEMMAP_WORKING_SET    RDB_K_INFO_MEMMAP_WORKING_SET
#define RDB$K_EXT_MIN                    RDB_K_EXT_MIN
#define RDB$K_EXT_ANALYZE                RDB_K_EXT_ANALYZE
#define RDB$K_EXT_MONITOR_SHOW           RDB_K_EXT_MONITOR_SHOW
#define RDB$K_EXT_MONITOR_OPER           RDB_K_EXT_MONITOR_OPER
#define RDB$K_EXT_RESOURCE_SHOW          RDB_K_EXT_RESOURCE_SHOW
#define RDB$K_EXT_CONVERT_FIXUP          RDB_K_EXT_CONVERT_FIXUP
#define RDB$K_EXT_GARBAGE_COLLECT        RDB_K_EXT_GARBAGE_COLLECT
#define RDB$K_EXT_VERIFY                 RDB_K_EXT_VERIFY
#define RDB$K_EXT_DELPRC_STREAM          RDB_K_EXT_DELPRC_STREAM
#define RDB$K_SWEEP                      RDB_K_SWEEP
#define RDB$K_EXT_PARSE_ACL              RDB_K_EXT_PARSE_ACL
#define RDB$K_EXT_FORMAT_ACL             RDB_K_EXT_FORMAT_ACL
#define RDB$K_EXT_RETURN_ACCESS          RDB_K_EXT_RETURN_ACCESS
#define RDB$K_EXT_CHECK_CONSTRAINTS      RDB_K_EXT_CHECK_CONSTRAINTS
#define RDB$K_EXT_SET_TXN_CURRENT        RDB_K_EXT_SET_TXN_CURRENT
#define RDB$K_EXT_OLDEST_TRANSACTION     RDB_K_EXT_OLDEST_TRANSACTION
#define RDB$K_EXT_CHECK_ACCESS           RDB_K_EXT_CHECK_ACCESS
#define RDB$K_EXT_SET_AUDIT              RDB_K_EXT_SET_AUDIT
#define RDB$K_EXT_PARSE_DATETIME         RDB_K_EXT_PARSE_DATETIME
#define RDB$K_EXT_FORMAT_DATETIME        RDB_K_EXT_FORMAT_DATETIME
#define RDB$K_EXT_MIA_SYSTEM_INFO        RDB_K_EXT_MIA_SYSTEM_INFO
#define RDB$K_EXT_PACK_DATETIME          RDB_K_EXT_PACK_DATETIME
#define RDB$K_EXT_UNPACK_DATETIME        RDB_K_EXT_UNPACK_DATETIME
#define RDB$K_EXT_SET_DEFAULT_TRANS      RDB_K_EXT_SET_DEFAULT_TRANS
#define RDB$K_EXT_MODULE_SETUP           RDB_K_EXT_MODULE_SETUP
#define RDB$K_EXT_SYSTEM_INFO            RDB_K_EXT_SYSTEM_INFO
#define RDB$K_EXT_ENGINE_INFO            RDB_K_EXT_ENGINE_INFO
#define RDB$K_EXT_DISPATCH_INFO          RDB_K_EXT_DISPATCH_INFO
#define RDB$K_EXT_CHECK_EXT_ROUTINE      RDB_K_EXT_CHECK_EXT_ROUTINE
#define RDB$K_EXT_SET_TRACE_FLAGS        RDB_K_EXT_SET_TRACE_FLAGS
#define RDB$K_EXT_RECOVER_XA             RDB_K_EXT_RECOVER_XA
#define RDB$K_EXT_COMMIT_XA              RDB_K_EXT_COMMIT_XA
#define RDB$K_EXT_ROLLBACK_XA            RDB_K_EXT_ROLLBACK_XA
#define RDB$K_EXT_CREATE_CLIENT_CTX      RDB_K_EXT_CREATE_CLIENT_CTX
#define RDB$K_EXT_DELETE_CLIENT_CTX      RDB_K_EXT_DELETE_CLIENT_CTX
#define RDB$K_EXT_SET_CLIENT_CTX         RDB_K_EXT_SET_CLIENT_CTX
#define RDB$K_EXT_GET_CLIENT_CTX         RDB_K_EXT_GET_CLIENT_CTX
#define RDB$K_EXT_SET_TXN_CALLBACK       RDB_K_EXT_SET_TXN_CALLBACK
#define RDB$K_EXT_PREP_DEFERRED_INDEX    RDB_K_EXT_PREP_DEFERRED_INDEX
#define RDB$K_EXT_UPDATE_DEFERRED_INDEX  RDB_K_EXT_UPDATE_DEFERRED_INDEX
#define RDB$K_EXT_RESERVE_TABLE          RDB_K_EXT_RESERVE_TABLE
#define RDB$K_EXT_PARSE_VALEXP_BLR       RDB_K_EXT_PARSE_VALEXP_BLR
#define RDB$K_EXT_EVALUATE_CONSTRAINT    RDB_K_EXT_EVALUATE_CONSTRAINT
#define RDB$K_EXT_SET_SQL_LEVEL          RDB_K_EXT_SET_SQL_LEVEL
#define RDB$K_EXT_BEGIN_IMPORT_DATABASE  RDB_K_EXT_BEGIN_IMPORT_DATABASE
#define RDB$K_EXT_END_IMPORT_DATABASE    RDB_K_EXT_END_IMPORT_DATABASE
#define RDB$K_EXT_GET_VALEXP_DTYPE       RDB_K_EXT_GET_VALEXP_DTYPE
#define RDB$K_EXT_REQUEST_QUIET_POINT    RDB_K_EXT_REQUEST_QUIET_POINT
#define RDB$K_EXT_RELEASE_QUIET_POINT    RDB_K_EXT_RELEASE_QUIET_POINT
#define RDB$K_EXT_QUERY_GOVERNOR         RDB_K_EXT_QUERY_GOVERNOR
#define RDB$K_EXT_MODIFY_AIP             RDB_K_EXT_MODIFY_AIP
#define RDB$K_EXT_MAX                    RDB_K_EXT_MAX
#define RDB$K_EXT_ANALYZE_MIN            RDB_K_EXT_ANALYZE_MIN
#define RDB$K_EXT_PAGE_CNT               RDB_K_EXT_PAGE_CNT
#define RDB$K_EXT_PAGE_SIZE              RDB_K_EXT_PAGE_SIZE
#define RDB$K_EXT_REC_LEN                RDB_K_EXT_REC_LEN
#define RDB$K_EXT_REC_CNT                RDB_K_EXT_REC_CNT
#define RDB$K_EXT_FRAG_CNT               RDB_K_EXT_FRAG_CNT
#define RDB$K_EXT_LEN_AVAIL              RDB_K_EXT_LEN_AVAIL
#define RDB$K_EXT_LEN_USED               RDB_K_EXT_LEN_USED
#define RDB$K_EXT_USED_HIST              RDB_K_EXT_USED_HIST
#define RDB$K_EXT_NODE_LEN               RDB_K_EXT_NODE_LEN
#define RDB$K_EXT_DUP_LEN                RDB_K_EXT_DUP_LEN
#define RDB$K_EXT_NODE_CNT               RDB_K_EXT_NODE_CNT
#define RDB$K_EXT_DUP_CNT                RDB_K_EXT_DUP_CNT
#define RDB$K_EXT_NODE_LEVEL             RDB_K_EXT_NODE_LEVEL
#define RDB$K_EXT_ANALYZE_MAX            RDB_K_EXT_ANALYZE_MAX
#define RDB$K_EXT_ACL_MIN                RDB_K_EXT_ACL_MIN
#define RDB$K_EXT_ACL_STR                RDB_K_EXT_ACL_STR
#define RDB$K_EXT_ACL_ENT                RDB_K_EXT_ACL_ENT
#define RDB$K_EXT_ACL_WIDTH              RDB_K_EXT_ACL_WIDTH
#define RDB$K_EXT_ACL_TERM               RDB_K_EXT_ACL_TERM
#define RDB$K_EXT_ACL_INDENT             RDB_K_EXT_ACL_INDENT
#define RDB$K_EXT_ACL_ERRPOS             RDB_K_EXT_ACL_ERRPOS
#define RDB$K_EXT_ACL_DB_ACCESS          RDB_K_EXT_ACL_DB_ACCESS
#define RDB$K_EXT_ACL_REL_ACCESS         RDB_K_EXT_ACL_REL_ACCESS
#define RDB$K_EXT_ACL_ACCESS             RDB_K_EXT_ACL_ACCESS
#define RDB$K_EXT_ACL_FLD_ACCESS         RDB_K_EXT_ACL_FLD_ACCESS
#define RDB$K_EXT_ACL_PRIV_NAMES         RDB_K_EXT_ACL_PRIV_NAMES
#define RDB$K_EXT_ACL_FORMAT             RDB_K_EXT_ACL_FORMAT
#define RDB$K_EXT_ACL_TYPE_ANSI          RDB_K_EXT_ACL_TYPE_ANSI
#define RDB$K_EXT_ACL_DB_ACCNOVR         RDB_K_EXT_ACL_DB_ACCNOVR
#define RDB$K_EXT_ACL_REL_ACCNOVR        RDB_K_EXT_ACL_REL_ACCNOVR
#define RDB$K_EXT_ACL_FLD_ACCNOVR        RDB_K_EXT_ACL_FLD_ACCNOVR
#define RDB$K_EXT_ACL_MOD_ACCESS         RDB_K_EXT_ACL_MOD_ACCESS
#define RDB$K_EXT_ACL_MOD_ACCNOVR        RDB_K_EXT_ACL_MOD_ACCNOVR
#define RDB$K_EXT_ACL_RTN_ACCESS         RDB_K_EXT_ACL_RTN_ACCESS
#define RDB$K_EXT_ACL_RTN_ACCNOVR        RDB_K_EXT_ACL_RTN_ACCNOVR
#define RDB$K_EXT_ACL_SEQ_ACCESS         RDB_K_EXT_ACL_SEQ_ACCESS
#define RDB$K_EXT_ACL_SEQ_ACCNOVR        RDB_K_EXT_ACL_SEQ_ACCNOVR
#define RDB$K_EXT_ACL_PARSE_REVOKE       RDB_K_EXT_ACL_PARSE_REVOKE
#define RDB$K_EXT_ACL_MAX                RDB_K_EXT_ACL_MAX
#define RDB$K_EXT_AUD_MIN                RDB_K_EXT_AUD_MIN
#define RDB$K_EXT_AUD_JNL                RDB_K_EXT_AUD_JNL
#define RDB$K_EXT_AUD_ALA                RDB_K_EXT_AUD_ALA
#define RDB$K_EXT_AUD_FIRST              RDB_K_EXT_AUD_FIRST
#define RDB$K_EXT_AUD_FLUSH              RDB_K_EXT_AUD_FLUSH
#define RDB$K_EXT_AUD_TYPE               RDB_K_EXT_AUD_TYPE
#define RDB$K_EXT_AUD_PURGE              RDB_K_EXT_AUD_PURGE
#define RDB$K_EXT_AUD_PRIV               RDB_K_EXT_AUD_PRIV
#define RDB$K_EXT_AUD_START              RDB_K_EXT_AUD_START
#define RDB$K_EXT_AUD_STOP               RDB_K_EXT_AUD_STOP
#define RDB$K_EXT_AUD_ENABLE             RDB_K_EXT_AUD_ENABLE
#define RDB$K_EXT_AUD_DISABLE            RDB_K_EXT_AUD_DISABLE
#define RDB$K_EXT_AUD_RMU                RDB_K_EXT_AUD_RMU
#define RDB$K_EXT_AUD_PROT               RDB_K_EXT_AUD_PROT
#define RDB$K_EXT_AUD_IDENT              RDB_K_EXT_AUD_IDENT
#define RDB$K_EXT_AUD_ACE                RDB_K_EXT_AUD_ACE
#define RDB$K_EXT_AUD_DACCESS            RDB_K_EXT_AUD_DACCESS
#define RDB$K_EXT_AUD_MACCESS            RDB_K_EXT_AUD_MACCESS
#define RDB$K_EXT_AUD_ALL                RDB_K_EXT_AUD_ALL
#define RDB$K_EXT_AUD_SCHEMA             RDB_K_EXT_AUD_SCHEMA
#define RDB$K_EXT_AUD_TABLE              RDB_K_EXT_AUD_TABLE
#define RDB$K_EXT_AUD_COLUMN             RDB_K_EXT_AUD_COLUMN
#define RDB$K_EXT_AUD_NONE               RDB_K_EXT_AUD_NONE
#define RDB$K_EXT_AUD_NAME               RDB_K_EXT_AUD_NAME
#define RDB$K_EXT_AUD_RMU_CMD            RDB_K_EXT_AUD_RMU_CMD
#define RDB$K_EXT_AUD_MAX                RDB_K_EXT_AUD_MAX
#define RDB$K_AUDIT_TYPE_AUDIT           RDB_K_AUDIT_TYPE_AUDIT
#define RDB$K_AUDIT_TYPE_ALARM           RDB_K_AUDIT_TYPE_ALARM
#define RDB$K_AUDIT_TYPE_BOTH            RDB_K_AUDIT_TYPE_BOTH
#define RDB$K_EXT_DT_MIN                 RDB_K_EXT_DT_MIN
#define RDB$K_EXT_DT_STRING              RDB_K_EXT_DT_STRING
#define RDB$K_EXT_DT_SUB_TYPE            RDB_K_EXT_DT_SUB_TYPE
#define RDB$K_EXT_DT_VALUE               RDB_K_EXT_DT_VALUE
#define RDB$K_EXT_DT_SCALE               RDB_K_EXT_DT_SCALE
#define RDB$K_EXT_DT_ILF_PREC            RDB_K_EXT_DT_ILF_PREC
#define RDB$K_EXT_DT_VECTOR              RDB_K_EXT_DT_VECTOR
#define RDB$K_EXT_DT_TYPE                RDB_K_EXT_DT_TYPE
#define RDB$K_EXT_DT_LENGTH              RDB_K_EXT_DT_LENGTH
#define RDB$K_EXT_DT_COLLATION           RDB_K_EXT_DT_COLLATION
#define RDB$K_EXT_DT_MAX                 RDB_K_EXT_DT_MAX
#define RDB$K_EXT_TXN_MIN                RDB_K_EXT_TXN_MIN
#define RDB$K_EXT_TXN_DEFAULT_TPB        RDB_K_EXT_TXN_DEFAULT_TPB
#define RDB$K_EXT_TXN_MODULE_NAME        RDB_K_EXT_TXN_MODULE_NAME
#define RDB$K_EXT_TXN_TEMP_DDL           RDB_K_EXT_TXN_TEMP_DDL
#define RDB$K_EXT_TXN_MAX                RDB_K_EXT_TXN_MAX
#define RDB$K_EXT_LVL_MIN                RDB_K_EXT_LVL_MIN
#define RDB$K_EXT_LVL_LEVEL              RDB_K_EXT_LVL_LEVEL
#define RDB$K_EXT_LVL_AUTOTRANS          RDB_K_EXT_LVL_AUTOTRANS
#define RDB$K_EXT_LVL_MAX                RDB_K_EXT_LVL_MAX
#define RDB$K_EXT_QG_MIN                 RDB_K_EXT_QG_MIN
#define RDB$K_EXT_QG_CPU_TIME            RDB_K_EXT_QG_CPU_TIME
#define RDB$K_EXT_QG_ELAPSED_TIME        RDB_K_EXT_QG_ELAPSED_TIME
#define RDB$K_EXT_QG_RETURNED_ROWS       RDB_K_EXT_QG_RETURNED_ROWS
#define RDB$K_EXT_QG_MAX                 RDB_K_EXT_QG_MAX
#define RDB$K_EXT_MODAIP_MIN             RDB_K_EXT_MODAIP_MIN
#define RDB$K_EXT_MODAIP_LAREA_ID        RDB_K_EXT_MODAIP_LAREA_ID
#define RDB$K_EXT_MODAIP_REBUILD_SPAMS   RDB_K_EXT_MODAIP_REBUILD_SPAMS
#define RDB$K_EXT_MODAIP_LAREA_NAME      RDB_K_EXT_MODAIP_LAREA_NAME
#define RDB$K_EXT_MODAIP_LAREA_RENAME    RDB_K_EXT_MODAIP_LAREA_RENAME
#define RDB$K_EXT_MODAIP_TABLE_NAME      RDB_K_EXT_MODAIP_TABLE_NAME
#define RDB$K_EXT_MODAIP_THRESHOLDS      RDB_K_EXT_MODAIP_THRESHOLDS
#define RDB$K_EXT_MODAIP_REC_LENGTH      RDB_K_EXT_MODAIP_REC_LENGTH
#define RDB$K_EXT_MODAIP_MAX             RDB_K_EXT_MODAIP_MAX
#define RDB$K_EXT_SYS_MIN                RDB_K_EXT_SYS_MIN
#define RDB$K_EXT_SYS_DB_NAME            RDB_K_EXT_SYS_DB_NAME
#define RDB$K_EXT_SYS_HND_DB_NAME        RDB_K_EXT_SYS_HND_DB_NAME
#define RDB$K_EXT_SYS_DB_TYPE            RDB_K_EXT_SYS_DB_TYPE
#define RDB$K_EXT_SYS_MAX                RDB_K_EXT_SYS_MAX
#define RDB$K_EXT_ENG_MIN                RDB_K_EXT_ENG_MIN
#define RDB$K_EXT_ENG_TRC_CB_ADDR        RDB_K_EXT_ENG_TRC_CB_ADDR
#define RDB$K_EXT_ENG_TRC_CB_PARAM       RDB_K_EXT_ENG_TRC_CB_PARAM
#define RDB$K_EXT_ENG_ENV_BUF_ADDR       RDB_K_EXT_ENG_ENV_BUF_ADDR
#define RDB$K_EXT_ENG_ENV_BUF_LEN        RDB_K_EXT_ENG_ENV_BUF_LEN
#define RDB$K_EXT_ENG_CPID_VALUE         RDB_K_EXT_ENG_CPID_VALUE
#define RDB$K_EXT_ENG_MAX                RDB_K_EXT_ENG_MAX
#define RDB$K_EXT_DISP_MIN               RDB_K_EXT_DISP_MIN
#define RDB$K_EXT_DISP_RCV_PREFETCH      RDB_K_EXT_DISP_RCV_PREFETCH
#define RDB$K_EXT_DISP_SGS_PREFETCH      RDB_K_EXT_DISP_SGS_PREFETCH
#define RDB$K_EXT_DISP_ASYNCH_ENABLED    RDB_K_EXT_DISP_ASYNCH_ENABLED
#define RDB$K_EXT_DISP_MAX               RDB_K_EXT_DISP_MAX
#define RDB$K_EXT_CSET_MIN               RDB_K_EXT_CSET_MIN
#define RDB$K_EXT_CSET_BY_ID             RDB_K_EXT_CSET_BY_ID
#define RDB$K_EXT_CSET_BY_NAME           RDB_K_EXT_CSET_BY_NAME
#define RDB$K_EXT_CSET_LIST              RDB_K_EXT_CSET_LIST
#define RDB$K_EXT_CSET_ID                RDB_K_EXT_CSET_ID
#define RDB$K_EXT_CSET_NAME              RDB_K_EXT_CSET_NAME
#define RDB$K_EXT_CSET_VERSION           RDB_K_EXT_CSET_VERSION
#define RDB$K_EXT_CSET_FORM_OF_USE       RDB_K_EXT_CSET_FORM_OF_USE
#define RDB$K_EXT_CSET_NAMES_CSET        RDB_K_EXT_CSET_NAMES_CSET
#define RDB$K_EXT_CSET_MIN_OCTETS        RDB_K_EXT_CSET_MIN_OCTETS
#define RDB$K_EXT_CSET_MAX_OCTETS        RDB_K_EXT_CSET_MAX_OCTETS
#define RDB$K_EXT_CSET_STR_WILD          RDB_K_EXT_CSET_STR_WILD
#define RDB$K_EXT_CSET_CHAR_WILD         RDB_K_EXT_CSET_CHAR_WILD
#define RDB$K_EXT_CSET_BLANK             RDB_K_EXT_CSET_BLANK
#define RDB$K_EXT_CSET_ASSOC_CSET        RDB_K_EXT_CSET_ASSOC_CSET
#define RDB$K_EXT_CSET_FLAGS             RDB_K_EXT_CSET_FLAGS
#define RDB$K_EXT_CSET_TRANS             RDB_K_EXT_CSET_TRANS
#define RDB$K_EXT_CSET_MAX               RDB_K_EXT_CSET_MAX
#define RDB$K_EXT_RTX_MIN                RDB_K_EXT_RTX_MIN
#define RDB$K_EXT_RTX_ROUTINE_NAME       RDB_K_EXT_RTX_ROUTINE_NAME
#define RDB$K_EXT_RTX_ERROR_TYPE         RDB_K_EXT_RTX_ERROR_TYPE
#define RDB$K_EXT_RTX_IMAGE_NAME         RDB_K_EXT_RTX_IMAGE_NAME
#define RDB$K_EXT_RTX_BODY_ENT_NAME      RDB_K_EXT_RTX_BODY_ENT_NAME
#define RDB$K_EXT_RTX_NTFY_ENT_NAME      RDB_K_EXT_RTX_NTFY_ENT_NAME
#define RDB$K_EXT_RTX_ERROR_TEXT         RDB_K_EXT_RTX_ERROR_TEXT
#define RDB$K_EXT_RTX_MAX                RDB_K_EXT_RTX_MAX
#define RDB$K_EXT_FLAG_MIN               RDB_K_EXT_FLAG_MIN
#define RDB$K_EXT_FLAG_STRING            RDB_K_EXT_FLAG_STRING
#define RDB$K_EXT_FLAG_SHOW              RDB_K_EXT_FLAG_SHOW
#define RDB$K_EXT_FLAG_MAX               RDB_K_EXT_FLAG_MAX
#define RDB$K_EXT_XA_TID                 RDB_K_EXT_XA_TID
#define RDB$K_EXT_XA_MAXCOUNT            RDB_K_EXT_XA_MAXCOUNT
#define RDB$K_EXT_XA_FLAGS               RDB_K_EXT_XA_FLAGS
#define RDB$K_EXT_XA_MAX                 RDB_K_EXT_XA_MAX
#define RDB$K_EXT_CC_PARENT              RDB_K_EXT_CC_PARENT
#define RDB$K_EXT_CC_UIC                 RDB_K_EXT_CC_UIC
#define RDB$K_EXT_CC_USERNAME            RDB_K_EXT_CC_USERNAME
#define RDB$K_EXT_CC_MAX                 RDB_K_EXT_CC_MAX
#define RDB$K_EXT_VFYC_MIN               RDB_K_EXT_VFYC_MIN
#define RDB$K_EXT_VFYC_TABLE_NAME        RDB_K_EXT_VFYC_TABLE_NAME
#define RDB$K_EXT_VFYC_CONSTRAINT_NAME   RDB_K_EXT_VFYC_CONSTRAINT_NAME
#define RDB$K_EXT_VFYC_EXCLUDE_UNIQUE    RDB_K_EXT_VFYC_EXCLUDE_UNIQUE
#define RDB$K_EXT_VFYC_INCLUDE_DISABLED  RDB_K_EXT_VFYC_INCLUDE_DISABLED
#define RDB$K_EXT_VFYC_FAILURE_TEXT      RDB_K_EXT_VFYC_FAILURE_TEXT
#define RDB$K_EXT_VFYC_TRUNCATE          RDB_K_EXT_VFYC_TRUNCATE
#define RDB$K_EXT_VFYC_MAX               RDB_K_EXT_VFYC_MAX
#define RDB$K_CSET_MCS                   RDB_K_CSET_MCS
#define RDB$K_CSET_DEC_MCS               RDB_K_CSET_DEC_MCS
#define RDB$K_CSET_ISOLATIN1             RDB_K_CSET_ISOLATIN1
#define RDB$K_CSET_ISOLATIN2             RDB_K_CSET_ISOLATIN2
#define RDB$K_CSET_ISOLATINARABIC        RDB_K_CSET_ISOLATINARABIC
#define RDB$K_CSET_ISOLATINGREEK         RDB_K_CSET_ISOLATINGREEK
#define RDB$K_CSET_ISOLATINCYRILLIC      RDB_K_CSET_ISOLATINCYRILLIC
#define RDB$K_CSET_ISOLATINHEBREW        RDB_K_CSET_ISOLATINHEBREW
#define RDB$K_CSET_ISOLATIN3             RDB_K_CSET_ISOLATIN3
#define RDB$K_CSET_ISOLATIN4             RDB_K_CSET_ISOLATIN4
#define RDB$K_CSET_ISOLATIN5             RDB_K_CSET_ISOLATIN5
#define RDB$K_CSET_ISOLATIN6             RDB_K_CSET_ISOLATIN6
#define RDB$K_CSET_ISOLATIN9             RDB_K_CSET_ISOLATIN9
#define RDB$K_CSET_KATAKANA              RDB_K_CSET_KATAKANA
#define RDB$K_CSET_KANJI                 RDB_K_CSET_KANJI
#define RDB$K_CSET_HANZI                 RDB_K_CSET_HANZI
#define RDB$K_CSET_KOREAN                RDB_K_CSET_KOREAN
#define RDB$K_CSET_HANYU                 RDB_K_CSET_HANYU
#define RDB$K_CSET_DTSCS                 RDB_K_CSET_DTSCS
#define RDB$K_CSET_DEC_KANJI             RDB_K_CSET_DEC_KANJI
#define RDB$K_CSET_DEC_HANZI             RDB_K_CSET_DEC_HANZI
#define RDB$K_CSET_DEC_KOREAN            RDB_K_CSET_DEC_KOREAN
#define RDB$K_CSET_DEC_HANYU             RDB_K_CSET_DEC_HANYU
#define RDB$K_CSET_DEC_SICGCC            RDB_K_CSET_DEC_SICGCC
#define RDB$K_CSET_GB18030               RDB_K_CSET_GB18030
#define RDB$K_CSET_ASCII                 RDB_K_CSET_ASCII
#define RDB$K_CSET_SIMPLE_LATIN          RDB_K_CSET_SIMPLE_LATIN
#define RDB$K_CSET_ARABIC                RDB_K_CSET_ARABIC
#define RDB$K_CSET_WIN_LATIN1            RDB_K_CSET_WIN_LATIN1
#define RDB$K_CSET_WIN_LATIN2            RDB_K_CSET_WIN_LATIN2
#define RDB$K_CSET_WIN_ARABIC            RDB_K_CSET_WIN_ARABIC
#define RDB$K_CSET_WIN_GREEK             RDB_K_CSET_WIN_GREEK
#define RDB$K_CSET_WIN_CYRILLIC          RDB_K_CSET_WIN_CYRILLIC
#define RDB$K_CSET_WIN_HEBREW            RDB_K_CSET_WIN_HEBREW
#define RDB$K_CSET_DOS_LATINUS           RDB_K_CSET_DOS_LATINUS
#define RDB$K_CSET_DOS_LATIN1            RDB_K_CSET_DOS_LATIN1
#define RDB$K_CSET_HEX                   RDB_K_CSET_HEX
#define RDB$K_CSET_UNICODE               RDB_K_CSET_UNICODE
#define RDB$K_CSET_UTF8                  RDB_K_CSET_UTF8
#define RDB$K_CSET_AL24UTFFSS            RDB_K_CSET_AL24UTFFSS
#define RDB$K_CSET_SHIFT_JIS             RDB_K_CSET_SHIFT_JIS
#define RDB$K_CSET_MS_KANJI              RDB_K_CSET_MS_KANJI
#define RDB$K_CSET_DEVANAGARI            RDB_K_CSET_DEVANAGARI
#define RDB$K_CSET_TACTIS                RDB_K_CSET_TACTIS
#define RDB$K_CSET_THAI                  RDB_K_CSET_THAI
#define RDB$K_CSET_UJIS                  RDB_K_CSET_UJIS
#define RDB$K_CSET_PSEUDO_MOCS           RDB_K_CSET_PSEUDO_MOCS
#define RDB$K_CSET_BIG5                  RDB_K_CSET_BIG5
#define RDB$K_CSET_COMPOUND_STRING       RDB_K_CSET_COMPOUND_STRING
#define RDB$K_CSET_UNSPECIFIED           RDB_K_CSET_UNSPECIFIED
#define RDB$K_CSET_FOU_MIN               RDB_K_CSET_FOU_MIN
#define RDB$K_CSET_FIXED_OCTET           RDB_K_CSET_FIXED_OCTET
#define RDB$K_CSET_MIXED_OCTET           RDB_K_CSET_MIXED_OCTET
#define RDB$K_CSET_FIXED_NO_UP           RDB_K_CSET_FIXED_NO_UP
#define RDB$K_CSET_MIXED_SS2             RDB_K_CSET_MIXED_SS2
#define RDB$K_CSET_FIXED_UP_G1           RDB_K_CSET_FIXED_UP_G1
#define RDB$K_CSET_MIXED_SS3             RDB_K_CSET_MIXED_SS3
#define RDB$K_CSET_FIXED_OTHER           RDB_K_CSET_FIXED_OTHER
#define RDB$K_CSET_MIXED_C2CB            RDB_K_CSET_MIXED_C2CB
#define RDB$K_CSET_MIXED_TAG             RDB_K_CSET_MIXED_TAG
#define RDB$K_CSET_MIXED_SHIFT           RDB_K_CSET_MIXED_SHIFT
#define RDB$K_CSET_MIXED_110             RDB_K_CSET_MIXED_110
#define RDB$K_CSET_MIXED_GB18030         RDB_K_CSET_MIXED_GB18030
#define RDB$K_CSET_FOU_MAX               RDB_K_CSET_FOU_MAX
#define RDB$V_CSET_CONTAINS_ASCII        RDB_V_CSET_CONTAINS_ASCII
#define RDB$V_CSET_SPACE_OCTET_REPEATS   RDB_V_CSET_SPACE_OCTET_REPEATS
#define RDB$K_CSET_MAX_OCTETS_PER_CHAR   RDB_K_CSET_MAX_OCTETS_PER_CHAR
#define RDB$K_SUB_TYPE_UNS               RDB_K_SUB_TYPE_UNS
#define RDB$K_SUB_TYPE_TEXT              RDB_K_SUB_TYPE_TEXT
#define RDB$K_SUB_TYPE_BLR               RDB_K_SUB_TYPE_BLR
#define RDB$K_SUB_TYPE_MBLR              RDB_K_SUB_TYPE_MBLR
#define RDB$K_SUB_TYPE_BINARY            RDB_K_SUB_TYPE_BINARY
#define RDB$K_SUB_TYPE_OBLR              RDB_K_SUB_TYPE_OBLR
#define RDB$K_SUB_TYPE_SQL_CLOB          RDB_K_SUB_TYPE_SQL_CLOB
#define RDB$K_SUB_TYPE_SQL_NCLOB         RDB_K_SUB_TYPE_SQL_NCLOB
#define RDB$K_SUB_TYPE_SQL_BLOB          RDB_K_SUB_TYPE_SQL_BLOB
#define RDB$K_SUB_TYPE_SQLMM_MIN         RDB_K_SUB_TYPE_SQLMM_MIN
#define RDB$K_SUB_TYPE_SQLMM_MAX         RDB_K_SUB_TYPE_SQLMM_MAX
#define RDB$K_SUB_TYPE_USER              RDB_K_SUB_TYPE_USER
#define RDB$K_SUB_TYPE_NULL              RDB_K_SUB_TYPE_NULL
#define RDB$K_SUB_TYPE_LABEL             RDB_K_SUB_TYPE_LABEL
#define RDB$K_SUB_TYPE_DBKEY             RDB_K_SUB_TYPE_DBKEY
#define RDB$K_SUB_TYPE_CURRENT_USER      RDB_K_SUB_TYPE_CURRENT_USER
#define RDB$K_SUB_TYPE_SESSION_USER      RDB_K_SUB_TYPE_SESSION_USER
#define RDB$K_SUB_TYPE_SYSTEM_USER       RDB_K_SUB_TYPE_SYSTEM_USER
#define RDB$K_SUB_TYPE_CURRENT_UID       RDB_K_SUB_TYPE_CURRENT_UID
#define RDB$K_SUB_TYPE_SESSION_UID       RDB_K_SUB_TYPE_SESSION_UID
#define RDB$K_SUB_TYPE_SYSTEM_UID        RDB_K_SUB_TYPE_SYSTEM_UID
#define RDB$K_SUB_TYPE_BOOLEAN           RDB_K_SUB_TYPE_BOOLEAN
#define RDB$K_TRIGGERED_ACTION           RDB_K_TRIGGERED_ACTION
#define RDB$K_TRIGGERED_FREQUENCY        RDB_K_TRIGGERED_FREQUENCY
#define RDB$K_TRIGGERED_CONDITION        RDB_K_TRIGGERED_CONDITION
#define RDB$K_TRIGGERED_STATEMENT        RDB_K_TRIGGERED_STATEMENT
#define RDB$K_TRIGGER_ONCE               RDB_K_TRIGGER_ONCE
#define RDB$K_TRIGGER_FOR_EACH_ROW       RDB_K_TRIGGER_FOR_EACH_ROW
#define RDB$K_BEFORE_STORE               RDB_K_BEFORE_STORE
#define RDB$K_BEFORE_ERASE               RDB_K_BEFORE_ERASE
#define RDB$K_BEFORE_MODIFY              RDB_K_BEFORE_MODIFY
#define RDB$K_AFTER_STORE                RDB_K_AFTER_STORE
#define RDB$K_AFTER_ERASE                RDB_K_AFTER_ERASE
#define RDB$K_AFTER_MODIFY               RDB_K_AFTER_MODIFY
#define RDB$K_INSTEAD_OF_STORE           RDB_K_INSTEAD_OF_STORE
#define RDB$K_INSTEAD_OF_ERASE           RDB_K_INSTEAD_OF_ERASE
#define RDB$K_INSTEAD_OF_MODIFY          RDB_K_INSTEAD_OF_MODIFY
#define RDB$K_CON_MATCH_NONE             RDB_K_CON_MATCH_NONE
#define RDB$K_CON_MATCH_ALL              RDB_K_CON_MATCH_ALL
#define RDB$K_CON_CONDITION              RDB_K_CON_CONDITION
#define RDB$K_CON_PRIMARY_KEY            RDB_K_CON_PRIMARY_KEY
#define RDB$K_CON_REFERENTIAL            RDB_K_CON_REFERENTIAL
#define RDB$K_CON_UNIQUE                 RDB_K_CON_UNIQUE
#define RDB$K_CON_VIEW_CHECK             RDB_K_CON_VIEW_CHECK
#define RDB$K_CON_NOT_NULL               RDB_K_CON_NOT_NULL
#define RDB$K_CON_SINGLE_LEVEL           RDB_K_CON_SINGLE_LEVEL
#define RDB$K_CONACT_NONE                RDB_K_CONACT_NONE
#define RDB$K_CONACT_CASCADE             RDB_K_CONACT_CASCADE
#define RDB$K_CONACT_SET_DEFAULT         RDB_K_CONACT_SET_DEFAULT
#define RDB$K_CONACT_SET_NULL            RDB_K_CONACT_SET_NULL
#define RDB$K_DUPLICATES_SORTED          RDB_K_DUPLICATES_SORTED
#define RDB$K_DUPLICATES_COMPRESSED      RDB_K_DUPLICATES_COMPRESSED
#define RDB$K_REQTYPE_OTHER              RDB_K_REQTYPE_OTHER
#define RDB$K_REQTYPE_USER_REQUEST       RDB_K_REQTYPE_USER_REQUEST
#define RDB$K_REQTYPE_PROCEDURE          RDB_K_REQTYPE_PROCEDURE
#define RDB$K_REQTYPE_FUNCTION           RDB_K_REQTYPE_FUNCTION
#define RDB$K_REQTYPE_TRIGGER            RDB_K_REQTYPE_TRIGGER
#define RDB$K_REQTYPE_CONSTRAINT         RDB_K_REQTYPE_CONSTRAINT
#define BLR$K_VERSION2                   BLR_K_VERSION2
#define BLR$K_VERSION3                   BLR_K_VERSION3
#define BLR$K_VERSION4                   BLR_K_VERSION4
#define BLR$K_MIN                        BLR_K_MIN
#define BLR$K_VERB_MIN                   BLR_K_VERB_MIN
#define BLR$K_ASSIGNMENT                 BLR_K_ASSIGNMENT
#define BLR$K_TRANSFER                   BLR_K_TRANSFER
#define BLR$K_BEGIN                      BLR_K_BEGIN
#define BLR$K_DCL_VARIABLE               BLR_K_DCL_VARIABLE
#define BLR$K_DCL_PORT                   BLR_K_DCL_PORT
#define BLR$K_MESSAGE                    BLR_K_MESSAGE
#define BLR$K_DECLARE_PORT               BLR_K_DECLARE_PORT
#define BLR$K_ERASE                      BLR_K_ERASE
#define BLR$K_FETCH                      BLR_K_FETCH
#define BLR$K_FOR                        BLR_K_FOR
#define BLR$K_IF                         BLR_K_IF
#define BLR$K_LOOP                       BLR_K_LOOP
#define BLR$K_MODIFY                     BLR_K_MODIFY
#define BLR$K_HANDLER                    BLR_K_HANDLER
#define BLR$K_RECEIVE                    BLR_K_RECEIVE
#define BLR$K_SELECT                     BLR_K_SELECT
#define BLR$K_SEND                       BLR_K_SEND
#define BLR$K_STORE                      BLR_K_STORE
#define BLR$K_WHILE                      BLR_K_WHILE
#define BLR$K_LABEL                      BLR_K_LABEL
#define BLR$K_LEAVE                      BLR_K_LEAVE
#define BLR$K_STORE2                     BLR_K_STORE2
#define BLR$K_PLACE                      BLR_K_PLACE
#define BLR$K_VERB_MAX                   BLR_K_VERB_MAX
#define BLR$K_VALUE_MIN                  BLR_K_VALUE_MIN
#define BLR$K_LITERAL                    BLR_K_LITERAL
#define BLR$K_DBKEY                      BLR_K_DBKEY
#define BLR$K_FIELD                      BLR_K_FIELD
#define BLR$K_FIELD_ID                   BLR_K_FIELD_ID
#define BLR$K_PARAMETER                  BLR_K_PARAMETER
#define BLR$K_VARIABLE                   BLR_K_VARIABLE
#define BLR$K_AVERAGE                    BLR_K_AVERAGE
#define BLR$K_COUNT                      BLR_K_COUNT
#define BLR$K_MAXIMUM                    BLR_K_MAXIMUM
#define BLR$K_MINIMUM                    BLR_K_MINIMUM
#define BLR$K_TOTAL                      BLR_K_TOTAL
#define BLR$K_STDDEV                     BLR_K_STDDEV
#define BLR$K_SMAX                       BLR_K_SMAX
#define BLR$K_VARIANCE                   BLR_K_VARIANCE
#define BLR$K_SMIN                       BLR_K_SMIN
#define BLR$K_ADD                        BLR_K_ADD
#define BLR$K_SUBTRACT                   BLR_K_SUBTRACT
#define BLR$K_MULTIPLY                   BLR_K_MULTIPLY
#define BLR$K_DIVIDE                     BLR_K_DIVIDE
#define BLR$K_NEGATE                     BLR_K_NEGATE
#define BLR$K_CONCATENATE                BLR_K_CONCATENATE
#define BLR$K_SUBSTR                     BLR_K_SUBSTR
#define BLR$K_PARAMETER2                 BLR_K_PARAMETER2
#define BLR$K_FROM                       BLR_K_FROM
#define BLR$K_VIA                        BLR_K_VIA
#define BLR$K_VALUE_MAX                  BLR_K_VALUE_MAX
#define BLR$K_EXCEPT                     BLR_K_EXCEPT
#define BLR$K_PAREN                      BLR_K_PAREN
#define BLR$K_INTERSECT                  BLR_K_INTERSECT
#define BLR$K_COLON                      BLR_K_COLON
#define BLR$K_ARGUMENT                   BLR_K_ARGUMENT
#define BLR$K_PLUS                       BLR_K_PLUS
#define BLR$K_MINUS                      BLR_K_MINUS
#define BLR$K_TIMES                      BLR_K_TIMES
#define BLR$K_EQUIVALENT                 BLR_K_EQUIVALENT
#define BLR$K_BOOL_MIN                   BLR_K_BOOL_MIN
#define BLR$K_EQL                        BLR_K_EQL
#define BLR$K_NEQ                        BLR_K_NEQ
#define BLR$K_GTR                        BLR_K_GTR
#define BLR$K_GEQ                        BLR_K_GEQ
#define BLR$K_LSS                        BLR_K_LSS
#define BLR$K_LEQ                        BLR_K_LEQ
#define BLR$K_CONTAINING                 BLR_K_CONTAINING
#define BLR$K_MATCHES                    BLR_K_MATCHES
#define BLR$K_STARTS                     BLR_K_STARTS
#define BLR$K_BETWEEN                    BLR_K_BETWEEN
#define BLR$K_OR                         BLR_K_OR
#define BLR$K_AND                        BLR_K_AND
#define BLR$K_NOT                        BLR_K_NOT
#define BLR$K_ANY                        BLR_K_ANY
#define BLR$K_MISSING                    BLR_K_MISSING
#define BLR$K_UNIQUE                     BLR_K_UNIQUE
#define BLR$K_IDENTITY                   BLR_K_IDENTITY
#define BLR$K_LIKE                       BLR_K_LIKE
#define BLR$K_ANY2                       BLR_K_ANY2
#define BLR$K_ALL                        BLR_K_ALL
#define BLR$K_BOOL_MAX                   BLR_K_BOOL_MAX
#define BLR$K_RSE                        BLR_K_RSE
#define BLR$K_RSE_MIN                    BLR_K_RSE_MIN
#define BLR$K_FIRST                      BLR_K_FIRST
#define BLR$K_PROJECT                    BLR_K_PROJECT
#define BLR$K_SORT                       BLR_K_SORT
#define BLR$K_BOOLEAN                    BLR_K_BOOLEAN
#define BLR$K_RSE_MAX                    BLR_K_RSE_MAX
#define BLR$K_ASCENDING                  BLR_K_ASCENDING
#define BLR$K_DESCENDING                 BLR_K_DESCENDING
#define BLR$K_SORTS                      BLR_K_SORTS
#define BLR$K_FIELDS                     BLR_K_FIELDS
#define BLR$K_RELATION                   BLR_K_RELATION
#define BLR$K_RELATION_ID                BLR_K_RELATION_ID
#define BLR$K_EOC                        BLR_K_EOC
#define BLR$K_MAX                        BLR_K_MAX
#define BLR$K_AGGREGATE                  BLR_K_AGGREGATE
#define BLR$K_AGG_AVERAGE                BLR_K_AGG_AVERAGE
#define BLR$K_AGG_COUNT                  BLR_K_AGG_COUNT
#define BLR$K_AGG_MAX                    BLR_K_AGG_MAX
#define BLR$K_AGG_MAXIMUM                BLR_K_AGG_MAXIMUM
#define BLR$K_AGG_MIN                    BLR_K_AGG_MIN
#define BLR$K_AGG_MINIMUM                BLR_K_AGG_MINIMUM
#define BLR$K_AGG_TOTAL                  BLR_K_AGG_TOTAL
#define BLR$K_CONTROL_BITS               BLR_K_CONTROL_BITS
#define BLR$K_GROUP_BY                   BLR_K_GROUP_BY
#define BLR$K_GROUP_VALUE                BLR_K_GROUP_VALUE
#define BLR$K_MAP                        BLR_K_MAP
#define BLR$K_MERGE                      BLR_K_MERGE
#define BLR$K_PARAMETER3                 BLR_K_PARAMETER3
#define BLR$K_USER                       BLR_K_USER
#define BLR$K_SUBSTR2                    BLR_K_SUBSTR2
#define BLR$K_TIMESTAMP                  BLR_K_TIMESTAMP
#define BLR$K_ERROR                      BLR_K_ERROR
#define BLR$K_NULL                       BLR_K_NULL
#define BLR$K_STATEMENT                  BLR_K_STATEMENT
#define BLR$K_CURRENT_TIMESTAMP          BLR_K_CURRENT_TIMESTAMP
#define BLR$K_CURRENT_TIME               BLR_K_CURRENT_TIME
#define BLR$K_CURRENT_DATE               BLR_K_CURRENT_DATE
#define BLR$K_CAST                       BLR_K_CAST
#define BLR$K_DESCRIPTOR                 BLR_K_DESCRIPTOR
#define BLR$K_EXTRACT                    BLR_K_EXTRACT
#define BLR$K_GLOBAL_FIELD               BLR_K_GLOBAL_FIELD
#define BLR$K_SUBSTR3                    BLR_K_SUBSTR3
#define BLR$K_TRANSLATE                  BLR_K_TRANSLATE
#define BLR$K_CASE                       BLR_K_CASE
#define BLR$K_TRANSACTION                BLR_K_TRANSACTION
#define BLR$K_TRACE                      BLR_K_TRACE
#define BLR$K_GET_INFO                   BLR_K_GET_INFO
#define BLR$K_FUNCTION                   BLR_K_FUNCTION
#define BLR$K_JOIN                       BLR_K_JOIN
#define BLR$K_CONTEXT                    BLR_K_CONTEXT
#define BLR$K_PARAMETER4                 BLR_K_PARAMETER4
#define BLR$K_VALUE_LIST                 BLR_K_VALUE_LIST
#define BLR$K_DATA_SET                   BLR_K_DATA_SET
#define BLR$K_POSITION                   BLR_K_POSITION
#define BLR$K_SUBSTATEMENT               BLR_K_SUBSTATEMENT
#define BLR$K_DCL_VARIABLE2              BLR_K_DCL_VARIABLE2
#define BLR$K_TRIM                       BLR_K_TRIM
#define BLR$K_FUNCTION_RESULT            BLR_K_FUNCTION_RESULT
#define BLR$K_GLOBAL_VARIABLE            BLR_K_GLOBAL_VARIABLE
#define BLR$K_MAP2                       BLR_K_MAP2
#define BLR$K_AGG_VARIANCE               BLR_K_AGG_VARIANCE
#define BLR$K_AGG_STDDEV                 BLR_K_AGG_STDDEV
#define BLR$K_OVERLAY                    BLR_K_OVERLAY
#define BLR$K_ROW_TSN                    BLR_K_ROW_TSN
#define BLR$K_ROW_NUMBER                 BLR_K_ROW_NUMBER
#define BLR$K_TRUE                       BLR_K_TRUE
#define BLR$K_FALSE                      BLR_K_FALSE
#define BLR$K_UNKNOWN                    BLR_K_UNKNOWN
#define BLR$K_REPLACE                    BLR_K_REPLACE
#define BLR$K_REPLACE2                   BLR_K_REPLACE2
#define BLR$K_END                        BLR_K_END
#define RDB$M_STAT_RETURN_NULL           RDB_M_STAT_RETURN_NULL
#define RDB$M_STAT_VAR_SAMPLE            RDB_M_STAT_VAR_SAMPLE
#define RDB$M_UNIQ_ALLOW_EMPTY           RDB_M_UNIQ_ALLOW_EMPTY
#define RDB$M_VIA_NO_RECORDS             RDB_M_VIA_NO_RECORDS
#define RDB$M_VIA_MORE_THAN_ONE_RECORD   RDB_M_VIA_MORE_THAN_ONE_RECORD
#define RDB$M_VALIDATE_CONCATENATE       RDB_M_VALIDATE_CONCATENATE
#define RDB$M_UPDACT_ONE_ROW             RDB_M_UPDACT_ONE_ROW
#define RDB$M_UPDACT_NO_TRIGS            RDB_M_UPDACT_NO_TRIGS
#define RDB$M_UPDACT_NO_CONSTR           RDB_M_UPDACT_NO_CONSTR
#define RDB$M_UPDACT_AUTO_OVERRIDE       RDB_M_UPDACT_AUTO_OVERRIDE
#define RDB$M_UPDATE_CURSOR              RDB_M_UPDATE_CURSOR
#define RDB$M_SINGLETON_SELECT           RDB_M_SINGLETON_SELECT
#define RDB$M_FOR_UPDATE_ONLY            RDB_M_FOR_UPDATE_ONLY
#define RDB$M_SEARCHED_UPDATE            RDB_M_SEARCHED_UPDATE
#define RDB$M_SEARCHED_DELETE            RDB_M_SEARCHED_DELETE
#define RDB$M_LOOPED_INSERT              RDB_M_LOOPED_INSERT
#define RDB$M_FETCH_NOWAIT               RDB_M_FETCH_NOWAIT
#define RDB$M_MERGE_LOOP                 RDB_M_MERGE_LOOP
#define RDB$M_VAR_NOT_UPDATABLE          RDB_M_VAR_NOT_UPDATABLE
#define RDB$M_RTN_INTRINSIC              RDB_M_RTN_INTRINSIC
#define RDB$M_OVER_USE_CHARACTERS        RDB_M_OVER_USE_CHARACTERS
#define RDB$M_OVER_ORA_SEMANTICS         RDB_M_OVER_ORA_SEMANTICS
#define RDB$M_BIT_SUBSTRING              RDB_M_BIT_SUBSTRING
#define RDB$M_NON_PAD_STR_COMPARE        RDB_M_NON_PAD_STR_COMPARE
#define RDB$M_XLATE_CHAR_SUBS            RDB_M_XLATE_CHAR_SUBS
#define RDB$M_LIKE_REGULAR_EXPR          RDB_M_LIKE_REGULAR_EXPR
#define RDB$M_LIKE_IGNORE_CASE           RDB_M_LIKE_IGNORE_CASE
#define RDB$K_UPDACT_ONE_ROW             RDB_K_UPDACT_ONE_ROW
#define RDB$K_UPDACT_NO_TRIGS            RDB_K_UPDACT_NO_TRIGS
#define RDB$K_INF_MIN                    RDB_K_INF_MIN
#define RDB$K_INF_SQLSTATE               RDB_K_INF_SQLSTATE
#define RDB$K_INF_SQLCODE                RDB_K_INF_SQLCODE
#define RDB$K_INF_ACTIVE_ROWCOUNT        RDB_K_INF_ACTIVE_ROWCOUNT
#define RDB$K_INF_TXN_TYPE               RDB_K_INF_TXN_TYPE
#define RDB$K_INF_ISOLATION              RDB_K_INF_ISOLATION
#define RDB$K_INF_ROWCOUNT               RDB_K_INF_ROWCOUNT
#define RDB$K_INF_COMMIT_TXN_COUNT       RDB_K_INF_COMMIT_TXN_COUNT
#define RDB$K_INF_ROLLBACK_TXN_COUNT     RDB_K_INF_ROLLBACK_TXN_COUNT
#define RDB$K_INF_TXN_ACTIVE             RDB_K_INF_TXN_ACTIVE
#define RDB$K_INF_TXN_DISTRIBUTED        RDB_K_INF_TXN_DISTRIBUTED
#define RDB$K_INF_CURRENT_USER           RDB_K_INF_CURRENT_USER
#define RDB$K_INF_SESSION_USER           RDB_K_INF_SESSION_USER
#define RDB$K_INF_SYSTEM_USER            RDB_K_INF_SYSTEM_USER
#define RDB$K_INF_COLUMN_DEFAULT         RDB_K_INF_COLUMN_DEFAULT
#define RDB$K_INF_CONNECTION_NAME        RDB_K_INF_CONNECTION_NAME
#define RDB$K_INF_CALLING_ROUTINE        RDB_K_INF_CALLING_ROUTINE
#define RDB$K_INF_CURRENT_SEQUENCE       RDB_K_INF_CURRENT_SEQUENCE
#define RDB$K_INF_NEXT_SEQUENCE          RDB_K_INF_NEXT_SEQUENCE
#define RDB$K_INF_PARAMETER_DEFAULT      RDB_K_INF_PARAMETER_DEFAULT
#define RDB$K_INF_CURRENT_UID            RDB_K_INF_CURRENT_UID
#define RDB$K_INF_SESSION_UID            RDB_K_INF_SESSION_UID
#define RDB$K_INF_SYSTEM_UID             RDB_K_INF_SYSTEM_UID
#define RDB$K_INF_TXN_TIMESTAMP          RDB_K_INF_TXN_TIMESTAMP
#define RDB$K_INF_TXN_TSN                RDB_K_INF_TXN_TSN
#define RDB$K_INF_HS_MODE                RDB_K_INF_HS_MODE
#define RDB$K_INF_SERVER_IDENT           RDB_K_INF_SERVER_IDENT
#define RDB$K_INF_TXN_CHANGES            RDB_K_INF_TXN_CHANGES
#define RDB$K_INF_IMAGE_NAME             RDB_K_INF_IMAGE_NAME
#define RDB$K_INF_QG_ROW_LIMIT           RDB_K_INF_QG_ROW_LIMIT
#define RDB$K_INF_QG_CPU_TIME            RDB_K_INF_QG_CPU_TIME
#define RDB$K_INF_QG_ELAPSED_TIME        RDB_K_INF_QG_ELAPSED_TIME
#define RDB$K_INF_TRACE_ENABLED          RDB_K_INF_TRACE_ENABLED
#define RDB$K_INF_TTBL_COLUMN_DEFAULT    RDB_K_INF_TTBL_COLUMN_DEFAULT
#define RDB$K_INF_INSERT_ROWCOUNT        RDB_K_INF_INSERT_ROWCOUNT
#define RDB$K_INF_UPDATE_ROWCOUNT        RDB_K_INF_UPDATE_ROWCOUNT
#define RDB$K_INF_MAX                    RDB_K_INF_MAX
#define RDB$M_TRIM_LEADING               RDB_M_TRIM_LEADING
#define RDB$M_TRIM_TRAILING              RDB_M_TRIM_TRAILING
#define RDB$M_TRIM_BOTH                  RDB_M_TRIM_BOTH
#define RDB$M_HOLD_NONE                  RDB_M_HOLD_NONE
#define RDB$M_HOLD_COMMIT                RDB_M_HOLD_COMMIT
#define RDB$M_HOLD_ROLLBACK              RDB_M_HOLD_ROLLBACK
#define RDB$M_HOLD_ALL                   RDB_M_HOLD_ALL
#define RDB$K_CN_FLAGS_CONSTR_DISABLED   RDB_K_CN_FLAGS_CONSTR_DISABLED
#define RDB$K_CN_FLAGS_CONSTR_UNCHECKED  RDB_K_CN_FLAGS_CONSTR_UNCHECKED
#define RDB$K_CN_FLAGS_CONSTR_GEN_NAME   RDB_K_CN_FLAGS_CONSTR_GEN_NAME
#define RDB$K_CN_FLAGS_NOT_NULL          RDB_K_CN_FLAGS_NOT_NULL
#define RDB$K_CN_FLAGS_PRIMARY_KEY       RDB_K_CN_FLAGS_PRIMARY_KEY
#define RDB$K_CN_FLAGS_REFERENTIAL       RDB_K_CN_FLAGS_REFERENTIAL
#define RDB$K_CN_FLAGS_CONDITION         RDB_K_CN_FLAGS_CONDITION
#define RDB$K_CN_FLAGS_UNIQUE            RDB_K_CN_FLAGS_UNIQUE
#define RDB$M_CN_FLAGS_CONSTR_DISABLED   RDB_M_CN_FLAGS_CONSTR_DISABLED
#define RDB$M_CN_FLAGS_CONSTR_UNCHECKED  RDB_M_CN_FLAGS_CONSTR_UNCHECKED
#define RDB$M_CN_FLAGS_CONSTR_GEN_NAME   RDB_M_CN_FLAGS_CONSTR_GEN_NAME
#define RDB$M_CN_FLAGS_NOT_NULL          RDB_M_CN_FLAGS_NOT_NULL
#define RDB$M_CN_FLAGS_PRIMARY_KEY       RDB_M_CN_FLAGS_PRIMARY_KEY
#define RDB$M_CN_FLAGS_REFERENTIAL       RDB_M_CN_FLAGS_REFERENTIAL
#define RDB$M_CN_FLAGS_CONDITION         RDB_M_CN_FLAGS_CONDITION
#define RDB$M_CN_FLAGS_UNIQUE            RDB_M_CN_FLAGS_UNIQUE
#define RDB$K_DB_FLAGS_DICT_REQUIRED     RDB_K_DB_FLAGS_DICT_REQUIRED
#define RDB$K_DB_FLAGS_ANSI_PROTECTION   RDB_K_DB_FLAGS_ANSI_PROTECTION
#define RDB$K_DB_FLAGS_DICT_DATABASE     RDB_K_DB_FLAGS_DICT_DATABASE
#define RDB$K_DB_FLAGS_SECURE_RDB        RDB_K_DB_FLAGS_SECURE_RDB
#define RDB$K_DB_FLAGS_INTEGRITY         RDB_K_DB_FLAGS_INTEGRITY
#define RDB$K_DB_FLAGS_SINGLE_LEVEL      RDB_K_DB_FLAGS_SINGLE_LEVEL
#define RDB$K_DB_FLAGS_MULTISCHEMA       RDB_K_DB_FLAGS_MULTISCHEMA
#define RDB$K_DB_FLAGS_MAC_POLICY_DISAB  RDB_K_DB_FLAGS_MAC_POLICY_DISAB
#define RDB$K_DB_FLAGS_NDX_COMPRESSED    RDB_K_DB_FLAGS_NDX_COMPRESSED
#define RDB$K_DB_FLAGS_COLLECT_WORKLOAD  RDB_K_DB_FLAGS_COLLECT_WORKLOAD
#define RDB$K_DB_FLAGS_CARDUPD_DISABLED  RDB_K_DB_FLAGS_CARDUPD_DISABLED
#define RDB$K_DB_FLAGS_DDL_DISABLED      RDB_K_DB_FLAGS_DDL_DISABLED
#define RDB$K_DB_FLAGS_SEC_INTERNAL      RDB_K_DB_FLAGS_SEC_INTERNAL
#define RDB$K_DB_FLAGS_VALIDATE_SID      RDB_K_DB_FLAGS_VALIDATE_SID
#define RDB$K_DB_FLAGS_OBJECT_SYNONYMS   RDB_K_DB_FLAGS_OBJECT_SYNONYMS
#define RDB$K_DB_FLAGS_NDXPCRD_DISABLED  RDB_K_DB_FLAGS_NDXPCRD_DISABLED
#define RDB$K_DB_FLAGS_NDX_PREFIX_ALL    RDB_K_DB_FLAGS_NDX_PREFIX_ALL
#define RDB$K_DB_FLAGS_NDX_RANKED        RDB_K_DB_FLAGS_NDX_RANKED
#define RDB$M_DB_FLAGS_DICT_REQUIRED     RDB_M_DB_FLAGS_DICT_REQUIRED
#define RDB$M_DB_FLAGS_ANSI_PROTECTION   RDB_M_DB_FLAGS_ANSI_PROTECTION
#define RDB$M_DB_FLAGS_DICT_DATABASE     RDB_M_DB_FLAGS_DICT_DATABASE
#define RDB$M_DB_FLAGS_SECURE_RDB        RDB_M_DB_FLAGS_SECURE_RDB
#define RDB$M_DB_FLAGS_INTEGRITY         RDB_M_DB_FLAGS_INTEGRITY
#define RDB$M_DB_FLAGS_SINGLE_LEVEL      RDB_M_DB_FLAGS_SINGLE_LEVEL
#define RDB$M_DB_FLAGS_MULTISCHEMA       RDB_M_DB_FLAGS_MULTISCHEMA
#define RDB$M_DB_FLAGS_MAC_POLICY_DISAB  RDB_M_DB_FLAGS_MAC_POLICY_DISAB
#define RDB$M_DB_FLAGS_NDX_COMPRESSED    RDB_M_DB_FLAGS_NDX_COMPRESSED
#define RDB$M_DB_FLAGS_COLLECT_WORKLOAD  RDB_M_DB_FLAGS_COLLECT_WORKLOAD
#define RDB$M_DB_FLAGS_CARDUPD_DISABLED  RDB_M_DB_FLAGS_CARDUPD_DISABLED
#define RDB$M_DB_FLAGS_DDL_DISABLED      RDB_M_DB_FLAGS_DDL_DISABLED
#define RDB$M_DB_FLAGS_SEC_INTERNAL      RDB_M_DB_FLAGS_SEC_INTERNAL
#define RDB$M_DB_FLAGS_VALIDATE_SID      RDB_M_DB_FLAGS_VALIDATE_SID
#define RDB$M_DB_FLAGS_OBJECT_SYNONYMS   RDB_M_DB_FLAGS_OBJECT_SYNONYMS
#define RDB$M_DB_FLAGS_NDXPCRD_DISABLED  RDB_M_DB_FLAGS_NDXPCRD_DISABLED
#define RDB$M_DB_FLAGS_NDX_PREFIX_ALL    RDB_M_DB_FLAGS_NDX_PREFIX_ALL
#define RDB$M_DB_FLAGS_NDX_RANKED        RDB_M_DB_FLAGS_NDX_RANKED
#define RDB$K_IX_FLAGS_HASHED            RDB_K_IX_FLAGS_HASHED
#define RDB$K_IX_FLAGS_MV_COMPRESSED     RDB_K_IX_FLAGS_MV_COMPRESSED
#define RDB$K_IX_FLAGS_HASHED_ORDERED    RDB_K_IX_FLAGS_HASHED_ORDERED
#define RDB$K_IX_FLAGS_HASHED_USER       RDB_K_IX_FLAGS_HASHED_USER
#define RDB$K_IX_FLAGS_RL_COMPRESSED     RDB_K_IX_FLAGS_RL_COMPRESSED
#define RDB$K_IX_FLAGS_DISABLED          RDB_K_IX_FLAGS_DISABLED
#define RDB$K_IX_FLAGS_BUILD_PENDING     RDB_K_IX_FLAGS_BUILD_PENDING
#define RDB$K_IX_FLAGS_INDEX_ONLY        RDB_K_IX_FLAGS_INDEX_ONLY
#define RDB$K_IX_FLAGS_SUB_INDEX         RDB_K_IX_FLAGS_SUB_INDEX
#define RDB$K_IX_FLAGS_DUP_SORTED        RDB_K_IX_FLAGS_DUP_SORTED
#define RDB$K_IX_FLAGS_TEMP_TBL_INDEX    RDB_K_IX_FLAGS_TEMP_TBL_INDEX
#define RDB$K_IX_FLAGS_DUP_COMPRESSED    RDB_K_IX_FLAGS_DUP_COMPRESSED
#define RDB$K_IX_FLAGS_PSEUDO_RANKED     RDB_K_IX_FLAGS_PSEUDO_RANKED
#define RDB$K_IX_FLAGS_COLLECT_DISABLED  RDB_K_IX_FLAGS_COLLECT_DISABLED
#define RDB$K_IX_FLAGS_PREFIX_FULL       RDB_K_IX_FLAGS_PREFIX_FULL
#define RDB$K_IX_FLAGS_CONSTRAINT_INDEX  RDB_K_IX_FLAGS_CONSTRAINT_INDEX
#define RDB$K_IX_FLAGS_CODE_LEVEL1       RDB_K_IX_FLAGS_CODE_LEVEL1
#define RDB$M_IX_FLAGS_HASHED            RDB_M_IX_FLAGS_HASHED
#define RDB$M_IX_FLAGS_MV_COMPRESSED     RDB_M_IX_FLAGS_MV_COMPRESSED
#define RDB$M_IX_FLAGS_HASHED_ORDERED    RDB_M_IX_FLAGS_HASHED_ORDERED
#define RDB$M_IX_FLAGS_HASHED_USER       RDB_M_IX_FLAGS_HASHED_USER
#define RDB$M_IX_FLAGS_RL_COMPRESSED     RDB_M_IX_FLAGS_RL_COMPRESSED
#define RDB$M_IX_FLAGS_DISABLED          RDB_M_IX_FLAGS_DISABLED
#define RDB$M_IX_FLAGS_BUILD_PENDING     RDB_M_IX_FLAGS_BUILD_PENDING
#define RDB$M_IX_FLAGS_INDEX_ONLY        RDB_M_IX_FLAGS_INDEX_ONLY
#define RDB$M_IX_FLAGS_SUB_INDEX         RDB_M_IX_FLAGS_SUB_INDEX
#define RDB$M_IX_FLAGS_DUP_SORTED        RDB_M_IX_FLAGS_DUP_SORTED
#define RDB$M_IX_FLAGS_TEMP_TBL_INDEX    RDB_M_IX_FLAGS_TEMP_TBL_INDEX
#define RDB$M_IX_FLAGS_DUP_COMPRESSED    RDB_M_IX_FLAGS_DUP_COMPRESSED
#define RDB$M_IX_FLAGS_PSEUDO_RANKED     RDB_M_IX_FLAGS_PSEUDO_RANKED
#define RDB$M_IX_FLAGS_COLLECT_DISABLED  RDB_M_IX_FLAGS_COLLECT_DISABLED
#define RDB$M_IX_FLAGS_PREFIX_FULL       RDB_M_IX_FLAGS_PREFIX_FULL
#define RDB$M_IX_FLAGS_CONSTRAINT_INDEX  RDB_M_IX_FLAGS_CONSTRAINT_INDEX
#define RDB$M_IX_FLAGS_CODE_LEVEL1       RDB_M_IX_FLAGS_CODE_LEVEL1
#define RDB$K_IX_FLAGS_DEFERRED          RDB_K_IX_FLAGS_DEFERRED
#define RDB$M_IX_FLAGS_DEFERRED          RDB_M_IX_FLAGS_DEFERRED
#define RDB$K_IK_FLAGS_DESCENDING        RDB_K_IK_FLAGS_DESCENDING
#define RDB$M_IK_FLAGS_DESCENDING        RDB_M_IK_FLAGS_DESCENDING
#define RDB$K_RL_FLAGS_VIEW              RDB_K_RL_FLAGS_VIEW
#define RDB$K_RL_FLAGS_COMP_DISABLED     RDB_K_RL_FLAGS_COMP_DISABLED
#define RDB$K_RL_FLAGS_VIEW_CHECK        RDB_K_RL_FLAGS_VIEW_CHECK
#define RDB$K_RL_FLAGS_INTERNAL          RDB_K_RL_FLAGS_INTERNAL
#define RDB$K_RL_FLAGS_NOT_ANSI_UPDATE   RDB_K_RL_FLAGS_NOT_ANSI_UPDATE
#define RDB$K_RL_FLAGS_IMPORTED_TABLE    RDB_K_RL_FLAGS_IMPORTED_TABLE
#define RDB$K_RL_FLAGS_PASSTHRU_TABLE    RDB_K_RL_FLAGS_PASSTHRU_TABLE
#define RDB$K_RL_FLAGS_PARTITION_VIEW    RDB_K_RL_FLAGS_PARTITION_VIEW
#define RDB$K_RL_FLAGS_USE_MAP_COMP      RDB_K_RL_FLAGS_USE_MAP_COMP
#define RDB$K_RL_FLAGS_TEMP_TABLE        RDB_K_RL_FLAGS_TEMP_TABLE
#define RDB$K_RL_FLAGS_GLOBAL_TEMP_TBL   RDB_K_RL_FLAGS_GLOBAL_TEMP_TBL
#define RDB$K_RL_FLAGS_DELETE_ON_COMMIT  RDB_K_RL_FLAGS_DELETE_ON_COMMIT
#define RDB$K_RL_FLAGS_INDEX_ONLY        RDB_K_RL_FLAGS_INDEX_ONLY
#define RDB$K_RL_FLAGS_REF_TO_LOCAL_TT   RDB_K_RL_FLAGS_REF_TO_LOCAL_TT
#define RDB$K_RL_FLAGS_INFO_TABLE        RDB_K_RL_FLAGS_INFO_TABLE
#define RDB$K_RL_FLAGS_MAPPED_SYSREL     RDB_K_RL_FLAGS_MAPPED_SYSREL
#define RDB$K_RL_FLAGS_ONLY_TT_MAIN_CTX  RDB_K_RL_FLAGS_ONLY_TT_MAIN_CTX
#define RDB$K_RL_FLAGS_HIDDEN            RDB_K_RL_FLAGS_HIDDEN
#define RDB$K_RL_FLAGS_LARGE_MEMORY      RDB_K_RL_FLAGS_LARGE_MEMORY
#define RDB$M_RL_FLAGS_VIEW              RDB_M_RL_FLAGS_VIEW
#define RDB$M_RL_FLAGS_COMP_DISABLED     RDB_M_RL_FLAGS_COMP_DISABLED
#define RDB$M_RL_FLAGS_VIEW_CHECK        RDB_M_RL_FLAGS_VIEW_CHECK
#define RDB$M_RL_FLAGS_INTERNAL          RDB_M_RL_FLAGS_INTERNAL
#define RDB$M_RL_FLAGS_NOT_ANSI_UPDATE   RDB_M_RL_FLAGS_NOT_ANSI_UPDATE
#define RDB$M_RL_FLAGS_IMPORTED_TABLE    RDB_M_RL_FLAGS_IMPORTED_TABLE
#define RDB$M_RL_FLAGS_PASSTHRU_TABLE    RDB_M_RL_FLAGS_PASSTHRU_TABLE
#define RDB$M_RL_FLAGS_PARTITION_VIEW    RDB_M_RL_FLAGS_PARTITION_VIEW
#define RDB$M_RL_FLAGS_USE_MAP_COMP      RDB_M_RL_FLAGS_USE_MAP_COMP
#define RDB$M_RL_FLAGS_TEMP_TABLE        RDB_M_RL_FLAGS_TEMP_TABLE
#define RDB$M_RL_FLAGS_GLOBAL_TEMP_TBL   RDB_M_RL_FLAGS_GLOBAL_TEMP_TBL
#define RDB$M_RL_FLAGS_DELETE_ON_COMMIT  RDB_M_RL_FLAGS_DELETE_ON_COMMIT
#define RDB$M_RL_FLAGS_INDEX_ONLY        RDB_M_RL_FLAGS_INDEX_ONLY
#define RDB$M_RL_FLAGS_REF_TO_LOCAL_TT   RDB_M_RL_FLAGS_REF_TO_LOCAL_TT
#define RDB$M_RL_FLAGS_INFO_TABLE        RDB_M_RL_FLAGS_INFO_TABLE
#define RDB$M_RL_FLAGS_MAPPED_SYSREL     RDB_M_RL_FLAGS_MAPPED_SYSREL
#define RDB$M_RL_FLAGS_ONLY_TT_MAIN_CTX  RDB_M_RL_FLAGS_ONLY_TT_MAIN_CTX
#define RDB$M_RL_FLAGS_HIDDEN            RDB_M_RL_FLAGS_HIDDEN
#define RDB$M_RL_FLAGS_LARGE_MEMORY      RDB_M_RL_FLAGS_LARGE_MEMORY
#define RDB$K_OT_FLAGS_INVALID           RDB_K_OT_FLAGS_INVALID
#define RDB$M_OT_FLAGS_INVALID           RDB_M_OT_FLAGS_INVALID
#define RDB$K_ML_FLAGS_HIDDEN            RDB_K_ML_FLAGS_HIDDEN
#define RDB$K_ML_FLAGS_SYSTEM            RDB_K_ML_FLAGS_SYSTEM
#define RDB$M_ML_FLAGS_HIDDEN            RDB_M_ML_FLAGS_HIDDEN
#define RDB$M_ML_FLAGS_SYSTEM            RDB_M_ML_FLAGS_SYSTEM
#define RDB$K_RT_FLAGS_FUNCTION          RDB_K_RT_FLAGS_FUNCTION
#define RDB$K_RT_FLAGS_INVALID           RDB_K_RT_FLAGS_INVALID
#define RDB$K_RT_FLAGS_VARIANT           RDB_K_RT_FLAGS_VARIANT
#define RDB$K_RT_FLAGS_CHG_TRANS_STATE   RDB_K_RT_FLAGS_CHG_TRANS_STATE
#define RDB$K_RT_FLAGS_SECURE_LOCATION   RDB_K_RT_FLAGS_SECURE_LOCATION
#define RDB$K_RT_FLAGS_SQL_PARAM_STYLE   RDB_K_RT_FLAGS_SQL_PARAM_STYLE
#define RDB$K_RT_FLAGS_INVALID_LANG_SEM  RDB_K_RT_FLAGS_INVALID_LANG_SEM
#define RDB$K_RT_FLAGS_THREADSAFE        RDB_K_RT_FLAGS_THREADSAFE
#define RDB$K_RT_FLAGS_PROPAGATE_NULL    RDB_K_RT_FLAGS_PROPAGATE_NULL
#define RDB$K_RT_FLAGS_ANALYZED          RDB_K_RT_FLAGS_ANALYZED
#define RDB$K_RT_FLAGS_STORE_ROWS        RDB_K_RT_FLAGS_STORE_ROWS
#define RDB$K_RT_FLAGS_MODIFY_ROWS       RDB_K_RT_FLAGS_MODIFY_ROWS
#define RDB$K_RT_FLAGS_ERASE_ROWS        RDB_K_RT_FLAGS_ERASE_ROWS
#define RDB$K_RT_FLAGS_READS_ROWS        RDB_K_RT_FLAGS_READS_ROWS
#define RDB$K_RT_FLAGS_CALLS_OUT         RDB_K_RT_FLAGS_CALLS_OUT
#define RDB$K_RT_FLAGS_JAVA_PARAM_STYLE  RDB_K_RT_FLAGS_JAVA_PARAM_STYLE
#define RDB$K_RT_FLAGS_PRIVATE           RDB_K_RT_FLAGS_PRIVATE
#define RDB$K_RT_FLAGS_JAVA_BYTECODE     RDB_K_RT_FLAGS_JAVA_BYTECODE
#define RDB$K_RT_FLAGS_HIDDEN            RDB_K_RT_FLAGS_HIDDEN
#define RDB$K_RT_FLAGS_SYSTEM            RDB_K_RT_FLAGS_SYSTEM
#define RDB$K_RT_FLAGS_GENERATED         RDB_K_RT_FLAGS_GENERATED
#define RDB$K_RT_FLAGS_CURSOR_COROUTINE  RDB_K_RT_FLAGS_CURSOR_COROUTINE
#define RDB$M_RT_FLAGS_FUNCTION          RDB_M_RT_FLAGS_FUNCTION
#define RDB$M_RT_FLAGS_INVALID           RDB_M_RT_FLAGS_INVALID
#define RDB$M_RT_FLAGS_VARIANT           RDB_M_RT_FLAGS_VARIANT
#define RDB$M_RT_FLAGS_CHG_TRANS_STATE   RDB_M_RT_FLAGS_CHG_TRANS_STATE
#define RDB$M_RT_FLAGS_SECURE_LOCATION   RDB_M_RT_FLAGS_SECURE_LOCATION
#define RDB$M_RT_FLAGS_SQL_PARAM_STYLE   RDB_M_RT_FLAGS_SQL_PARAM_STYLE
#define RDB$M_RT_FLAGS_INVALID_LANG_SEM  RDB_M_RT_FLAGS_INVALID_LANG_SEM
#define RDB$M_RT_FLAGS_THREADSAFE        RDB_M_RT_FLAGS_THREADSAFE
#define RDB$M_RT_FLAGS_PROPAGATE_NULL    RDB_M_RT_FLAGS_PROPAGATE_NULL
#define RDB$M_RT_FLAGS_ANALYZED          RDB_M_RT_FLAGS_ANALYZED
#define RDB$M_RT_FLAGS_STORE_ROWS        RDB_M_RT_FLAGS_STORE_ROWS
#define RDB$M_RT_FLAGS_MODIFY_ROWS       RDB_M_RT_FLAGS_MODIFY_ROWS
#define RDB$M_RT_FLAGS_ERASE_ROWS        RDB_M_RT_FLAGS_ERASE_ROWS
#define RDB$M_RT_FLAGS_READS_ROWS        RDB_M_RT_FLAGS_READS_ROWS
#define RDB$M_RT_FLAGS_CALLS_OUT         RDB_M_RT_FLAGS_CALLS_OUT
#define RDB$M_RT_FLAGS_JAVA_PARAM_STYLE  RDB_M_RT_FLAGS_JAVA_PARAM_STYLE
#define RDB$M_RT_FLAGS_PRIVATE           RDB_M_RT_FLAGS_PRIVATE
#define RDB$M_RT_FLAGS_JAVA_BYTECODE     RDB_M_RT_FLAGS_JAVA_BYTECODE
#define RDB$M_RT_FLAGS_HIDDEN            RDB_M_RT_FLAGS_HIDDEN
#define RDB$M_RT_FLAGS_SYSTEM            RDB_M_RT_FLAGS_SYSTEM
#define RDB$M_RT_FLAGS_GENERATED         RDB_M_RT_FLAGS_GENERATED
#define RDB$M_RT_FLAGS_CURSOR_COROUTINE  RDB_M_RT_FLAGS_CURSOR_COROUTINE
#define RDB$M_RT_FLAGS_CALL_STATE        RDB_M_RT_FLAGS_CALL_STATE
#define RDB$M_RT_FLAGS_TRIGGER_STATE     RDB_M_RT_FLAGS_TRIGGER_STATE
#define RDB$M_RT_FLAGS_DML_STATE         RDB_M_RT_FLAGS_DML_STATE
#define RDB$K_PF_FLAGS_PROFILE_DISABLED  RDB_K_PF_FLAGS_PROFILE_DISABLED
#define RDB$K_PF_FLAGS_IDENT_EXTERNAL    RDB_K_PF_FLAGS_IDENT_EXTERNAL
#define RDB$K_PF_FLAGS_IDENT_PASSWORD    RDB_K_PF_FLAGS_IDENT_PASSWORD
#define RDB$K_PF_FLAGS_SYSTEM_ROLE       RDB_K_PF_FLAGS_SYSTEM_ROLE
#define RDB$K_PF_FLAGS_ASSIGNED_QUOTA    RDB_K_PF_FLAGS_ASSIGNED_QUOTA
#define RDB$M_PF_FLAGS_PROFILE_DISABLED  RDB_M_PF_FLAGS_PROFILE_DISABLED
#define RDB$M_PF_FLAGS_IDENT_EXTERNAL    RDB_M_PF_FLAGS_IDENT_EXTERNAL
#define RDB$M_PF_FLAGS_IDENT_PASSWORD    RDB_M_PF_FLAGS_IDENT_PASSWORD
#define RDB$M_PF_FLAGS_SYSTEM_ROLE       RDB_M_PF_FLAGS_SYSTEM_ROLE
#define RDB$M_PF_FLAGS_ASSIGNED_QUOTA    RDB_M_PF_FLAGS_ASSIGNED_QUOTA
#define RDB$K_PA_FLAGS_IN                RDB_K_PA_FLAGS_IN
#define RDB$K_PA_FLAGS_OUT               RDB_K_PA_FLAGS_OUT
#define RDB$K_PA_FLAGS_LENGTH            RDB_K_PA_FLAGS_LENGTH
#define RDB$K_PA_FLAGS_DESCRIPTOR        RDB_K_PA_FLAGS_DESCRIPTOR
#define RDB$K_PA_FLAGS_VALUE             RDB_K_PA_FLAGS_VALUE
#define RDB$K_PA_FLAGS_ALIGN             RDB_K_PA_FLAGS_ALIGN
#define RDB$K_PA_FLAGS_MODE_UNDEFINED    RDB_K_PA_FLAGS_MODE_UNDEFINED
#define RDB$K_PA_FLAGS_ACTION_OPEN       RDB_K_PA_FLAGS_ACTION_OPEN
#define RDB$K_PA_FLAGS_ACTION_CLOSE      RDB_K_PA_FLAGS_ACTION_CLOSE
#define RDB$K_PA_FLAGS_ACTION_FETCH      RDB_K_PA_FLAGS_ACTION_FETCH
#define RDB$K_PA_FLAGS_ACTION_DELETE     RDB_K_PA_FLAGS_ACTION_DELETE
#define RDB$K_PA_FLAGS_ACTION_INSERT     RDB_K_PA_FLAGS_ACTION_INSERT
#define RDB$K_PA_FLAGS_ACTION_UPDATE     RDB_K_PA_FLAGS_ACTION_UPDATE
#define RDB$M_PA_FLAGS_IN                RDB_M_PA_FLAGS_IN
#define RDB$M_PA_FLAGS_OUT               RDB_M_PA_FLAGS_OUT
#define RDB$M_PA_FLAGS_INOUT             RDB_M_PA_FLAGS_INOUT
#define RDB$M_PA_FLAGS_LENGTH            RDB_M_PA_FLAGS_LENGTH
#define RDB$M_PA_FLAGS_DESCRIPTOR        RDB_M_PA_FLAGS_DESCRIPTOR
#define RDB$M_PA_FLAGS_VALUE             RDB_M_PA_FLAGS_VALUE
#define RDB$M_PA_FLAGS_ALIGN             RDB_M_PA_FLAGS_ALIGN
#define RDB$M_PA_FLAGS_MODE_UNDEFINED    RDB_M_PA_FLAGS_MODE_UNDEFINED
#define RDB$M_PA_FLAGS_ACTION_OPEN       RDB_M_PA_FLAGS_ACTION_OPEN
#define RDB$M_PA_FLAGS_ACTION_CLOSE      RDB_M_PA_FLAGS_ACTION_CLOSE
#define RDB$M_PA_FLAGS_ACTION_FETCH      RDB_M_PA_FLAGS_ACTION_FETCH
#define RDB$M_PA_FLAGS_ACTION_DELETE     RDB_M_PA_FLAGS_ACTION_DELETE
#define RDB$M_PA_FLAGS_ACTION_INSERT     RDB_M_PA_FLAGS_ACTION_INSERT
#define RDB$M_PA_FLAGS_ACTION_UPDATE     RDB_M_PA_FLAGS_ACTION_UPDATE
#define RDB$K_IR_FLAGS_ENT_MODULE        RDB_K_IR_FLAGS_ENT_MODULE
#define RDB$K_IR_FLAGS_OBJ_MODULE        RDB_K_IR_FLAGS_OBJ_MODULE
#define RDB$K_IR_FLAGS_ENT_ROUTINE       RDB_K_IR_FLAGS_ENT_ROUTINE
#define RDB$K_IR_FLAGS_OBJ_ROUTINE       RDB_K_IR_FLAGS_OBJ_ROUTINE
#define RDB$K_IR_FLAGS_ENT_TRIGGER       RDB_K_IR_FLAGS_ENT_TRIGGER
#define RDB$K_IR_FLAGS_OBJ_TRIGGER       RDB_K_IR_FLAGS_OBJ_TRIGGER
#define RDB$K_IR_FLAGS_ENT_CONSTRAINT    RDB_K_IR_FLAGS_ENT_CONSTRAINT
#define RDB$K_IR_FLAGS_OBJ_CONSTRAINT    RDB_K_IR_FLAGS_OBJ_CONSTRAINT
#define RDB$K_IR_FLAGS_ENT_STORAGE_MAP   RDB_K_IR_FLAGS_ENT_STORAGE_MAP
#define RDB$K_IR_FLAGS_OBJ_STORAGE_MAP   RDB_K_IR_FLAGS_OBJ_STORAGE_MAP
#define RDB$K_IR_FLAGS_ENT_OUTLINE       RDB_K_IR_FLAGS_ENT_OUTLINE
#define RDB$K_IR_FLAGS_OBJ_OUTLINE       RDB_K_IR_FLAGS_OBJ_OUTLINE
#define RDB$K_IR_FLAGS_ENT_TABLE         RDB_K_IR_FLAGS_ENT_TABLE
#define RDB$K_IR_FLAGS_OBJ_TABLE         RDB_K_IR_FLAGS_OBJ_TABLE
#define RDB$K_IR_FLAGS_ENT_SEQUENCE      RDB_K_IR_FLAGS_ENT_SEQUENCE
#define RDB$K_IR_FLAGS_OBJ_SEQUENCE      RDB_K_IR_FLAGS_OBJ_SEQUENCE
#define RDB$K_IR_FLAGS_ENT_VARIABLE      RDB_K_IR_FLAGS_ENT_VARIABLE
#define RDB$K_IR_FLAGS_OBJ_VARIABLE      RDB_K_IR_FLAGS_OBJ_VARIABLE
#define RDB$K_IR_FLAGS_ENT_INDEX         RDB_K_IR_FLAGS_ENT_INDEX
#define RDB$K_IR_FLAGS_OBJ_INDEX         RDB_K_IR_FLAGS_OBJ_INDEX
#define RDB$M_IR_FLAGS_ENT_MODULE        RDB_M_IR_FLAGS_ENT_MODULE
#define RDB$M_IR_FLAGS_OBJ_MODULE        RDB_M_IR_FLAGS_OBJ_MODULE
#define RDB$M_IR_FLAGS_ENT_ROUTINE       RDB_M_IR_FLAGS_ENT_ROUTINE
#define RDB$M_IR_FLAGS_OBJ_ROUTINE       RDB_M_IR_FLAGS_OBJ_ROUTINE
#define RDB$M_IR_FLAGS_ENT_TRIGGER       RDB_M_IR_FLAGS_ENT_TRIGGER
#define RDB$M_IR_FLAGS_OBJ_TRIGGER       RDB_M_IR_FLAGS_OBJ_TRIGGER
#define RDB$M_IR_FLAGS_ENT_CONSTRAINT    RDB_M_IR_FLAGS_ENT_CONSTRAINT
#define RDB$M_IR_FLAGS_OBJ_CONSTRAINT    RDB_M_IR_FLAGS_OBJ_CONSTRAINT
#define RDB$M_IR_FLAGS_ENT_STORAGE_MAP   RDB_M_IR_FLAGS_ENT_STORAGE_MAP
#define RDB$M_IR_FLAGS_OBJ_STORAGE_MAP   RDB_M_IR_FLAGS_OBJ_STORAGE_MAP
#define RDB$M_IR_FLAGS_ENT_OUTLINE       RDB_M_IR_FLAGS_ENT_OUTLINE
#define RDB$M_IR_FLAGS_OBJ_OUTLINE       RDB_M_IR_FLAGS_OBJ_OUTLINE
#define RDB$M_IR_FLAGS_ENT_TABLE         RDB_M_IR_FLAGS_ENT_TABLE
#define RDB$M_IR_FLAGS_OBJ_TABLE         RDB_M_IR_FLAGS_OBJ_TABLE
#define RDB$M_IR_FLAGS_ENT_SEQUENCE      RDB_M_IR_FLAGS_ENT_SEQUENCE
#define RDB$M_IR_FLAGS_OBJ_SEQUENCE      RDB_M_IR_FLAGS_OBJ_SEQUENCE
#define RDB$M_IR_FLAGS_ENT_VARIABLE      RDB_M_IR_FLAGS_ENT_VARIABLE
#define RDB$M_IR_FLAGS_OBJ_VARIABLE      RDB_M_IR_FLAGS_OBJ_VARIABLE
#define RDB$M_IR_FLAGS_ENT_INDEX         RDB_M_IR_FLAGS_ENT_INDEX
#define RDB$M_IR_FLAGS_OBJ_INDEX         RDB_M_IR_FLAGS_OBJ_INDEX
#define RDB$K_SM_FLAGS_MIXED_FORMAT      RDB_K_SM_FLAGS_MIXED_FORMAT
#define RDB$K_SM_FLAGS_DO_NOT_COMPRESS   RDB_K_SM_FLAGS_DO_NOT_COMPRESS
#define RDB$K_SM_FLAGS_NOUPDATE          RDB_K_SM_FLAGS_NOUPDATE
#define RDB$K_SM_FLAGS_DYNAMIC           RDB_K_SM_FLAGS_DYNAMIC
#define RDB$K_SM_FLAGS_NAMED_PARTITION   RDB_K_SM_FLAGS_NAMED_PARTITION
#define RDB$K_SM_FLAGS_PART_UNCHECKED    RDB_K_SM_FLAGS_PART_UNCHECKED
#define RDB$M_SM_FLAGS_MIXED_FORMAT      RDB_M_SM_FLAGS_MIXED_FORMAT
#define RDB$M_SM_FLAGS_DO_NOT_COMPRESS   RDB_M_SM_FLAGS_DO_NOT_COMPRESS
#define RDB$M_SM_FLAGS_NOUPDATE          RDB_M_SM_FLAGS_NOUPDATE
#define RDB$M_SM_FLAGS_DYNAMIC           RDB_M_SM_FLAGS_DYNAMIC
#define RDB$M_SM_FLAGS_NAMED_PARTITION   RDB_M_SM_FLAGS_NAMED_PARTITION
#define RDB$M_SM_FLAGS_PART_UNCHECKED    RDB_M_SM_FLAGS_PART_UNCHECKED
#define RDB$K_MA_FLAGS_SEQ_FILL          RDB_K_MA_FLAGS_SEQ_FILL
#define RDB$K_MA_FLAGS_NAMED_PARTITION   RDB_K_MA_FLAGS_NAMED_PARTITION
#define RDB$K_MA_FLAGS_BUILD_PENDING     RDB_K_MA_FLAGS_BUILD_PENDING
#define RDB$K_MA_FLAGS_CREATE_NOLOGGING  RDB_K_MA_FLAGS_CREATE_NOLOGGING
#define RDB$K_MA_FLAGS_COLLECT_CARD      RDB_K_MA_FLAGS_COLLECT_CARD
#define RDB$M_MA_FLAGS_SEQ_FILL          RDB_M_MA_FLAGS_SEQ_FILL
#define RDB$M_MA_FLAGS_NAMED_PARTITION   RDB_M_MA_FLAGS_NAMED_PARTITION
#define RDB$M_MA_FLAGS_BUILD_PENDING     RDB_M_MA_FLAGS_BUILD_PENDING
#define RDB$M_MA_FLAGS_CREATE_NOLOGGING  RDB_M_MA_FLAGS_CREATE_NOLOGGING
#define RDB$M_MA_FLAGS_COLLECT_CARD      RDB_M_MA_FLAGS_COLLECT_CARD
#define RDB$K_RC_FLAGS_UNIQ_ALLOW_EMPTY  RDB_K_RC_FLAGS_UNIQ_ALLOW_EMPTY
#define RDB$M_RC_FLAGS_UNIQ_ALLOW_EMPTY  RDB_M_RC_FLAGS_UNIQ_ALLOW_EMPTY
#define RDB$K_TR_FLAGS_TRIGGER_DISABLED  RDB_K_TR_FLAGS_TRIGGER_DISABLED
#define RDB$K_TR_FLAGS_INVALID           RDB_K_TR_FLAGS_INVALID
#define RDB$K_TR_FLAGS_INVALID_LANG_SEM  RDB_K_TR_FLAGS_INVALID_LANG_SEM
#define RDB$M_TR_FLAGS_TRIGGER_DISABLED  RDB_M_TR_FLAGS_TRIGGER_DISABLED
#define RDB$M_TR_FLAGS_INVALID           RDB_M_TR_FLAGS_INVALID
#define RDB$M_TR_FLAGS_INVALID_LANG_SEM  RDB_M_TR_FLAGS_INVALID_LANG_SEM
#define RDB$K_SQ_FLAGS_CYCLE             RDB_K_SQ_FLAGS_CYCLE
#define RDB$K_SQ_FLAGS_ORDER             RDB_K_SQ_FLAGS_ORDER
#define RDB$K_SQ_FLAGS_RANDOMIZE         RDB_K_SQ_FLAGS_RANDOMIZE
#define RDB$K_SQ_FLAGS_SYSTEM            RDB_K_SQ_FLAGS_SYSTEM
#define RDB$K_SQ_FLAGS_USED_NOMINVALUE   RDB_K_SQ_FLAGS_USED_NOMINVALUE
#define RDB$K_SQ_FLAGS_USED_NOMAXVALUE   RDB_K_SQ_FLAGS_USED_NOMAXVALUE
#define RDB$K_SQ_FLAGS_COLUMN_IDENTITY   RDB_K_SQ_FLAGS_COLUMN_IDENTITY
#define RDB$K_SQ_FLAGS_LOCK_WAIT         RDB_K_SQ_FLAGS_LOCK_WAIT
#define RDB$K_SQ_FLAGS_LOCK_NOWAIT       RDB_K_SQ_FLAGS_LOCK_NOWAIT
#define RDB$K_SQ_FLAGS_MANUAL_UPDATE     RDB_K_SQ_FLAGS_MANUAL_UPDATE
#define RDB$M_SQ_FLAGS_CYCLE             RDB_M_SQ_FLAGS_CYCLE
#define RDB$M_SQ_FLAGS_ORDER             RDB_M_SQ_FLAGS_ORDER
#define RDB$M_SQ_FLAGS_RANDOMIZE         RDB_M_SQ_FLAGS_RANDOMIZE
#define RDB$M_SQ_FLAGS_SYSTEM            RDB_M_SQ_FLAGS_SYSTEM
#define RDB$M_SQ_FLAGS_USED_NOMINVALUE   RDB_M_SQ_FLAGS_USED_NOMINVALUE
#define RDB$M_SQ_FLAGS_USED_NOMAXVALUE   RDB_M_SQ_FLAGS_USED_NOMAXVALUE
#define RDB$M_SQ_FLAGS_COLUMN_IDENTITY   RDB_M_SQ_FLAGS_COLUMN_IDENTITY
#define RDB$M_SQ_FLAGS_LOCK_WAIT         RDB_M_SQ_FLAGS_LOCK_WAIT
#define RDB$M_SQ_FLAGS_LOCK_NOWAIT       RDB_M_SQ_FLAGS_LOCK_NOWAIT
#define RDB$M_SQ_FLAGS_MANUAL_UPDATE     RDB_M_SQ_FLAGS_MANUAL_UPDATE
#define RDB$K_PV_FLAGS_OBJ_MOD_RTN       RDB_K_PV_FLAGS_OBJ_MOD_RTN
#define RDB$K_PV_FLAGS_OBJ_SEQ           RDB_K_PV_FLAGS_OBJ_SEQ
#define RDB$K_PV_FLAGS_OBJ_TYP_FLD       RDB_K_PV_FLAGS_OBJ_TYP_FLD
#define RDB$M_PV_FLAGS_OBJ_MOD_RTN       RDB_M_PV_FLAGS_OBJ_MOD_RTN
#define RDB$M_PV_FLAGS_OBJ_SEQ           RDB_M_PV_FLAGS_OBJ_SEQ
#define RDB$M_PV_FLAGS_OBJ_TYP_FLD       RDB_M_PV_FLAGS_OBJ_TYP_FLD
#define RDB$K_FL_FLAGS_SQL_VALID_IF      RDB_K_FL_FLAGS_SQL_VALID_IF
#define RDB$K_FL_FLAGS_AUTO_INSERT       RDB_K_FL_FLAGS_AUTO_INSERT
#define RDB$K_FL_FLAGS_AUTO_UPDATE       RDB_K_FL_FLAGS_AUTO_UPDATE
#define RDB$K_FL_FLAGS_NAMED_VALID_IF    RDB_K_FL_FLAGS_NAMED_VALID_IF
#define RDB$K_FL_FLAGS_COLUMN_IDENTITY   RDB_K_FL_FLAGS_COLUMN_IDENTITY
#define RDB$K_FL_FLAGS_READ_ONLY         RDB_K_FL_FLAGS_READ_ONLY
#define RDB$K_FL_FLAGS_DISTINCT_TYPE     RDB_K_FL_FLAGS_DISTINCT_TYPE
#define RDB$K_FL_FLAGS_HIDDEN            RDB_K_FL_FLAGS_HIDDEN
#define RDB$K_FL_FLAGS_SHARED_COMPUTED   RDB_K_FL_FLAGS_SHARED_COMPUTED
#define RDB$K_FL_FLAGS_AUTO_CONTEXT      RDB_K_FL_FLAGS_AUTO_CONTEXT
#define RDB$M_FL_FLAGS_SQL_VALID_IF      RDB_M_FL_FLAGS_SQL_VALID_IF
#define RDB$M_FL_FLAGS_AUTO_INSERT       RDB_M_FL_FLAGS_AUTO_INSERT
#define RDB$M_FL_FLAGS_AUTO_UPDATE       RDB_M_FL_FLAGS_AUTO_UPDATE
#define RDB$M_FL_FLAGS_NAMED_VALID_IF    RDB_M_FL_FLAGS_NAMED_VALID_IF
#define RDB$M_FL_FLAGS_COLUMN_IDENTITY   RDB_M_FL_FLAGS_COLUMN_IDENTITY
#define RDB$M_FL_FLAGS_READ_ONLY         RDB_M_FL_FLAGS_READ_ONLY
#define RDB$M_FL_FLAGS_DISTINCT_TYPE     RDB_M_FL_FLAGS_DISTINCT_TYPE
#define RDB$M_FL_FLAGS_HIDDEN            RDB_M_FL_FLAGS_HIDDEN
#define RDB$M_FL_FLAGS_SHARED_COMPUTED   RDB_M_FL_FLAGS_SHARED_COMPUTED
#define RDB$M_FL_FLAGS_AUTO_CONTEXT      RDB_M_FL_FLAGS_AUTO_CONTEXT
#define RDB$K_FV_FLAGS_NULLS_ALLOWED     RDB_K_FV_FLAGS_NULLS_ALLOWED
#define RDB$K_FV_FLAGS_UNIQUE            RDB_K_FV_FLAGS_UNIQUE
#define RDB$K_FV_FLAGS_DYNAMIC           RDB_K_FV_FLAGS_DYNAMIC
#define RDB$K_FV_FLAGS_INDIRECT          RDB_K_FV_FLAGS_INDIRECT
#define RDB$K_FV_FLAGS_REF_TEMP_TABLE    RDB_K_FV_FLAGS_REF_TEMP_TABLE
#define RDB$K_FV_FLAGS_SQL_VALID_IF      RDB_K_FV_FLAGS_SQL_VALID_IF
#define RDB$K_FV_FLAGS_AUTO_INSERT       RDB_K_FV_FLAGS_AUTO_INSERT
#define RDB$K_FV_FLAGS_AUTO_UPDATE       RDB_K_FV_FLAGS_AUTO_UPDATE
#define RDB$K_FV_FLAGS_NAMED_VALID_IF    RDB_K_FV_FLAGS_NAMED_VALID_IF
#define RDB$K_FV_FLAGS_COLUMN_IDENTITY   RDB_K_FV_FLAGS_COLUMN_IDENTITY
#define RDB$K_FV_FLAGS_READ_ONLY         RDB_K_FV_FLAGS_READ_ONLY
#define RDB$K_FV_FLAGS_DISTINCT_TYPE     RDB_K_FV_FLAGS_DISTINCT_TYPE
#define RDB$K_FV_FLAGS_AUTO_CONTEXT      RDB_K_FV_FLAGS_AUTO_CONTEXT
#define RDB$M_FV_FLAGS_NULLS_ALLOWED     RDB_M_FV_FLAGS_NULLS_ALLOWED
#define RDB$M_FV_FLAGS_UNIQUE            RDB_M_FV_FLAGS_UNIQUE
#define RDB$M_FV_FLAGS_DYNAMIC           RDB_M_FV_FLAGS_DYNAMIC
#define RDB$M_FV_FLAGS_INDIRECT          RDB_M_FV_FLAGS_INDIRECT
#define RDB$M_FV_FLAGS_REF_TEMP_TABLE    RDB_M_FV_FLAGS_REF_TEMP_TABLE
#define RDB$M_FV_FLAGS_SQL_VALID_IF      RDB_M_FV_FLAGS_SQL_VALID_IF
#define RDB$M_FV_FLAGS_AUTO_INSERT       RDB_M_FV_FLAGS_AUTO_INSERT
#define RDB$M_FV_FLAGS_AUTO_UPDATE       RDB_M_FV_FLAGS_AUTO_UPDATE
#define RDB$M_FV_FLAGS_NAMED_VALID_IF    RDB_M_FV_FLAGS_NAMED_VALID_IF
#define RDB$M_FV_FLAGS_COLUMN_IDENTITY   RDB_M_FV_FLAGS_COLUMN_IDENTITY
#define RDB$M_FV_FLAGS_READ_ONLY         RDB_M_FV_FLAGS_READ_ONLY
#define RDB$M_FV_FLAGS_DISTINCT_TYPE     RDB_M_FV_FLAGS_DISTINCT_TYPE
#define RDB$M_FV_FLAGS_AUTO_CONTEXT      RDB_M_FV_FLAGS_AUTO_CONTEXT
#define RDB$K_OS_FLAGS_SYNONYM_REF       RDB_K_OS_FLAGS_SYNONYM_REF
#define RDB$K_OS_FLAGS_CLIENT_SYNONYM    RDB_K_OS_FLAGS_CLIENT_SYNONYM
#define RDB$K_OS_FLAGS_FROM_RENAME       RDB_K_OS_FLAGS_FROM_RENAME
#define RDB$M_OS_FLAGS_SYNONYM_REF       RDB_M_OS_FLAGS_SYNONYM_REF
#define RDB$M_OS_FLAGS_CLIENT_SYNONYM    RDB_M_OS_FLAGS_CLIENT_SYNONYM
#define RDB$M_OS_FLAGS_FROM_RENAME       RDB_M_OS_FLAGS_FROM_RENAME
#define RDB$K_C1_FLAGS_AGG_LEVEL2        RDB_K_C1_FLAGS_AGG_LEVEL2
#define RDB$K_C1_FLAGS_RENAME            RDB_K_C1_FLAGS_RENAME
#define RDB$K_C1_FLAGS_BIT_UNUSED_BIT    RDB_K_C1_FLAGS_BIT_UNUSED_BIT
#define RDB$K_C1_FLAGS_CLONE_TABLE       RDB_K_C1_FLAGS_CLONE_TABLE
#define RDB$K_C1_FLAGS_BOOLEAN_TYPE      RDB_K_C1_FLAGS_BOOLEAN_TYPE
#define RDB$K_C1_FLAGS_FN_OVERLAY        RDB_K_C1_FLAGS_FN_OVERLAY
#define RDB$K_C1_FLAGS_FN_MOD            RDB_K_C1_FLAGS_FN_MOD
#define RDB$K_C1_FLAGS_FN_ROUND          RDB_K_C1_FLAGS_FN_ROUND
#define RDB$K_C1_FLAGS_UDT_LEVEL1        RDB_K_C1_FLAGS_UDT_LEVEL1
#define RDB$K_C1_FLAGS_UDT_LEVEL2        RDB_K_C1_FLAGS_UDT_LEVEL2
#define RDB$K_C1_FLAGS_LOB_LEVEL1        RDB_K_C1_FLAGS_LOB_LEVEL1
#define RDB$K_C1_FLAGS_LOB_LEVEL2        RDB_K_C1_FLAGS_LOB_LEVEL2
#define RDB$K_C1_FLAGS_AUTO_TRANS_SESS   RDB_K_C1_FLAGS_AUTO_TRANS_SESS
#define RDB$K_C1_FLAGS_AUTO_DEFAULT      RDB_K_C1_FLAGS_AUTO_DEFAULT
#define RDB$K_C1_FLAGS_QG_EXEC_TIMEOUT   RDB_K_C1_FLAGS_QG_EXEC_TIMEOUT
#define RDB$K_C1_FLAGS_FN_TRUNC          RDB_K_C1_FLAGS_FN_TRUNC
#define RDB$K_C1_FLAGS_ALTER_VIEW        RDB_K_C1_FLAGS_ALTER_VIEW
#define RDB$K_C1_FLAGS_TAG_MSP           RDB_K_C1_FLAGS_TAG_MSP
#define RDB$K_C1_FLAGS_VECTOR_CONCAT     RDB_K_C1_FLAGS_VECTOR_CONCAT
#define RDB$K_C1_FLAGS_RENAME_MAP        RDB_K_C1_FLAGS_RENAME_MAP
#define RDB$K_C1_FLAGS_LOB_LEVEL0        RDB_K_C1_FLAGS_LOB_LEVEL0
#define RDB$K_C1_FLAGS_REPLACE_STMT      RDB_K_C1_FLAGS_REPLACE_STMT
#define RDB$K_C1_FLAGS_MERGE_STMT        RDB_K_C1_FLAGS_MERGE_STMT
#define RDB$K_C1_FLAGS_FN_CONCAT_WS      RDB_K_C1_FLAGS_FN_CONCAT_WS
#define RDB$K_C1_FLAGS_LIKE_IGNORE_CASE  RDB_K_C1_FLAGS_LIKE_IGNORE_CASE
#define RDB$M_C1_FLAGS_AGG_LEVEL2        RDB_M_C1_FLAGS_AGG_LEVEL2
#define RDB$M_C1_FLAGS_RENAME            RDB_M_C1_FLAGS_RENAME
#define RDB$M_C1_FLAGS_CLONE_TABLE       RDB_M_C1_FLAGS_CLONE_TABLE
#define RDB$M_C1_FLAGS_BOOLEAN_TYPE      RDB_M_C1_FLAGS_BOOLEAN_TYPE
#define RDB$M_C1_FLAGS_FN_OVERLAY        RDB_M_C1_FLAGS_FN_OVERLAY
#define RDB$M_C1_FLAGS_FN_MOD            RDB_M_C1_FLAGS_FN_MOD
#define RDB$M_C1_FLAGS_FN_ROUND          RDB_M_C1_FLAGS_FN_ROUND
#define RDB$M_C1_FLAGS_UDT_LEVEL1        RDB_M_C1_FLAGS_UDT_LEVEL1
#define RDB$M_C1_FLAGS_UDT_LEVEL2        RDB_M_C1_FLAGS_UDT_LEVEL2
#define RDB$M_C1_FLAGS_LOB_LEVEL1        RDB_M_C1_FLAGS_LOB_LEVEL1
#define RDB$M_C1_FLAGS_LOB_LEVEL2        RDB_M_C1_FLAGS_LOB_LEVEL2
#define RDB$M_C1_FLAGS_AUTO_TRANS_SESS   RDB_M_C1_FLAGS_AUTO_TRANS_SESS
#define RDB$M_C1_FLAGS_AUTO_DEFAULT      RDB_M_C1_FLAGS_AUTO_DEFAULT
#define RDB$M_C1_FLAGS_QG_EXEC_TIMEOUT   RDB_M_C1_FLAGS_QG_EXEC_TIMEOUT
#define RDB$M_C1_FLAGS_FN_TRUNC          RDB_M_C1_FLAGS_FN_TRUNC
#define RDB$M_C1_FLAGS_ALTER_VIEW        RDB_M_C1_FLAGS_ALTER_VIEW
#define RDB$M_C1_FLAGS_TAG_MSP           RDB_M_C1_FLAGS_TAG_MSP
#define RDB$M_C1_FLAGS_VECTOR_CONCAT     RDB_M_C1_FLAGS_VECTOR_CONCAT
#define RDB$M_C1_FLAGS_RENAME_MAP        RDB_M_C1_FLAGS_RENAME_MAP
#define RDB$M_C1_FLAGS_LOB_LEVEL0        RDB_M_C1_FLAGS_LOB_LEVEL0
#define RDB$M_C1_FLAGS_REPLACE_STMT      RDB_M_C1_FLAGS_REPLACE_STMT
#define RDB$M_C1_FLAGS_MERGE_STMT        RDB_M_C1_FLAGS_MERGE_STMT
#define RDB$M_C1_FLAGS_FN_CONCAT_WS      RDB_M_C1_FLAGS_FN_CONCAT_WS
#define RDB$M_C1_FLAGS_LIKE_IGNORE_CASE  RDB_M_C1_FLAGS_LIKE_IGNORE_CASE
#define RDB$M_PARAM_IND_PRESENT          RDB_M_PARAM_IND_PRESENT
#define BLR$K_TRANS_UPPER                BLR_K_TRANS_UPPER
#define BLR$K_TRANS_LOWER                BLR_K_TRANS_LOWER
#define BLR$K_TRANS_MISSING_NONE         BLR_K_TRANS_MISSING_NONE
#define BLR$K_TRANS_MISSING_DEFAULT      BLR_K_TRANS_MISSING_DEFAULT
#define BLR$K_TRANS_MISSING_SPECIFIED    BLR_K_TRANS_MISSING_SPECIFIED
#define BLR$K_TRANS_MISSING_MAX          BLR_K_TRANS_MISSING_MAX
#define RDB$K_TXN_START                  RDB_K_TXN_START
#define RDB$K_TXN_COMMIT                 RDB_K_TXN_COMMIT
#define RDB$K_TXN_ROLLBACK               RDB_K_TXN_ROLLBACK
#define RDB$K_TXN_MARK_ESTABLISH         RDB_K_TXN_MARK_ESTABLISH
#define RDB$K_TXN_MARK_COMMIT            RDB_K_TXN_MARK_COMMIT
#define RDB$K_TXN_MARK_ROLLBACK          RDB_K_TXN_MARK_ROLLBACK
#define RDB$K_TXN_RESERVE_TABLE          RDB_K_TXN_RESERVE_TABLE
#define RDB$K_TXN_EVALUATE_CONSTRAINT    RDB_K_TXN_EVALUATE_CONSTRAINT
#define RDB$K_TXN_COMMIT_RESTART         RDB_K_TXN_COMMIT_RESTART
#define RDB$K_TXN_ROLLBACK_RESTART       RDB_K_TXN_ROLLBACK_RESTART
#define RDB$K_JOIN_OUTER                 RDB_K_JOIN_OUTER
#define RDB$K_JOIN_LEFT                  RDB_K_JOIN_LEFT
#define RDB$K_JOIN_RIGHT                 RDB_K_JOIN_RIGHT
#define RDB$K_JOIN_CROSS                 RDB_K_JOIN_CROSS
#define RDB$M_RSE_JOIN_INNER             RDB_M_RSE_JOIN_INNER
#define RDB$M_RSE_JOIN_LEFT              RDB_M_RSE_JOIN_LEFT
#define RDB$M_RSE_JOIN_RIGHT             RDB_M_RSE_JOIN_RIGHT
#define RDB$M_RSE_JOIN_FULL              RDB_M_RSE_JOIN_FULL
#define RDB$M_RSE_JOIN_CROSS             RDB_M_RSE_JOIN_CROSS
#define DSC$K_DTYPE_DATETIME             DSC_K_DTYPE_DATETIME
#define DSC$K_DTYPE_CHAR                 DSC_K_DTYPE_CHAR
#define DSC$K_DTYPE_VCHAR                DSC_K_DTYPE_VCHAR
#define DSC$K_DTYPE_BOOL                 DSC_K_DTYPE_BOOL
#define DSC$K_DTYPE_VBYTE                DSC_K_DTYPE_VBYTE
#define DSC$K_DTYPE_UDT                  DSC_K_DTYPE_UDT
#define DSC$K_DTYPE_BLOB                 DSC_K_DTYPE_BLOB
#define BLR$K_EXT_MIN                    BLR_K_EXT_MIN
#define BLR$K_EXT_YEAR                   BLR_K_EXT_YEAR
#define BLR$K_EXT_MONTH                  BLR_K_EXT_MONTH
#define BLR$K_EXT_DAY                    BLR_K_EXT_DAY
#define BLR$K_EXT_HOUR                   BLR_K_EXT_HOUR
#define BLR$K_EXT_MINUTE                 BLR_K_EXT_MINUTE
#define BLR$K_EXT_SECOND                 BLR_K_EXT_SECOND
#define BLR$K_EXT_FRACTION               BLR_K_EXT_FRACTION
#define BLR$K_EXT_TZ_HOUR                BLR_K_EXT_TZ_HOUR
#define BLR$K_EXT_TZ_MINUTE              BLR_K_EXT_TZ_MINUTE
#define BLR$K_EXT_WEEKDAY                BLR_K_EXT_WEEKDAY
#define BLR$K_EXT_LENGTH                 BLR_K_EXT_LENGTH
#define BLR$K_EXT_MAX_SIZE               BLR_K_EXT_MAX_SIZE
#define BLR$K_EXT_NLENGTH                BLR_K_EXT_NLENGTH
#define BLR$K_EXT_JULIAN                 BLR_K_EXT_JULIAN
#define BLR$K_EXT_WEEKNUMBER             BLR_K_EXT_WEEKNUMBER
#define BLR$K_EXT_YEARWEEK               BLR_K_EXT_YEARWEEK
#define BLR$K_EXT_MAX                    BLR_K_EXT_MAX
#define BLR$V_DT_YEAR                    BLR_V_DT_YEAR
#define BLR$V_DT_MONTH                   BLR_V_DT_MONTH
#define BLR$V_DT_DAY                     BLR_V_DT_DAY
#define BLR$V_DT_HOUR                    BLR_V_DT_HOUR
#define BLR$V_DT_MINUTE                  BLR_V_DT_MINUTE
#define BLR$V_DT_SECOND                  BLR_V_DT_SECOND
#define BLR$V_DT_TZ_MINUTE               BLR_V_DT_TZ_MINUTE
#define BLR$V_DT_TZ_HOUR                 BLR_V_DT_TZ_HOUR
#define BLR$V_DT_MBZ                     BLR_V_DT_MBZ
#define BLR$V_DT_INTERVAL                BLR_V_DT_INTERVAL
#define BLR$V_DT_TIME_ZONE               BLR_V_DT_TIME_ZONE
#define BLR$V_DT_SQL99_FORMAT            BLR_V_DT_SQL99_FORMAT
#define BLR$M_DT_TIMESTAMP_ADT           BLR_M_DT_TIMESTAMP_ADT
#define BLR$M_DT_YEAR                    BLR_M_DT_YEAR
#define BLR$M_DT_MONTH                   BLR_M_DT_MONTH
#define BLR$M_DT_DAY                     BLR_M_DT_DAY
#define BLR$M_DT_HOUR                    BLR_M_DT_HOUR
#define BLR$M_DT_MINUTE                  BLR_M_DT_MINUTE
#define BLR$M_DT_SECOND                  BLR_M_DT_SECOND
#define BLR$M_DT_INTERVAL                BLR_M_DT_INTERVAL
#define BLR$M_DT_SQL99_FORMAT            BLR_M_DT_SQL99_FORMAT
#define BLR$M_DT_TIME                    BLR_M_DT_TIME
#define BLR$M_DT_DATE                    BLR_M_DT_DATE
#define BLR$M_DT_TIMESTAMP               BLR_M_DT_TIMESTAMP
#define BLR$M_DT_INT_YEAR                BLR_M_DT_INT_YEAR
#define BLR$M_DT_INT_YEAR_MONTH          BLR_M_DT_INT_YEAR_MONTH
#define BLR$M_DT_INT_MONTH               BLR_M_DT_INT_MONTH
#define BLR$M_DT_INT_DAY                 BLR_M_DT_INT_DAY
#define BLR$M_DT_INT_DAY_HOUR            BLR_M_DT_INT_DAY_HOUR
#define BLR$M_DT_INT_DAY_MINUTE          BLR_M_DT_INT_DAY_MINUTE
#define BLR$M_DT_INT_DAY_SECOND          BLR_M_DT_INT_DAY_SECOND
#define BLR$M_DT_INT_HOUR                BLR_M_DT_INT_HOUR
#define BLR$M_DT_INT_HOUR_MINUTE         BLR_M_DT_INT_HOUR_MINUTE
#define BLR$M_DT_INT_HOUR_SECOND         BLR_M_DT_INT_HOUR_SECOND
#define BLR$M_DT_INT_MINUTE              BLR_M_DT_INT_MINUTE
#define BLR$M_DT_INT_MINUTE_SECOND       BLR_M_DT_INT_MINUTE_SECOND
#define BLR$M_DT_INT_SECOND              BLR_M_DT_INT_SECOND
#define OBLR$K_MIN                       OBLR_K_MIN
#define OBLR$K_VERSION                   OBLR_K_VERSION
#define OBLR$K_BEGIN                     OBLR_K_BEGIN
#define OBLR$K_END                       OBLR_K_END
#define OBLR$K_OUTLINE_NAME              OBLR_K_OUTLINE_NAME
#define OBLR$K_OUTLINE_MODE              OBLR_K_OUTLINE_MODE
#define OBLR$K_OUTLINE_ID                OBLR_K_OUTLINE_ID
#define OBLR$K_OUTLINE_FLAGS             OBLR_K_OUTLINE_FLAGS
#define OBLR$K_COMMENT                   OBLR_K_COMMENT
#define OBLR$K_RELATION                  OBLR_K_RELATION
#define OBLR$K_ACCESS_ANY                OBLR_K_ACCESS_ANY
#define OBLR$K_ACCESS_SEQUENTIAL         OBLR_K_ACCESS_SEQUENTIAL
#define OBLR$K_ACCESS_DBKEY              OBLR_K_ACCESS_DBKEY
#define OBLR$K_ACCESS_NO_INDEX           OBLR_K_ACCESS_NO_INDEX
#define OBLR$K_ACCESS_INDEX              OBLR_K_ACCESS_INDEX
#define OBLR$K_JOIN_ANY                  OBLR_K_JOIN_ANY
#define OBLR$K_JOIN_CROSS                OBLR_K_JOIN_CROSS
#define OBLR$K_JOIN_MATCH                OBLR_K_JOIN_MATCH
#define OBLR$K_JOIN_HASH                 OBLR_K_JOIN_HASH
#define OBLR$K_UNION                     OBLR_K_UNION
#define OBLR$K_QUERY                     OBLR_K_QUERY
#define OBLR$K_ORDERED                   OBLR_K_ORDERED
#define OBLR$K_UNORDERED                 OBLR_K_UNORDERED
#define OBLR$K_SUBQUERY                  OBLR_K_SUBQUERY
#define OBLR$K_FLOATING                  OBLR_K_FLOATING
#define OBLR$K_MODULE_RELATION           OBLR_K_MODULE_RELATION
#define OBLR$K_MAX                       OBLR_K_MAX
#define OBLR$K_EOC                       OBLR_K_EOC
#define RDB$K_OUTL_FLG_COMPLIANCE        RDB_K_OUTL_FLG_COMPLIANCE
#define RDB$K_OUTL_FLG_NODYN             RDB_K_OUTL_FLG_NODYN
#define RDB$K_OUTL_FLG_ANY               RDB_K_OUTL_FLG_ANY
#define RDB$K_OUTL_FLG_FAST_FIRST        RDB_K_OUTL_FLG_FAST_FIRST
#define RDB$K_OUTL_FLG_TOTAL_TIME        RDB_K_OUTL_FLG_TOTAL_TIME
#define RDB$K_OUTL_OPT_MIN               RDB_K_OUTL_OPT_MIN
#define RDB$K_OUTL_OPT_CREATE            RDB_K_OUTL_OPT_CREATE
#define RDB$K_OUTL_OPT_STORE             RDB_K_OUTL_OPT_STORE
#define RDB$K_OUTL_OPT_USE_STORED        RDB_K_OUTL_OPT_USE_STORED
#define RDB$K_OUTL_OPT_USE               RDB_K_OUTL_OPT_USE
#define RDB$K_OUTL_OPT_USE_AUGMENT       RDB_K_OUTL_OPT_USE_AUGMENT
#define RDB$K_OUTL_OPT_MAX               RDB_K_OUTL_OPT_MAX
#define RDB$K_OUTL_MODE_MIN              RDB_K_OUTL_MODE_MIN
#define RDB$K_OUTL_MODE_DEFAULT          RDB_K_OUTL_MODE_DEFAULT
#define RDB$K_OUTL_MODE_FAST_FIRST       RDB_K_OUTL_MODE_FAST_FIRST
#define RDB$K_OUTL_MODE_TOTAL_TIME       RDB_K_OUTL_MODE_TOTAL_TIME
#define RDB$K_OUTL_MODE_MAX              RDB_K_OUTL_MODE_MAX
#define RDB$K_CURRENT_OBLR_VERSION       RDB_K_CURRENT_OBLR_VERSION
#define RDB$M_OPR_NONE                   RDB_M_OPR_NONE
#define RDB$M_OPR_CENTRAL                RDB_M_OPR_CENTRAL
#define RDB$M_OPR_PRINT                  RDB_M_OPR_PRINT
#define RDB$M_OPR_TAPES                  RDB_M_OPR_TAPES
#define RDB$M_OPR_DISKS                  RDB_M_OPR_DISKS
#define RDB$M_OPR_DEVICE                 RDB_M_OPR_DEVICE
#define RDB$M_OPR_CARDS                  RDB_M_OPR_CARDS
#define RDB$M_OPR_NETWORK                RDB_M_OPR_NETWORK
#define RDB$M_OPR_CLUSTER                RDB_M_OPR_CLUSTER
#define RDB$M_OPR_SECURITY               RDB_M_OPR_SECURITY
#define RDB$M_OPR_REPLY                  RDB_M_OPR_REPLY
#define RDB$M_OPR_SOFTWARE               RDB_M_OPR_SOFTWARE
#define RDB$M_OPR_LICENSE                RDB_M_OPR_LICENSE
#define RDB$M_OPR_OPER1                  RDB_M_OPR_OPER1
#define RDB$M_OPR_OPER2                  RDB_M_OPR_OPER2
#define RDB$M_OPR_OPER3                  RDB_M_OPR_OPER3
#define RDB$M_OPR_OPER4                  RDB_M_OPR_OPER4
#define RDB$M_OPR_OPER5                  RDB_M_OPR_OPER5
#define RDB$M_OPR_OPER6                  RDB_M_OPR_OPER6
#define RDB$M_OPR_OPER7                  RDB_M_OPR_OPER7
#define RDB$M_OPR_OPER8                  RDB_M_OPR_OPER8
#define RDB$M_OPR_OPER9                  RDB_M_OPR_OPER9
#define RDB$M_OPR_OPER10                 RDB_M_OPR_OPER10
#define RDB$M_OPR_OPER11                 RDB_M_OPR_OPER11
#define RDB$M_OPR_OPER12                 RDB_M_OPR_OPER12
#define RDB$M_OPR_ALL                    RDB_M_OPR_ALL
#define RDB$K_SCROLL_MIN                 RDB_K_SCROLL_MIN
#define RDB$K_SCROLL_NEXT                RDB_K_SCROLL_NEXT
#define RDB$K_SCROLL_PRIOR               RDB_K_SCROLL_PRIOR
#define RDB$K_SCROLL_FIRST               RDB_K_SCROLL_FIRST
#define RDB$K_SCROLL_LAST                RDB_K_SCROLL_LAST
#define RDB$K_SCROLL_RELATIVE            RDB_K_SCROLL_RELATIVE
#define RDB$K_SCROLL_ABSOLUTE            RDB_K_SCROLL_ABSOLUTE
#define RDB$K_SCROLL_MAX                 RDB_K_SCROLL_MAX
#define RDB$V_BLOB_ENABLE_SCROLL         RDB_V_BLOB_ENABLE_SCROLL
#define RDB$V_BLOB_GET_TRUNCATE          RDB_V_BLOB_GET_TRUNCATE
#define RDB$V_BLOB_DISABLE_PART_GET      RDB_V_BLOB_DISABLE_PART_GET
#define RDB$V_BLOB_GET_NOFILL            RDB_V_BLOB_GET_NOFILL
#define RDB$V_BLOB_CREATE_LOCAL          RDB_V_BLOB_CREATE_LOCAL
#define RDB$V_BLOB_CREATE_SCRATCH        RDB_V_BLOB_CREATE_SCRATCH
#define RDB$V_BLOB_CREATE_TABLE          RDB_V_BLOB_CREATE_TABLE
#define RDB$M_BLOB_ENABLE_SCROLL         RDB_M_BLOB_ENABLE_SCROLL
#define RDB$M_BLOB_GET_TRUNCATE          RDB_M_BLOB_GET_TRUNCATE
#define RDB$M_BLOB_GET_NOFILL            RDB_M_BLOB_GET_NOFILL
#define RDB$M_BLOB_CREATE_LOCAL          RDB_M_BLOB_CREATE_LOCAL
#define RDB$M_BLOB_CREATE_SCRATCH        RDB_M_BLOB_CREATE_SCRATCH
#define RDB$M_BLOB_CREATE_TABLE          RDB_M_BLOB_CREATE_TABLE
#define RDB$K_INTCOM_MIN                 RDB_K_INTCOM_MIN
#define RDB$K_INTCOM_END                 RDB_K_INTCOM_END
#define RDB$K_INTCOM_TRUNCATED           RDB_K_INTCOM_TRUNCATED
#define RDB$K_INTCOM_ERROR               RDB_K_INTCOM_ERROR
#define RDB$K_INTCOM_FUNCTION            RDB_K_INTCOM_FUNCTION
#define RDB$K_INTCOM_USER_UIC            RDB_K_INTCOM_USER_UIC
#define RDB$K_INTCOM_TRUSTED_BUF         RDB_K_INTCOM_TRUSTED_BUF
#define RDB$K_INTCOM_XA_COMPLIANT        RDB_K_INTCOM_XA_COMPLIANT
#define RDB$K_INTCOM_XA_RECOVERY         RDB_K_INTCOM_XA_RECOVERY
#define RDB$K_INTCOM_CLIENT_CTX          RDB_K_INTCOM_CLIENT_CTX
#define RDB$K_INTCOM_PARENT_CLIENT_CTX   RDB_K_INTCOM_PARENT_CLIENT_CTX
#define RDB$K_INTCOM_MAX                 RDB_K_INTCOM_MAX
#define RDB$K_RTX_NOTIFY_MIN             RDB_K_RTX_NOTIFY_MIN
#define RDB$K_RTX_NOTIFY_ACTV_START      RDB_K_RTX_NOTIFY_ACTV_START
#define RDB$K_RTX_NOTIFY_ACTV_END        RDB_K_RTX_NOTIFY_ACTV_END
#define RDB$K_RTX_NOTIFY_CONN_START      RDB_K_RTX_NOTIFY_CONN_START
#define RDB$K_RTX_NOTIFY_CONN_END        RDB_K_RTX_NOTIFY_CONN_END
#define RDB$K_RTX_NOTIFY_TRAN_START      RDB_K_RTX_NOTIFY_TRAN_START
#define RDB$K_RTX_NOTIFY_TRAN_COMMIT     RDB_K_RTX_NOTIFY_TRAN_COMMIT
#define RDB$K_RTX_NOTIFY_TRAN_ROLLBACK   RDB_K_RTX_NOTIFY_TRAN_ROLLBACK
#define RDB$K_RTX_NOTIFY_STMT_START      RDB_K_RTX_NOTIFY_STMT_START
#define RDB$K_RTX_NOTIFY_STMT_FAILURE    RDB_K_RTX_NOTIFY_STMT_FAILURE
#define RDB$K_RTX_NOTIFY_STMT_SUCCESS    RDB_K_RTX_NOTIFY_STMT_SUCCESS
#define RDB$K_RTX_NOTIFY_MAX             RDB_K_RTX_NOTIFY_MAX
#define RDB$K_RTX_ERR_MIN                RDB_K_RTX_ERR_MIN
#define RDB$K_RTX_ERR_ACTIVATE           RDB_K_RTX_ERR_ACTIVATE
#define RDB$K_RTX_ERR_ACT_INSTALL        RDB_K_RTX_ERR_ACT_INSTALL
#define RDB$K_RTX_ERR_BIND_BODY_ENT      RDB_K_RTX_ERR_BIND_BODY_ENT
#define RDB$K_RTX_ERR_BIND_NTFY_ENT      RDB_K_RTX_ERR_BIND_NTFY_ENT
#define RDB$K_RTX_ERR_EXECUTE            RDB_K_RTX_ERR_EXECUTE
#define RDB$K_RTX_ERR_NOTIFY             RDB_K_RTX_ERR_NOTIFY
#define RDB$K_RTX_ERR_DEACTIVATE         RDB_K_RTX_ERR_DEACTIVATE
#define RDB$K_RTX_ERR_CANCEL             RDB_K_RTX_ERR_CANCEL
#define RDB$K_RTX_ERR_CLIENT_SITE        RDB_K_RTX_ERR_CLIENT_SITE
#define RDB$K_RTX_ERR_SERVER_SITE        RDB_K_RTX_ERR_SERVER_SITE
#define RDB$K_RTX_ERR_UNKNOWN            RDB_K_RTX_ERR_UNKNOWN
#define RDB$K_RTX_ERR_MAX                RDB_K_RTX_ERR_MAX
#define RDB$K_LANGUAGE_UNDEFINED         RDB_K_LANGUAGE_UNDEFINED
#define RDB$K_LANGUAGE_ADA               RDB_K_LANGUAGE_ADA
#define RDB$K_LANGUAGE_C                 RDB_K_LANGUAGE_C
#define RDB$K_LANGUAGE_COBOL             RDB_K_LANGUAGE_COBOL
#define RDB$K_LANGUAGE_FORTRAN           RDB_K_LANGUAGE_FORTRAN
#define RDB$K_LANGUAGE_PASCAL            RDB_K_LANGUAGE_PASCAL
#define RDB$K_LANGUAGE_MUMPS             RDB_K_LANGUAGE_MUMPS
#define RDB$K_LANGUAGE_BASIC             RDB_K_LANGUAGE_BASIC
#define RDB$K_LANGUAGE_GENERAL           RDB_K_LANGUAGE_GENERAL
#define RDB$K_LANGUAGE_PLI               RDB_K_LANGUAGE_PLI
#define RDB$K_LANGUAGE_SQL               RDB_K_LANGUAGE_SQL
#define RDB$K_LANGUAGE_JAVA              RDB_K_LANGUAGE_JAVA
#define RDB$K_MODE_UNDEFINED             RDB_K_MODE_UNDEFINED
#define RDB$K_MODE_IN                    RDB_K_MODE_IN
#define RDB$K_MODE_OUT                   RDB_K_MODE_OUT
#define RDB$K_MODE_INOUT                 RDB_K_MODE_INOUT
#define RDB$K_MODE_RETURN                RDB_K_MODE_RETURN
#define RDB$K_MODE_CAST_FROM             RDB_K_MODE_CAST_FROM
#define RDB$K_MECH_REFERENCE             RDB_K_MECH_REFERENCE
#define RDB$K_MECH_DESCRIPTOR            RDB_K_MECH_DESCRIPTOR
#define RDB$K_MECH_VALUE                 RDB_K_MECH_VALUE
#define RDB$K_MECH_LENGTH                RDB_K_MECH_LENGTH
#define RDB$K_RTX_SITE_CLIENT            RDB_K_RTX_SITE_CLIENT
#define RDB$K_RTX_SITE_SERVER            RDB_K_RTX_SITE_SERVER
#define RDB$K_RTX_DEACTIVATE_MIN         RDB_K_RTX_DEACTIVATE_MIN
#define RDB$K_RTX_DEACTIVATE_CONN        RDB_K_RTX_DEACTIVATE_CONN
#define RDB$K_RTX_DEACTIVATE_TRAN        RDB_K_RTX_DEACTIVATE_TRAN
#define RDB$K_RTX_DEACTIVATE_STMT        RDB_K_RTX_DEACTIVATE_STMT
#define RDB$K_RTX_DEACTIVATE_MAX         RDB_K_RTX_DEACTIVATE_MAX
#define RDB$K_TBL_TEMP_GLOBAL            RDB_K_TBL_TEMP_GLOBAL
#define RDB$K_TBL_TEMP_LOCAL             RDB_K_TBL_TEMP_LOCAL
#define RDB$K_TBL_TEMP_SCRATCH           RDB_K_TBL_TEMP_SCRATCH
#define RDB$K_TBL_DERIVED_DATA           RDB_K_TBL_DERIVED_DATA
#define RDB$K_TBL_VIEW                   RDB_K_TBL_VIEW
#define RDB$K_TBL_DATA                   RDB_K_TBL_DATA
#define RDB$K_TBLCMT_NONE                RDB_K_TBLCMT_NONE
#define RDB$K_TBLCMT_PRESERVE            RDB_K_TBLCMT_PRESERVE
#define RDB$K_TBLCMT_DELETE              RDB_K_TBLCMT_DELETE
#define RDB$K_POS_BEFORE                 RDB_K_POS_BEFORE
#define RDB$K_POS_AFTER                  RDB_K_POS_AFTER
#define MBLR$K_CHANGE                    MBLR_K_CHANGE
#define MBLR$K_DEFINE                    MBLR_K_DEFINE
#define MBLR$K_DELETE                    MBLR_K_DELETE
#define MBLR$K_CHANGE_CASCADE            MBLR_K_CHANGE_CASCADE
#define MBLR$K_DELETE_CASCADE            MBLR_K_DELETE_CASCADE
#define MBLR$K_DEFINE_REPLACE            MBLR_K_DEFINE_REPLACE
#define MBLR$K_DECLARE_LOCAL             MBLR_K_DECLARE_LOCAL
#define MBLR$K_OPERATION                 MBLR_K_OPERATION
#define MBLR$K_DUPLICATES_SETUP          MBLR_K_DUPLICATES_SETUP
#define MBLR$K_AIJ                       MBLR_K_AIJ
#define MBLR$K_DUPLICATES_END            MBLR_K_DUPLICATES_END
#define MBLR$K_ALLOCATION                MBLR_K_ALLOCATION
#define MBLR$K_TRUNCATE                  MBLR_K_TRUNCATE
#define MBLR$K_BUFFERS                   MBLR_K_BUFFERS
#define MBLR$K_TABLE_TYPE                MBLR_K_TABLE_TYPE
#define MBLR$K_BUFFER_LEN                MBLR_K_BUFFER_LEN
#define MBLR$K_CDD_PATH                  MBLR_K_CDD_PATH
#define MBLR$K_CHANGE_FIELD              MBLR_K_CHANGE_FIELD
#define MBLR$K_CONSTRAINT                MBLR_K_CONSTRAINT
#define MBLR$K_CONSTRAINT_DEF            MBLR_K_CONSTRAINT_DEF
#define MBLR$K_CONSTRAINT_END            MBLR_K_CONSTRAINT_END
#define MBLR$K_DESCRIPTOR                MBLR_K_DESCRIPTOR
#define MBLR$K_DEFINE_FIELD              MBLR_K_DEFINE_FIELD
#define MBLR$K_DELETE_FIELD              MBLR_K_DELETE_FIELD
#define MBLR$K_DTR_DEF_VAL               MBLR_K_DTR_DEF_VAL
#define MBLR$K_DTR_EDIT_STR              MBLR_K_DTR_EDIT_STR
#define MBLR$K_DTR_QRY_HDR               MBLR_K_DTR_QRY_HDR
#define MBLR$K_DTR_QRY_HDR_LINE          MBLR_K_DTR_QRY_HDR_LINE
#define MBLR$K_DTR_QRY_HDR_END           MBLR_K_DTR_QRY_HDR_END
#define MBLR$K_DUPLICATES                MBLR_K_DUPLICATES
#define MBLR$K_FIELD_DEF                 MBLR_K_FIELD_DEF
#define MBLR$K_FIELD_END                 MBLR_K_FIELD_END
#define MBLR$K_FIELD_EXPRESSION          MBLR_K_FIELD_EXPRESSION
#define MBLR$K_FIELD_NAM                 MBLR_K_FIELD_NAM
#define MBLR$K_FIELD_NOUPDATE            MBLR_K_FIELD_NOUPDATE
#define MBLR$K_FIELD_UPDATE              MBLR_K_FIELD_UPDATE
#define MBLR$K_INDEX_ONLY                MBLR_K_INDEX_ONLY
#define MBLR$K_FILE                      MBLR_K_FILE
#define MBLR$K_INDEX_DEF                 MBLR_K_INDEX_DEF
#define MBLR$K_INDEX_END                 MBLR_K_INDEX_END
#define MBLR$K_MISSING_VALUE             MBLR_K_MISSING_VALUE
#define MBLR$K_PARTITION                 MBLR_K_PARTITION
#define MBLR$K_NUM_BUFF                  MBLR_K_NUM_BUFF
#define MBLR$K_BUFFER_SIZE               MBLR_K_BUFFER_SIZE
#define MBLR$K_PAGE_SIZE                 MBLR_K_PAGE_SIZE
#define MBLR$K_RELATION_DEF              MBLR_K_RELATION_DEF
#define MBLR$K_RELATION_END              MBLR_K_RELATION_END
#define MBLR$K_RELATION_NAME             MBLR_K_RELATION_NAME
#define MBLR$K_RSE                       MBLR_K_RSE
#define MBLR$K_VALID_IF                  MBLR_K_VALID_IF
#define MBLR$K_VIEW_DEF                  MBLR_K_VIEW_DEF
#define MBLR$K_VIEW_END                  MBLR_K_VIEW_END
#define MBLR$K_CHANGE_ATTRIBUTES         MBLR_K_CHANGE_ATTRIBUTES
#define MBLR$K_DELETE_ATTRIBUTES         MBLR_K_DELETE_ATTRIBUTES
#define MBLR$K_COMMIT                    MBLR_K_COMMIT
#define MBLR$K_UPDATE                    MBLR_K_UPDATE
#define MBLR$K_DTR_QRY_NAM               MBLR_K_DTR_QRY_NAM
#define MBLR$K_VALID_IF_SOURCE           MBLR_K_VALID_IF_SOURCE
#define MBLR$K_COMPUTED_BY_SOURCE        MBLR_K_COMPUTED_BY_SOURCE
#define MBLR$K_RSE_SOURCE                MBLR_K_RSE_SOURCE
#define MBLR$K_CONSTRAINT_SOURCE         MBLR_K_CONSTRAINT_SOURCE
#define MBLR$K_PARTIAL_BLR               MBLR_K_PARTIAL_BLR
#define MBLR$K_ABSTIM                    MBLR_K_ABSTIM
#define MBLR$K_DCL_GLOBAL_VARIABLE       MBLR_K_DCL_GLOBAL_VARIABLE
#define MBLR$K_OPEN_CLOSE                MBLR_K_OPEN_CLOSE
#define MBLR$K_INCREMENT_BY              MBLR_K_INCREMENT_BY
#define MBLR$K_VOLLAB                    MBLR_K_VOLLAB
#define MBLR$K_OBJECT_FLAGS              MBLR_K_OBJECT_FLAGS
#define MBLR$K_SEQUENCE_FLAGS            MBLR_K_SEQUENCE_FLAGS
#define MBLR$K_NUMBER_OF_USERS           MBLR_K_NUMBER_OF_USERS
#define MBLR$K_DESCRIPTION_SOURCE        MBLR_K_DESCRIPTION_SOURCE
#define MBLR$K_SUB_TYPE                  MBLR_K_SUB_TYPE
#define MBLR$K_SEGMENT_LENGTH            MBLR_K_SEGMENT_LENGTH
#define MBLR$K_RELATION_ACL              MBLR_K_RELATION_ACL
#define MBLR$K_DATABASE_ACL              MBLR_K_DATABASE_ACL
#define MBLR$K_CONTINUOUS_FLAG           MBLR_K_CONTINUOUS_FLAG
#define MBLR$K_TRANSFER_DEF              MBLR_K_TRANSFER_DEF
#define MBLR$K_TRANSFER_END              MBLR_K_TRANSFER_END
#define MBLR$K_SELECTION_BLR             MBLR_K_SELECTION_BLR
#define MBLR$K_SEQUENCE_DEF              MBLR_K_SEQUENCE_DEF
#define MBLR$K_OPEN                      MBLR_K_OPEN
#define MBLR$K_SEQUENCE_END              MBLR_K_SEQUENCE_END
#define MBLR$K_CLOSE                     MBLR_K_CLOSE
#define MBLR$K_NOJOURNAL                 MBLR_K_NOJOURNAL
#define MBLR$K_PARTITION_NAME            MBLR_K_PARTITION_NAME
#define MBLR$K_EXIT                      MBLR_K_EXIT
#define MBLR$K_OVERFLOW_AREA_DEF         MBLR_K_OVERFLOW_AREA_DEF
#define MBLR$K_DELETION                  MBLR_K_DELETION
#define MBLR$K_OVERFLOW_AREA_END         MBLR_K_OVERFLOW_AREA_END
#define MBLR$K_CLUSTER                   MBLR_K_CLUSTER
#define MBLR$K_EXTENSION                 MBLR_K_EXTENSION
#define MBLR$K_STORAGE_MAP_DEF           MBLR_K_STORAGE_MAP_DEF
#define MBLR$K_STORAGE_MAP_END           MBLR_K_STORAGE_MAP_END
#define MBLR$K_STORAGE_MAP_COMPRESS      MBLR_K_STORAGE_MAP_COMPRESS
#define MBLR$K_STORAGE_AREA_DEF          MBLR_K_STORAGE_AREA_DEF
#define MBLR$K_STORAGE_AREA_NAME         MBLR_K_STORAGE_AREA_NAME
#define MBLR$K_STORAGE_AREA_BLR          MBLR_K_STORAGE_AREA_BLR
#define MBLR$K_STORAGE_AREA_END          MBLR_K_STORAGE_AREA_END
#define MBLR$K_STORAGE_VIA_INDEX         MBLR_K_STORAGE_VIA_INDEX
#define MBLR$K_HASHED_INDEX              MBLR_K_HASHED_INDEX
#define MBLR$K_STORAGE_MAP_SOURCE        MBLR_K_STORAGE_MAP_SOURCE
#define MBLR$K_INDEX_FIELD_ASCENDING     MBLR_K_INDEX_FIELD_ASCENDING
#define MBLR$K_INDEX_FIELD_DESCENDING    MBLR_K_INDEX_FIELD_DESCENDING
#define MBLR$K_DEFAULT_VALUE             MBLR_K_DEFAULT_VALUE
#define MBLR$K_CHECK_OPTION              MBLR_K_CHECK_OPTION
#define MBLR$K_TRIGGER_DEF               MBLR_K_TRIGGER_DEF
#define MBLR$K_TRIGGER_END               MBLR_K_TRIGGER_END
#define MBLR$K_TRIGGER_BEFORE_STORE      MBLR_K_TRIGGER_BEFORE_STORE
#define MBLR$K_TRIGGER_BEFORE_ERASE      MBLR_K_TRIGGER_BEFORE_ERASE
#define MBLR$K_TRIGGER_BEFORE_MODIFY     MBLR_K_TRIGGER_BEFORE_MODIFY
#define MBLR$K_TRIGGER_AFTER_STORE       MBLR_K_TRIGGER_AFTER_STORE
#define MBLR$K_TRIGGER_AFTER_ERASE       MBLR_K_TRIGGER_AFTER_ERASE
#define MBLR$K_TRIGGER_AFTER_MODIFY      MBLR_K_TRIGGER_AFTER_MODIFY
#define MBLR$K_TRIGGER_CONTEXT           MBLR_K_TRIGGER_CONTEXT
#define MBLR$K_TRIGGER_ACTION            MBLR_K_TRIGGER_ACTION
#define MBLR$K_TRIGGER_ACTION_END        MBLR_K_TRIGGER_ACTION_END
#define MBLR$K_TRIGGER_OLD_CONTEXT       MBLR_K_TRIGGER_OLD_CONTEXT
#define MBLR$K_TRIGGER_NEW_CONTEXT       MBLR_K_TRIGGER_NEW_CONTEXT
#define MBLR$K_TRIGGER_FOR_EACH_ROW      MBLR_K_TRIGGER_FOR_EACH_ROW
#define MBLR$K_TRIGGER_CONDITION         MBLR_K_TRIGGER_CONDITION
#define MBLR$K_TRIGGER_STATEMENT         MBLR_K_TRIGGER_STATEMENT
#define MBLR$K_TRIGGER_SOURCE            MBLR_K_TRIGGER_SOURCE
#define MBLR$K_RELATION_CONSTRAINT_DEF   MBLR_K_RELATION_CONSTRAINT_DEF
#define MBLR$K_RELATION_CONSTRAINT_END   MBLR_K_RELATION_CONSTRAINT_END
#define MBLR$K_REL_CONSTRAINT_SOURCE     MBLR_K_REL_CONSTRAINT_SOURCE
#define MBLR$K_RELATION_CONSTRAINT       MBLR_K_RELATION_CONSTRAINT
#define MBLR$K_FIELD_CONSTRAINT          MBLR_K_FIELD_CONSTRAINT
#define MBLR$K_CONDITION                 MBLR_K_CONDITION
#define MBLR$K_NOT_NULL                  MBLR_K_NOT_NULL
#define MBLR$K_PRIMARY_KEY               MBLR_K_PRIMARY_KEY
#define MBLR$K_UNIQUE_KEY                MBLR_K_UNIQUE_KEY
#define MBLR$K_FOREIGN_KEY               MBLR_K_FOREIGN_KEY
#define MBLR$K_KEY_END                   MBLR_K_KEY_END
#define MBLR$K_MATCH_ALL                 MBLR_K_MATCH_ALL
#define MBLR$K_MODIFY_ACTION             MBLR_K_MODIFY_ACTION
#define MBLR$K_ERASE_ACTION              MBLR_K_ERASE_ACTION
#define MBLR$K_CASCADE                   MBLR_K_CASCADE
#define MBLR$K_SET_NULL                  MBLR_K_SET_NULL
#define MBLR$K_SET_DEFAULT               MBLR_K_SET_DEFAULT
#define MBLR$K_DELETE_CONSTRAINT         MBLR_K_DELETE_CONSTRAINT
#define MBLR$K_STORAGE_MAP_REORGANIZE    MBLR_K_STORAGE_MAP_REORGANIZE
#define MBLR$K_COLLATION_DEF             MBLR_K_COLLATION_DEF
#define MBLR$K_COLLATION                 MBLR_K_COLLATION
#define MBLR$K_COLLATION_END             MBLR_K_COLLATION_END
#define MBLR$K_FIELD_ACL                 MBLR_K_FIELD_ACL
#define MBLR$K_GRANTEE                   MBLR_K_GRANTEE
#define MBLR$K_USER_VISIBLE_NAME         MBLR_K_USER_VISIBLE_NAME
#define MBLR$K_POSITION                  MBLR_K_POSITION
#define MBLR$K_AFTER_UIC                 MBLR_K_AFTER_UIC
#define MBLR$K_DEFINE_PRIVILEGE          MBLR_K_DEFINE_PRIVILEGE
#define MBLR$K_DELETE_PRIVILEGE          MBLR_K_DELETE_PRIVILEGE
#define MBLR$K_GRANTOR                   MBLR_K_GRANTOR
#define MBLR$K_ACL_END                   MBLR_K_ACL_END
#define MBLR$K_INDEX_FIELD_SIZE          MBLR_K_INDEX_FIELD_SIZE
#define MBLR$K_INDEX_FIELD_MAPPING       MBLR_K_INDEX_FIELD_MAPPING
#define MBLR$K_SEGMENTS                  MBLR_K_SEGMENTS
#define MBLR$K_DEFAULT                   MBLR_K_DEFAULT
#define MBLR$K_FIELD_NAM_LIST            MBLR_K_FIELD_NAM_LIST
#define MBLR$K_FIELD_NAM_END             MBLR_K_FIELD_NAM_END
#define MBLR$K_SINGLE_LEVEL              MBLR_K_SINGLE_LEVEL
#define MBLR$K_CLASSIFICATION            MBLR_K_CLASSIFICATION
#define MBLR$K_CATALOG_DEF               MBLR_K_CATALOG_DEF
#define MBLR$K_CATALOG_ID                MBLR_K_CATALOG_ID
#define MBLR$K_CATALOG_END               MBLR_K_CATALOG_END
#define MBLR$K_SCHEMA_DEF                MBLR_K_SCHEMA_DEF
#define MBLR$K_SCHEMA_ID                 MBLR_K_SCHEMA_ID
#define MBLR$K_SCHEMA_END                MBLR_K_SCHEMA_END
#define MBLR$K_SYNONYM_DEF               MBLR_K_SYNONYM_DEF
#define MBLR$K_SYNONYM_END               MBLR_K_SYNONYM_END
#define MBLR$K_THRESHOLD                 MBLR_K_THRESHOLD
#define MBLR$K_OBJECT_OWNER              MBLR_K_OBJECT_OWNER
#define MBLR$K_SCHEMA_AUTH_ID            MBLR_K_SCHEMA_AUTH_ID
#define MBLR$K_VIEW_NOT_UPDATEABLE       MBLR_K_VIEW_NOT_UPDATEABLE
#define MBLR$K_AREA_SET                  MBLR_K_AREA_SET
#define MBLR$K_UPDATE_NOT_DEFERRABLE     MBLR_K_UPDATE_NOT_DEFERRABLE
#define MBLR$K_INDEX_FIELD_MAPPING_DSC   MBLR_K_INDEX_FIELD_MAPPING_DSC
#define MBLR$K_IMPORT_TABLE              MBLR_K_IMPORT_TABLE
#define MBLR$K_LINK_TABLE                MBLR_K_LINK_TABLE
#define MBLR$K_LINK_NAME                 MBLR_K_LINK_NAME
#define MBLR$K_LINK_DEF                  MBLR_K_LINK_DEF
#define MBLR$K_LINK_CONNECT              MBLR_K_LINK_CONNECT
#define MBLR$K_LINK_END                  MBLR_K_LINK_END
#define MBLR$K_CHANGE_PROXY              MBLR_K_CHANGE_PROXY
#define MBLR$K_DEFINE_PROXY              MBLR_K_DEFINE_PROXY
#define MBLR$K_DELETE_PROXY              MBLR_K_DELETE_PROXY
#define MBLR$K_PROXY_ACCESS_INFO         MBLR_K_PROXY_ACCESS_INFO
#define MBLR$K_LINK_USER                 MBLR_K_LINK_USER
#define MBLR$K_DEFAULT_PARTITION         MBLR_K_DEFAULT_PARTITION
#define MBLR$K_PARTITION_DEF             MBLR_K_PARTITION_DEF
#define MBLR$K_PARTITION_END             MBLR_K_PARTITION_END
#define MBLR$K_PARTITION_QUALIFIER       MBLR_K_PARTITION_QUALIFIER
#define MBLR$K_REIMPORT_TABLE            MBLR_K_REIMPORT_TABLE
#define MBLR$K_UPDATE_TABLE_STATISTICS   MBLR_K_UPDATE_TABLE_STATISTICS
#define MBLR$K_ROUTINE_DEF               MBLR_K_ROUTINE_DEF
#define MBLR$K_ROUTINE_END               MBLR_K_ROUTINE_END
#define MBLR$K_LANGUAGE                  MBLR_K_LANGUAGE
#define MBLR$K_DEFINE_ROUTINE            MBLR_K_DEFINE_ROUTINE
#define MBLR$K_DELETE_ROUTINE            MBLR_K_DELETE_ROUTINE
#define MBLR$K_MODE                      MBLR_K_MODE
#define MBLR$K_MODULE_DEF                MBLR_K_MODULE_DEF
#define MBLR$K_MODULE_END                MBLR_K_MODULE_END
#define MBLR$K_OBJECT_ACL                MBLR_K_OBJECT_ACL
#define MBLR$K_OBJECT_BLR                MBLR_K_OBJECT_BLR
#define MBLR$K_OBJECT_SOURCE             MBLR_K_OBJECT_SOURCE
#define MBLR$K_PARAMETER_MECHANISM       MBLR_K_PARAMETER_MECHANISM
#define MBLR$K_OUTLINE_DEF               MBLR_K_OUTLINE_DEF
#define MBLR$K_OUTLINE_END               MBLR_K_OUTLINE_END
#define MBLR$K_SIGNATURE                 MBLR_K_SIGNATURE
#define MBLR$K_OBJECT_NAME               MBLR_K_OBJECT_NAME
#define MBLR$K_OUTLINE_NAME              MBLR_K_OUTLINE_NAME
#define MBLR$K_MAXIMUM_VALUE             MBLR_K_MAXIMUM_VALUE
#define MBLR$K_MINIMUM_VALUE             MBLR_K_MINIMUM_VALUE
#define MBLR$K_PROFILE_DEF               MBLR_K_PROFILE_DEF
#define MBLR$K_PROFILE_END               MBLR_K_PROFILE_END
#define MBLR$K_DEFINE_PROFILE            MBLR_K_DEFINE_PROFILE
#define MBLR$K_DELETE_PROFILE            MBLR_K_DELETE_PROFILE
#define MBLR$K_END_ATTRIBUTES            MBLR_K_END_ATTRIBUTES
#define MBLR$K_CHANGE_PROFILE            MBLR_K_CHANGE_PROFILE
#define MBLR$K_TYPE_DEF                  MBLR_K_TYPE_DEF
#define MBLR$K_TYPE_END                  MBLR_K_TYPE_END
#define MBLR$K_HIDDEN_OBJECT             MBLR_K_HIDDEN_OBJECT
#define MBLR$K_DELETE_FIELD_CASCADE      MBLR_K_DELETE_FIELD_CASCADE
#define MBLR$K_TRIGGER_INSTEAD_OF        MBLR_K_TRIGGER_INSTEAD_OF
#define MBLR$K_IDENTITY                  MBLR_K_IDENTITY
#define MBLR$K_DEFAULT_SOURCE            MBLR_K_DEFAULT_SOURCE
#define MBLR$K_LAST_ITEM                 MBLR_K_LAST_ITEM
#define MBLR$K_VERSION_1                 MBLR_K_VERSION_1
#define MBLR$K_VERSION_2                 MBLR_K_VERSION_2
#define MBLR$K_FIRST                     MBLR_K_FIRST
#define MBLR$K_LAST                      MBLR_K_LAST
#define MBLR$K_EXT_INDEX_NODE_SIZE       MBLR_K_EXT_INDEX_NODE_SIZE
#define MBLR$K_EXT_INDEX_PERCENT_FILL    MBLR_K_EXT_INDEX_PERCENT_FILL
#define MBLR$K_EXT_AREA_NAME             MBLR_K_EXT_AREA_NAME
#define MBLR$K_EXT_COMPRESSION           MBLR_K_EXT_COMPRESSION
#define MBLR$K_EXT_TRACE                 MBLR_K_EXT_TRACE
#define MBLR$K_EXT_AIJ_BUFFERS           MBLR_K_EXT_AIJ_BUFFERS
#define MBLR$K_EXT_LOCATION              MBLR_K_EXT_LOCATION
#define MBLR$K_EXT_ENTRY_POINT           MBLR_K_EXT_ENTRY_POINT
#define MBLR$K_EXT_NUMBER_OF_IOS         MBLR_K_EXT_NUMBER_OF_IOS
#define MBLR$K_EXT_CPU_INSTRUCTIONS      MBLR_K_EXT_CPU_INSTRUCTIONS
#define MBLR$K_EXT_NOTIFY_ENTRY_POINT    MBLR_K_EXT_NOTIFY_ENTRY_POINT
#define MBLR$K_EXT_CLEANUP               MBLR_K_EXT_CLEANUP
#define MBLR$K_EXT_MIN_RUN_LENGTH        MBLR_K_EXT_MIN_RUN_LENGTH
#define MBLR$K_EXT_COMP_SPACE_OCTETS     MBLR_K_EXT_COMP_SPACE_OCTETS
#define MBLR$K_EXT_HASH_TYPE             MBLR_K_EXT_HASH_TYPE
#define MBLR$K_EXT_MAINTENANCE           MBLR_K_EXT_MAINTENANCE
#define MBLR$K_EXT_VARIANT               MBLR_K_EXT_VARIANT
#define MBLR$K_EXT_DEFAULT_TXN           MBLR_K_EXT_DEFAULT_TXN
#define MBLR$K_EXT_SQL_PARAMETERS        MBLR_K_EXT_SQL_PARAMETERS
#define MBLR$K_EXT_LANG_TBL_DEPENDENCY   MBLR_K_EXT_LANG_TBL_DEPENDENCY
#define MBLR$K_EXT_COMPILE_OPTIONS       MBLR_K_EXT_COMPILE_OPTIONS
#define MBLR$K_EXT_SECURE_LOCATION       MBLR_K_EXT_SECURE_LOCATION
#define MBLR$K_EXT_SQL_PARAM_STYLE       MBLR_K_EXT_SQL_PARAM_STYLE
#define MBLR$K_EXT_EXECUTION_SITE        MBLR_K_EXT_EXECUTION_SITE
#define MBLR$K_EXT_NOTIFY_CONN           MBLR_K_EXT_NOTIFY_CONN
#define MBLR$K_EXT_NOTIFY_TRAN           MBLR_K_EXT_NOTIFY_TRAN
#define MBLR$K_EXT_NOTIFY_STMT           MBLR_K_EXT_NOTIFY_STMT
#define MBLR$K_EXT_NOTIFY_ACTIVATE       MBLR_K_EXT_NOTIFY_ACTIVATE
#define MBLR$K_EXT_DEACTIVATE_IMAGE      MBLR_K_EXT_DEACTIVATE_IMAGE
#define MBLR$K_EXT_TEMPORARY_DDL         MBLR_K_EXT_TEMPORARY_DDL
#define MBLR$K_EXT_SORT_TYPE             MBLR_K_EXT_SORT_TYPE
#define MBLR$K_EXT_SQL_SEMANTICS         MBLR_K_EXT_SQL_SEMANTICS
#define MBLR$K_EXT_LIMIT_COMP_CPU_TIME   MBLR_K_EXT_LIMIT_COMP_CPU_TIME
#define MBLR$K_EXT_LIMIT_COMP_TIME       MBLR_K_EXT_LIMIT_COMP_TIME
#define MBLR$K_EXT_LIMIT_QRY_ROWS        MBLR_K_EXT_LIMIT_QRY_ROWS
#define MBLR$K_EXT_TXN_MODES             MBLR_K_EXT_TXN_MODES
#define MBLR$K_EXT_SECURITY_DOMAIN       MBLR_K_EXT_SECURITY_DOMAIN
#define MBLR$K_EXT_ACCESS_PASSWORD       MBLR_K_EXT_ACCESS_PASSWORD
#define MBLR$K_EXT_THREADSAFE            MBLR_K_EXT_THREADSAFE
#define MBLR$K_EXT_PROPAGATE_NULL        MBLR_K_EXT_PROPAGATE_NULL
#define MBLR$K_EXT_OS_SECURITY_ID        MBLR_K_EXT_OS_SECURITY_ID
#define MBLR$K_EXT_OS_SECURITY_ID_W      MBLR_K_EXT_OS_SECURITY_ID_W
#define MBLR$K_EXT_CARD_COLLECT          MBLR_K_EXT_CARD_COLLECT
#define MBLR$K_EXT_PRIOR_PARTITION_BLR   MBLR_K_EXT_PRIOR_PARTITION_BLR
#define MBLR$K_EXT_DEFAULT2_SOURCE       MBLR_K_EXT_DEFAULT2_SOURCE
#define MBLR$K_EXT_VALID_IF_NAME         MBLR_K_EXT_VALID_IF_NAME
#define MBLR$K_EXT_COLLATION_NAME        MBLR_K_EXT_COLLATION_NAME
#define MBLR$K_EXT_LOCAL_ROUTINE         MBLR_K_EXT_LOCAL_ROUTINE
#define MBLR$K_EXT_INDEX_CARDINALITY     MBLR_K_EXT_INDEX_CARDINALITY
#define MBLR$K_EXT_JAVA_BYTECODE         MBLR_K_EXT_JAVA_BYTECODE
#define MBLR$K_EXT_JAVA_JARNAME          MBLR_K_EXT_JAVA_JARNAME
#define MBLR$K_EXT_JAVA_CLASSNAME        MBLR_K_EXT_JAVA_CLASSNAME
#define MBLR$K_EXT_LAST_ITEM             MBLR_K_EXT_LAST_ITEM
#define RDB$K_SQLPAR_VERSION             RDB_K_SQLPAR_VERSION
#define RDB$K_SQLPAR_MIN                 RDB_K_SQLPAR_MIN
#define RDB$K_SQLPAR_SQLCODE_INDEX       RDB_K_SQLPAR_SQLCODE_INDEX
#define RDB$K_SQLPAR_SQLSTATE_INDEX      RDB_K_SQLPAR_SQLSTATE_INDEX
#define RDB$K_SQLPAR_SEND_MSG            RDB_K_SQLPAR_SEND_MSG
#define RDB$K_SQLPAR_RCV_MSG             RDB_K_SQLPAR_RCV_MSG
#define RDB$K_SQLPAR_ALWAYS_NULL_INDEX   RDB_K_SQLPAR_ALWAYS_NULL_INDEX
#define RDB$K_SQLPAR_NEVER_NULL_INDEX    RDB_K_SQLPAR_NEVER_NULL_INDEX
#define RDB$K_SQLPAR_OPEN_ACTION         RDB_K_SQLPAR_OPEN_ACTION
#define RDB$K_SQLPAR_CLOSE_ACTION        RDB_K_SQLPAR_CLOSE_ACTION
#define RDB$K_SQLPAR_DELETE_ACTION       RDB_K_SQLPAR_DELETE_ACTION
#define RDB$K_SQLPAR_FETCH_ACTION        RDB_K_SQLPAR_FETCH_ACTION
#define RDB$K_SQLPAR_INSERT_ACTION       RDB_K_SQLPAR_INSERT_ACTION
#define RDB$K_SQLPAR_UPDATE_ACTION       RDB_K_SQLPAR_UPDATE_ACTION
#define RDB$K_SQLPAR_MAX                 RDB_K_SQLPAR_MAX
#define RDB$K_OTYP_MS_RELATION           RDB_K_OTYP_MS_RELATION
#define RDB$K_OTYP_MS_VIEW               RDB_K_OTYP_MS_VIEW
#define RDB$K_OTYP_MS_COLLATION          RDB_K_OTYP_MS_COLLATION
#define RDB$K_OTYP_MS_CONSTRAINT         RDB_K_OTYP_MS_CONSTRAINT
#define RDB$K_OTYP_MS_FIELD              RDB_K_OTYP_MS_FIELD
#define RDB$K_OTYP_MS_INDEX              RDB_K_OTYP_MS_INDEX
#define RDB$K_OTYP_MS_STORAGE_MAP        RDB_K_OTYP_MS_STORAGE_MAP
#define RDB$K_OTYP_MS_TRIGGER            RDB_K_OTYP_MS_TRIGGER
#define RDB$K_OTYP_MS_SEQUENCE           RDB_K_OTYP_MS_SEQUENCE
#define RDB$K_OTYP_MS_MODULE             RDB_K_OTYP_MS_MODULE
#define RDB$K_OTYP_MS_ROUTINE            RDB_K_OTYP_MS_ROUTINE
#define RDB$K_OTYP_MS_TYPE               RDB_K_OTYP_MS_TYPE
#define RDB$K_OTYP_UNKNOWN               RDB_K_OTYP_UNKNOWN
#define RDB$K_OTYP_DIRECTORY             RDB_K_OTYP_DIRECTORY
#define RDB$K_OTYP_FIELD                 RDB_K_OTYP_FIELD
#define RDB$K_OTYP_FUNCTION              RDB_K_OTYP_FUNCTION
#define RDB$K_OTYP_LIBRARY               RDB_K_OTYP_LIBRARY
#define RDB$K_OTYP_MODULE                RDB_K_OTYP_MODULE
#define RDB$K_OTYP_PROCEDURE             RDB_K_OTYP_PROCEDURE
#define RDB$K_OTYP_RELATION              RDB_K_OTYP_RELATION
#define RDB$K_OTYP_SEQUENCE              RDB_K_OTYP_SEQUENCE
#define RDB$K_OTYP_SYNONYM               RDB_K_OTYP_SYNONYM
#define RDB$K_OTYP_TYPE                  RDB_K_OTYP_TYPE
#define RDB$K_OTYP_VIEW                  RDB_K_OTYP_VIEW
#define RDB$K_OTYP_OUTLINE               RDB_K_OTYP_OUTLINE
#define RDB$K_OTYP_TRIGGER               RDB_K_OTYP_TRIGGER
#define RDB$K_OTYP_CONSTRAINT            RDB_K_OTYP_CONSTRAINT
#define RDB$K_OTYP_USER                  RDB_K_OTYP_USER
#define RDB$K_OTYP_ROLE                  RDB_K_OTYP_ROLE
#define RDB$K_OTYP_PROFILE               RDB_K_OTYP_PROFILE
#define RDB$K_OTYP_COLUMN                RDB_K_OTYP_COLUMN
#define RDB$K_OTYP_INDEX                 RDB_K_OTYP_INDEX
#define RDB$K_OTYP_STORAGE_MAP           RDB_K_OTYP_STORAGE_MAP
#define MBLR$K_STORAGE_MAP_REORG_FIRST   MBLR_K_STORAGE_MAP_REORG_FIRST
#define MBLR$K_STORAGE_MAP_REORG_NONE    MBLR_K_STORAGE_MAP_REORG_NONE
#define MBLR$K_STORAGE_MAP_REORG_AREAS   MBLR_K_STORAGE_MAP_REORG_AREAS
#define MBLR$K_STORAGE_MAP_REORG_PAGES   MBLR_K_STORAGE_MAP_REORG_PAGES
#define MBLR$K_STORAGE_MAP_REORG_PARTS   MBLR_K_STORAGE_MAP_REORG_PARTS
#define MBLR$K_STORAGE_MAP_REORG_LAST    MBLR_K_STORAGE_MAP_REORG_LAST
#define MBLR$K_FILL_MIN                  MBLR_K_FILL_MIN
#define MBLR$K_FILL_RANDOM               MBLR_K_FILL_RANDOM
#define MBLR$K_FILL_SEQUENTIAL           MBLR_K_FILL_SEQUENTIAL
#define MBLR$K_FILL_MAX                  MBLR_K_FILL_MAX
#define MBLR$K_HASH_USER_DEFINED         MBLR_K_HASH_USER_DEFINED
#define MBLR$K_HASH_CRC                  MBLR_K_HASH_CRC
#define MBLR$K_HASH_MODULO               MBLR_K_HASH_MODULO
#define MBLR$K_SORT_UNRANKED             MBLR_K_SORT_UNRANKED
#define MBLR$K_SORT_P_RANKED_BSTAR       MBLR_K_SORT_P_RANKED_BSTAR
#define MBLR$K_SORT_P_RANKED_BPLUS       MBLR_K_SORT_P_RANKED_BPLUS
#define MBLR$K_SORT_P_RANKED_HYBRID      MBLR_K_SORT_P_RANKED_HYBRID
#define MBLR$K_MAINT_ENABLED             MBLR_K_MAINT_ENABLED
#define MBLR$K_MAINT_DISABLED            MBLR_K_MAINT_DISABLED
#define MBLR$K_MAINT_DEFERRED            MBLR_K_MAINT_DEFERRED
#define MBLR$K_COLLECT_DISABLED          MBLR_K_COLLECT_DISABLED
#define MBLR$K_COLLECT_ENABLED           MBLR_K_COLLECT_ENABLED
#define MBLR$K_COLLECT_FULL              MBLR_K_COLLECT_FULL
#define MBLR$K_PARAM_STYLE_GENERAL       MBLR_K_PARAM_STYLE_GENERAL
#define MBLR$K_PARAM_STYLE_SQL           MBLR_K_PARAM_STYLE_SQL
#define MBLR$K_PARAM_STYLE_JAVA          MBLR_K_PARAM_STYLE_JAVA
#define RDB$K_PART_UPDATE_STATIC         RDB_K_PART_UPDATE_STATIC
#define RDB$K_PART_UPDATE_DYNAMIC        RDB_K_PART_UPDATE_DYNAMIC
#define RDB$K_PART_NOUPDATE              RDB_K_PART_NOUPDATE
#endif
#endif