database.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once
#ifndef __databaseH__
#define __databaseH__

#include <Mstn\MstnDefs.h>
#include "dbdefs.h"

/*----------------------------------------------------------------------+
|                                                                       |
|   Defines                                                             |
|                                                                       |
+----------------------------------------------------------------------*/
#define DB_PACKET_SIZE          2048    /* the packet size for the DB IPC */
#define DB_MORE_PACKETS            1
#define DB_LAST_PACKET             2
#define DB_DATABASE_NAME_SIZE     64    /* size of a database name */
#define DB_TABLE_NAME_SIZE        MAX_TABLE_LENGTH
                                        /* size of a database table name */
#define DB_COLUMN_NAME_SIZE       MAX_COLUMN_LENGTH
                                        /* size of a database column name */
#define DB_FORM_EXT               10
#define VAR_STRING                 0
#define VAR_NAME_STRING            1
#define CHARACTER_DATA             0    /* DEFAULT, return data in character form */
#define RAW_DATA                   1    /* do not coerce to character, return raw data */
#define MAX_OPEN_CURSORS          10
#define MAX_ERROR_LENGTH         512    /* max length for error return strings */
#define SQL_LOOKUP              -100    /* SQL error; look in errorInformation */
#define MAX_ENV_VAR_LENGTH       512    /* max length for value in an EnvVarRequest */
#define DB_COPY_TABLE_LENGTH    2048    /* length of the sql statement in a copy table */
#define DB_MAX_TYPE_LENGTH       128    /* max size for sql stmt in extract stmt type */
#define MAX_DATE_SEPARATOR_LEN    15

/* To insure that space is not always dynamically allocated (calloc) buffers in */
/*  the IPC and SQL modules are allocated of the stack with the size below */
#define DB_DEFAULT_BUFFER_SIZE  2048

/* if default was not enough and total additional space is not known, the below */
/*  amount of additonal space will be realloced */
#define DB_BUFFER_REALLOC_SIZE  2048

/* sql buffer realloc size, only for the dynamic sql buffer reallocation */
#define DB_SQLBUF_REALLOC_SIZE  256


/*----------------------------------------------------------------------+
|                                                                       |
|   Miscellaneous                                                       |
|                                                                       |
+----------------------------------------------------------------------*/
/* database server types */
#define XBASE_SERVER        1
#define ORACLE_SERVER       2
#define ORACLE_STD_SERVER   ORACLE_SERVER
#define ORACLE_DOS_SERVER   3
#define ORACLE_WIN_SERVER   4
#define INFORMIX_SERVER     5
#define RIS_SERVER          6
#define ODBC_SERVER         7
#define WINCON_SERVER       ORACLE_WIN_SERVER
#define UNKNOWN_SERVER      8
#define SYBASE_SERVER       9
#define CTMORCL_SERVER      10
#define OLEDB_SERVER        11
#define BUDBC_SERVER        12

/* ODBC database type defines */
#define ODBC_UNKNOWN        1
#define ODBC_FLATFILE       2
#define ODBC_ORACLE         3
#define ODBC_INFORMIX       4
#define ODBC_ACCESS         5
#define ODBC_SQLSERVER      6
#define ODBC_SYBASE         7

/* flat file database definitions */
#define ODBC_BF_DBASE   (0x00000001 << 0)
#define ODBC_BF_BTRIEVE (0x00000001 << 1)
#define ODBC_BF_PARADOX (0x00000001 << 2)
#define ODBC_BF_EXCEL   (0x00000001 << 3)
#define ODBC_BF_TEXT    (0x00000001 << 4)

/* return values for preprocess step */
#define NOT_HANDLED     1

#define NOT_ORACLE_MSDOS (!(serverType == ORACLE_DOS_SERVER))
#define ORACLE_DOS (serverType == ORACLE_DOS_SERVER)
#define DB_USES_WINCON (serverType == WINCON_SERVER)

/*----------------------------------------------------------------------+
|                                                                       |
|   External server debug defines                                       |
|                                                                       |
+----------------------------------------------------------------------*/
#define DEBUG_ON                (0x0001 << 0)
#define EXT_DEBUG_ON            (0x0001 << 1)
#define IPC_DEBUG_ON            (0x0001 << 2)

/*----------------------------------------------------------------------+
|                                                                       |
|   IPC service requests.                                               |
|                                                                       |
+----------------------------------------------------------------------*/
#define IPC_RegisterHandler     1

/*----------------------------------------------------------------------+
|                                                                       |
|   Message fields.                                                     |
|                                                                       |
+----------------------------------------------------------------------*/
#define DBFORM_DAS              1
#define DBFORM_EDITAE           2
#define DBFORM_REVIEW           3
#define DBFORM_FORMCMD          4

/*----------------------------------------------------------------------+
|                                                                       |
|   Message fields.                                                     |
|                                                                       |
+----------------------------------------------------------------------*/
#define FIELD_Status            1
#define FIELD_Error             2
#define FIELD_Message           3
#define FIELD_DebugWindow       4

/*----------------------------------------------------------------------+
|                                                                       |
|   SQL statement types.                                                |
|                                                                       |
+----------------------------------------------------------------------*/
#define DB_MALFORMED_STMT     1
#define DB_UNKNOWN_STMT       2
#define DB_SELECT_STMT        3
#define DB_UPDATE_STMT        4
#define DB_CONNECT_STMT       5
#define DB_DISCONNECT_STMT    6
#define DB_SQLFORMS_STMT      7
#define DB_RELOAD_STMT        8
#define DB_INSERT_STMT        9
#define DB_COMMIT_STMT        10
#define DB_ROLLBACK_STMT      11
#define DB_HANDLES_STMT       12
#define DB_DELETE_STMT        13

/*----------------------------------------------------------------------+
|                                                                       |
|   Cursor IDs                                                          |
|                                                                       |
+----------------------------------------------------------------------*/
#define DB_CURSOR_ID_0              0
#define DB_CURSOR_ID_1              1
#define DB_CURSOR_ID_2              2
#define DB_CURSOR_ID_3              3
#define DB_CURSOR_ID_4              4
#define DB_CURSOR_ID_5              5
#define DB_CURSOR_ID_6              6
#define DB_CURSOR_ID_7              7
#define DB_CURSOR_ID_8              8
#define DB_CURSOR_ID_9              9
#define DB_DESRIBE_SQLDA           10   /* the sqlda used in a describe */

/*----------------------------------------------------------------------+
|                                                                       |
|   Message types.                                                      |
|                                                                       |
+----------------------------------------------------------------------*/
#define MTYPE_ServiceRequest            1
#define MTYPE_ServiceRequestMore        2   /* one of many service requests */
#define MTYPE_ServiceRequestLast        3   /* last service request */
#define MTYPE_ServiceAcknowledge        4
#define MTYPE_ServiceAcknowledgeMore    5   /* one of many service acks with data */
#define MTYPE_ServiceAcknowledgeLast    6   /* last service ack with data */
#define MTYPE_ServiceAcknowledgeNoData  7   /* a service ack without data */
#define MTYPE_CallBackRequest           8
#define MTYPE_CallBackAcknowledge       9

/*----------------------------------------------------------------------+
|                                                                       |
|   Database service requests.                                          |
|                                                                       |
+----------------------------------------------------------------------*/
#define DS_DatabaseProfile           1
#define DS_OpenDatabase              2
#define DS_CloseDatabase             3
#define DS_Terminate                 4
#define DS_DescribeDatabase          5
#define DS_DescribeTable             6
#define DS_DescribeColumn            7
#define DS_CommitTransaction         8
#define DS_RollbackTransaction       9
#define DS_ProcessStatement          10
#define DS_OpenCursor                11
#define DS_FetchRow                  12
#define DS_CloseCursor               13
#define DS_ProcessForm               14
#define DS_GetErrorInformation       15
#define DS_AdditionalRequest         16
#define DS_DebugMode                 17
#define DS_CopyTable                 18
#define DS_LockTable                 19
#define DS_SetAE                     20 /* server to loader only */
#define DS_CreateDABuffer            21 /* Note: NEW Msg, not in Betas */
#define DS_SetMsforms                22 /* server to loader only */

/*----------------------------------------------------------------------+
|                                                                       |
|   CallBack requests.                                                  |
|                                                                       |
+----------------------------------------------------------------------*/
#define CALLBACK_DebugMessage        1
#define CALLBACK_EnvVarRequest       2
#define CALLBACK_GetXbaseName        3
#define CALLBACK_SendPID             4
#define CALLBACK_MSWindowPriority    5
#define CALLBACK_FindDBFile          6

/*----------------------------------------------------------------------+
|                                                                       |
|   Additional request (AR) defines.  Used with DS_AdditionalRequest.   |
|                                                                       |
+----------------------------------------------------------------------*/
#define AR_MaxMSLink                1
#define AR_CopyRowToAE              2
#define AR_CopyRowToReport          3
#define AR_SimpleSelect             4
#define AR_OpenCursorXbase          5
#define AR_FetchRowXbase            6
#define AR_CloseCursorXbase         7
#define AR_SetRawData               8
#define AR_GetRawData               9
#define AR_DelPendingVersion       10
#define AR_ExecPendingQuery        11
/*----------------------------------------------------------------------+
|                                                                       |
|   Additional request (AR) structure typedefs.                         |
|                                                                       |
+----------------------------------------------------------------------*/
struct AllocdStmt 
    {
    WString     *stmt;
    };

struct MaxMSLink
    {
    long         requestType;                   /* The AR request type */
    UInt32       maxMSLink;                     /* the max mslink in the table */
    WChar        tableName[DB_TABLE_NAME_SIZE]; /* table name to get max mslink from */
    };

/* for Xbase performance improvements */
struct CopyRowToAERequest
    {
    long        requestType;
    UInt32      *mslinkP;
    WCharCP     whereValue;
    WCharCP     whereFieldName;
    WCharCP     sourceTableName;
    WCharCP     destTableName;
    WCharCP     query;
    bool        zeroMslink;
    };

/* for Xbase performance improvements */
struct CopyRowToReportRequest
    {
    long        requestType;
    long        mslink;
    WChar       *sourceTableName;
    WChar       *destTableName;
    };

/* for Xbase performance improvements */
struct SimpleSelectAR
    {
    long        requestType;
    long        resultSize;
    long        numValues;
    bool        breakResult;
    WChar       ***brokenResult;
    WCharP      result;
    MS_sqlda    *sqlda;
    WChar       *stmt;
    bool        isMalloced;
    };

/* for Xbase performance improvements */
struct OpenCursorXbaseAR
    {
    long        requestType;
    WChar       *stmt;
    bool        getColInfo;
    bool        isMalloced;
    };

/* for Xbase performance improvements */
struct FetchRowXbaseAR
    {
    long        requestType;
    MS_sqlda    *sqldaP;
    };

/* for Xbase performance improvements */
struct CloseCursorXbaseAR
    {
    long        requestType;
    };

struct VarRawAR
    {
    long        requestType;
    byte        *dataP;
    short       length;
    long        primaryKey;
    int         updateMode;
    WChar       columnName [MAX_COLUMN_LENGTH];
    WChar       tableName [MAX_TABLE_LENGTH];
    WChar       keyName [MAX_COLUMN_LENGTH];
    };

/* For ProjectWise Managed Tables. */
/* Get Pending rows */
struct PendingRowRequest
    {
    long        requestType;
    long        cursorId;
    long        versionSet;
    WChar       sqlStatement[8000];
    };

/* Delete Pending Rows */
struct DeletePendingRows
    {
    long        requestType;
    long        versionId;
    long        delCount;
    WChar       sqlStatement[8000];
    };



/*----------------------------------------------------------------------+
|                                                                       |
|   IPC typedefs.                                                       |
|                                                                       |
+----------------------------------------------------------------------*/
struct  DatabaseServiceHandler
    {
    WChar       taskID[TASK_ID_SIZE];       /* name of task */
    MdlDesc     *mdlFileDescr;              /* mdl application handing requests */
    void        *pFunction;                 /* entry point in this application */
    };

struct IPCService
    {
    UInt32                      type;       /* type of request */
    DatabaseServiceHandler      handler;    /* service handler */
    };

struct ServiceName
    {
    WChar       *name;                      /* name of database service */
    UInt32      type;                       /* service code */
    };

/*----------------------------------------------------------------------+
|                                                                       |
|   Service name table.                                                 |
|                                                                       |
+----------------------------------------------------------------------*/
#if defined (GLOBAL_DEFINITIONS)
ServiceName serviceNameTable[]=
    {
    {L"DS_DatabaseProfile",      DS_DatabaseProfile},
    {L"DS_OpenDatabase",         DS_OpenDatabase},
    {L"DS_CloseDatabase",        DS_CloseDatabase},
    {L"DS_Terminate",            DS_Terminate},
    {L"DS_DescribeDatabase",     DS_DescribeDatabase},
    {L"DS_DescribeTable",        DS_DescribeTable},
    {L"DS_DescribeColumn",       DS_DescribeColumn},
    {L"DS_CommitTransaction",    DS_CommitTransaction},
    {L"DS_RollbackTransaction",  DS_RollbackTransaction},
    {L"DS_ProcessStatement",     DS_ProcessStatement},
    {L"DS_OpenCursor",           DS_OpenCursor},
    {L"DS_FetchRow",             DS_FetchRow},
    {L"DS_CloseCursor",          DS_CloseCursor},
    {L"DS_ProcessForm",          DS_ProcessForm},
    {L"DS_GetErrorInformation",  DS_GetErrorInformation},
    {L"DS_AdditionalRequest",    DS_AdditionalRequest},
    {L"DS_DebugMode",            DS_DebugMode},
    {L"DS_CopyTable",            DS_CopyTable},
    {L"DS_LockTable",            DS_LockTable},
    {L"DS_SetAE",                DS_SetAE},
    {L"DS_CreateDABuffer",       DS_CreateDABuffer},
    {L"DS_SetMsforms",           DS_SetMsforms}
    };
#endif

/*----------------------------------------------------------------------+
|                                                                       |
|   Service requests.                                                   |
|                                                                       |
+----------------------------------------------------------------------*/
struct BrandProfile     // May need to remain as char fields
    {
    WChar       brandName[32];      /* name of brand (Oracle, dBASE, ...) */
    WChar       serverName[32];     /* name of the database server executable */
    WChar       version[32];        /* version of database */
    long        odbcDBType;         /* ODBC underlying database type */
    };

struct AccessProfile
    {
    long            hostnameRequired;   /* host name required for login */
    long            usernameRequired;   /* user name required for login */
    long            passwordRequired;   /* password required for login */
    long            optionString;       /* option string supported */
    };

struct DataType
    {
    long            supported;          /* data type supported */
    char            name[32];           /* vendor name */           // CHAR_OK
    };

#ifdef charType
    #error The dloadbsi.h #defines of charType, floatType, et cetera, will corrupt the definition of DataTypeProfile which has members with those same names. Figure out how to get rid of the xxxxType #defines or make sure that they only occur after including database.h.
#endif

struct DataTypeProfile
    {
    DataType            m_charType;       /* CHAR (n); fixed length */
    DataType            m_varcharType;    /* VARCHAR (n); variable length */
    DataType            m_floatType;      /* REAL; single precision*/
    DataType            m_doubleType;     /* DOUBLE; double precision */
    DataType            m_intType;        /* INTEGER; 32 bit integer */
    DataType            m_shortType;      /* SMALLINT; 16 bit integer */
    DataType            m_numericType;    /* NUMERIC (p, s); fixed point */
    DataType            m_decimalType;    /* DECIMAL (p, s); fixed point */
    DataType            m_dateType;       /* DATE */
    DataType            m_timeType;       /* TIME */
    DataType            m_datetimeType;   /* DATETIME; absolute (date + time) */
    DataType            m_intervalType;   /* INTERVAL; delta (date + time) */
    DataType            m_rawType;        /* RAW (n); binary data; */
    DataType            m_booleanType;    /* BOOLEAN; logical */
    DataType            m_nationalType;   /* NCHAR; national character string */
    DataType            m_rowid;          /* ROWID; pseudo column primary key */
    };

struct FunctionProfile
    {
    long            max;                /* min () function supported */
    long            min;                /* max () function supported */
    long            count;              /* count () function supported */
    long            sum;                /* sum () function supported */
    long            avg;                /* avg () function supported */
    };

struct TransactionProfile
    {
    long            supported;          /* transactions supported */
    };

struct FormsProfile
    {
    long            supported;                  /* screen forms supported */
    long            fileOutput;                 /* can generate text file output */
    WChar           fileExt[DB_FORM_EXT];       /* file extension for forms, .frm .fmt */
    };

struct GraphicsProfile
    {
    UShort          primarySignature;    /* priamry user data signature */
    UShort          secondarySignature;  /* secondary user data signature */
    long            saveAccessString;    /* saved in design file */
    long            applicationLevel;    /* level for access string */
    };

struct SQLProfile
    {
    long            ANSICompatible;
    bool            cursorCommitClose;
    bool            cursorRollbackClose;
    WChar           leftDateSeparator[MAX_DATE_SEPARATOR_LEN];
    WChar           rightDateSeparator[MAX_DATE_SEPARATOR_LEN];
    };

struct DatabaseProfile
    {
    BrandProfile            brand;          /* brand of RDBMS */
    AccessProfile           accessProfile;  /* access method */
    DataTypeProfile         types;          /* supported data types */
    SQLProfile              sql;            /* SQL support and extensions */
    FunctionProfile         functions;      /* aggregate function support */
    TransactionProfile      transactions;   /* transaction support */
    FormsProfile            forms;          /* screen forms support */
    GraphicsProfile         graphics;       /* design file parameters */
    bool                    passSqlda;
    };

struct OpenDatabase
    {
    WChar       text[512];                  /* the text of the open request */
    };

struct DescribeDatabase
    {
#if defined (_M_X64)
    UInt64       descriptionLength;
#else
    UInt32       descriptionLength;
#endif
    WChar       *description;
    };

struct DescribeTable
    {
    long         descriptionLength;
    WChar       *description;
    WChar        tableName[DB_TABLE_NAME_SIZE];
    };

struct DescribeColumn
    {
    WChar        tableName[DB_TABLE_NAME_SIZE];
    ColumnDescr  columnDescr;
    };

struct ProcessStatement
    {
#if defined (_M_X64)
    UInt64       statementLength;
#else
    UInt32       statementLength;
#endif
    WChar       *statement;
    };

struct OpenCursor
    {
#if defined (_M_X64)
    UInt64       descriptionLength;
#else
    UInt32       descriptionLength;
#endif
    WChar       *description;
    long         cursorID;
    };

struct FetchRow
    {
    long         rowLength;                 /* <=  length of data */
    WChar       *row;                       /* <=  the row that was fetched */
    long         cursorID;                  /*  => the ID of the cursor to fetch from */
    short        returnDataType;            /*  => type of data to return, char or raw */
    };

struct CloseCursor
    {
    long         cursorID;                  /*  => the ID of the cursor to close */
    };

struct ProcessForm
    {
    WChar        arguments[256];
    WChar        formName[256];
    WChar        tableName[64];
    WChar        dosWindow[8];
    long         textMode;
    long         noStdOut;

    };

struct ErrorInformation
    {
    long         code;                      /* <=> SQL error code */
    WChar        message[MAX_ERROR_LENGTH]; /* <=  text of error message */
    };

struct AdditionalRequest
    {
    long         requestLength;             /* <=> Length of text */
    WChar       *request;                   /* <=> The text of developer supplied request */
    };

struct DebugMode
    {
    long         mode;                      /*  => The new debug mode */
    };

struct CopyTable
    {
    WChar        fromTableName[DB_TABLE_NAME_SIZE];     /* The table name to copy from */
    WChar        toTableName[DB_TABLE_NAME_SIZE];       /* The table name to copy to */
    };

struct LockTable
    {
    WChar        tableName[DB_TABLE_NAME_SIZE];         /* The table name to lock */
    };

/* The following request is only used for communication between
   server.ma and dbload.ma - it never reachs the external server
*/
struct SetAE
    {
    WChar       aeTableName[DB_TABLE_NAME_SIZE];
    };

/* The following request is new for the Version 5 release of the toolkit
   (3/94).  It was not present in the Beta versions of the toolkit.
   Database developers must handle this message if the server needs to work
   with Displayable Attributes in Forms mode
*/
struct CreateDABuffer
    {
    long    numLines;                   /* <= # lines to read from frm file */
    WChar   dasFormFile[MAXFILELENGTH]; /*  => the form name */
                                        /* <=  the qualified path name to   */
                                        /*     the DAS form output file */
    };

/* The following request is only used for communication between
   server.ma and dbload.ma - it never reachs the external server
*/
struct SetMsforms
    {
    WChar       msformsTableName[DB_TABLE_NAME_SIZE];
    };

/*----------------------------------------------------------------------+
|                                                                       |
|   Service message.                                                    |
|                                                                       |
+----------------------------------------------------------------------*/
struct ServiceHeader
    {
    long        status;             /* <=  return status */
    UInt32      type;               /*  => type of request */
    size_t      length;             /* <=> length of message */
    bool        isCallocd;          /* <=  whether memory in structure was calloc'd */
    size_t      callocdLength;      /* <=  if isCallocd, this is the new size */
    long        databaseID;         /*  =>  id of target database (FUTURE EXPANSION) */
    };

struct DatabaseService
    {
    ServiceHeader   header;                 /* <=> message header */
    union
        {
        DatabaseProfile     databaseProfile;
        OpenDatabase        openDatabase;
        DescribeDatabase    describeDatabase;
        DescribeTable       describeTable;
        DescribeColumn      describeColumn;
        ProcessStatement    processStatement;
        OpenCursor          openCursor;
        FetchRow            fetchRow;
        CloseCursor         closeCursor;
        ProcessForm         processForm;
        ErrorInformation    errorInformation;
        AdditionalRequest   additionalRequest;
        DebugMode           debugMode;
        CopyTable           copyTable;
        LockTable           lockTable;
        SetAE               setAE;
        CreateDABuffer      createDABuffer;
        SetMsforms          setMsforms;
        } u;
    };

struct RequestWithPtr
    {
    ServiceHeader   header;
    size_t          length;
    WChar          *data;
    long            cursorID;
    };

struct BufferWithoutPtr
    {
    long            bufferLength;
    ServiceHeader   header;
    long            length;
    WChar           data[1];
    };

struct BufferWithCursorID
    {
    long            bufferLength;
    ServiceHeader   header;
    long            length;
    long            cursorID;
    WChar           data[1];
    };

struct BufferWithLength
    {
    long            bufferLength;
    WChar           data[1];
    };

/*----------------------------------------------------------------------+
|                                                                       |
|   CallBack requests.                                                  |
|                                                                       |
+----------------------------------------------------------------------*/
struct StatusMessage
    {
    long            field;                      /* <= field for message output */
    WChar           string[512];                /* <= user message */
    };

struct EnvVarRequest
    {
    WChar           variable[64];               /* <=  environment variable */
    WChar           value[MAX_ENV_VAR_LENGTH];  /*  => value of environment variable */
    };

struct XbaseNameRequest
    {
    WChar           name[MAXFILELENGTH];    /* <=>  databaseName */
    };

struct ExternalPID
    {
    ProcessID       pid;                    /* <= process ID of external Server */
    };

struct MSWindowPriority
    {
    bool            activePriority;         /* <= MS window priority High T/F */
    };

struct FindDBFile
    {
    WChar   fileName[MAXFILELENGTH];        /* <=  file to find   */
                                            /*  => path to file   */
    WChar   fileExt[MAXEXTENSIONLENGTH];    /*  => file Extension */
    };

/*----------------------------------------------------------------------+
|                                                                       |
|   CallBack message.                                                   |
|                                                                       |
+----------------------------------------------------------------------*/
struct CallBackHeader
    {
    long        status;                         /* <=> return status */
    UInt32      type;                           /* <=> type of request */
    UInt32      length;                         /* <=> length of message */
    };

struct ServerCallBack
    {
    CallBackHeader   header;                    /* <=> message header */
    union
        {
        StatusMessage       message;            /* <=> */
        EnvVarRequest       envVarRequest;      /* <=> */
        XbaseNameRequest    xbaseNameRequest;   /* <=> */
        ExternalPID         externalPID;        /* <=  no ack */
        MSWindowPriority    msWindowPriority;   /* <=> */
        FindDBFile          findDBFile;         /* <=> */
        } u;
    };

/*----------------------------------------------------------------------+
|                                                                       |
|   Descriptor message (mdl -> Server)                                  |
|                                                                       |
+----------------------------------------------------------------------*/
struct ServerDescrMessageHdr
    {
    short   columns;
    short   rows;
    short   items;
    };

struct ServerDescriptorMessage
    {
    ServerDescrMessageHdr   hdr;
#ifndef DLM_DBSERVER
    WChar                   data[1];
#else
    MS_sqlda                *dlmSqlda;
#endif
    };

struct DLMDescriptorMessage
    {
    ServerDescrMessageHdr   hdr;
    MS_sqlda               *dlmSqlda;
    };
#endif