<refentry id="libgda-common-GDA">
<refmeta>
<refentrytitle>GDA</refentrytitle>
<manvolnum>3</manvolnum>
<refmiscinfo>LIBGDA-COMMON Library</refmiscinfo>
</refmeta>

<refnamediv>
<refname>GDA</refname><refpurpose></refpurpose>
</refnamediv>

<refsynopsisdiv><title>Synopsis</title>
<synopsis>



#define     <link linkend="ORBIT-IDL-SERIAL-CAPS">ORBIT_IDL_SERIAL</link>
#define     <link linkend="GDA-H-CAPS">GDA_H</link>
#define     <link linkend="TC-IMPL-TC-GDA-Error-0">TC_IMPL_TC_GDA_Error_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Error-1">TC_IMPL_TC_GDA_Error_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Error-2">TC_IMPL_TC_GDA_Error_2</link>
#define     <link linkend="TC-GDA-Error">TC_GDA_Error</link>
<link linkend="GDA-Error">GDA_Error</link>*  <link linkend="GDA-Error--alloc">GDA_Error__alloc</link>                (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-Error--free">GDA_Error__free</link>                 (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="ORBIT-DECL-CORBA-sequence-GDA-Error">ORBIT_DECL_CORBA_sequence_GDA_Error</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-Error-0">ORBIT_IMPL_CORBA_sequence_GDA_Error_0</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-Error-1">ORBIT_IMPL_CORBA_sequence_GDA_Error_1</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-Error-2">ORBIT_IMPL_CORBA_sequence_GDA_Error_2</link>
<link linkend="GDA-Error">GDA_Error</link>*  <link linkend="CORBA-sequence-GDA-Error-allocbuf">CORBA_sequence_GDA_Error_allocbuf</link>
                                            (<link linkend="CORBA-unsigned-long">CORBA_unsigned_long</link> len);
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-Error-0">TC_IMPL_TC_CORBA_sequence_GDA_Error_0</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-Error-1">TC_IMPL_TC_CORBA_sequence_GDA_Error_1</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-Error-2">TC_IMPL_TC_CORBA_sequence_GDA_Error_2</link>
#define     <link linkend="TC-CORBA-sequence-GDA-Error">TC_CORBA_sequence_GDA_Error</link>
<link linkend="CORBA-sequence-GDA-Error">CORBA_sequence_GDA_Error</link>* <link linkend="CORBA-sequence-GDA-Error--alloc">CORBA_sequence_GDA_Error__alloc</link>
                                            (void);
<link linkend="gpointer">gpointer</link>    <link linkend="CORBA-sequence-GDA-Error--free">CORBA_sequence_GDA_Error__free</link>  (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
typedef     <link linkend="GDA-ErrorSeq">GDA_ErrorSeq</link>;
#define     <link linkend="TC-IMPL-TC-GDA-ErrorSeq-0">TC_IMPL_TC_GDA_ErrorSeq_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-ErrorSeq-1">TC_IMPL_TC_GDA_ErrorSeq_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-ErrorSeq-2">TC_IMPL_TC_GDA_ErrorSeq_2</link>
#define     <link linkend="TC-GDA-ErrorSeq">TC_GDA_ErrorSeq</link>
<link linkend="GDA-ErrorSeq">GDA_ErrorSeq</link>* <link linkend="GDA-ErrorSeq--alloc">GDA_ErrorSeq__alloc</link>           (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-ErrorSeq--free">GDA_ErrorSeq__free</link>              (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="ex-GDA-DriverError">ex_GDA_DriverError</link>
#define     <link linkend="TC-IMPL-TC-GDA-DriverError-0">TC_IMPL_TC_GDA_DriverError_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-DriverError-1">TC_IMPL_TC_GDA_DriverError_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-DriverError-2">TC_IMPL_TC_GDA_DriverError_2</link>
#define     <link linkend="TC-GDA-DriverError">TC_GDA_DriverError</link>
<link linkend="GDA-DriverError">GDA_DriverError</link>* <link linkend="GDA-DriverError--alloc">GDA_DriverError__alloc</link>     (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-DriverError--free">GDA_DriverError__free</link>           (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="ex-GDA-NotSupported">ex_GDA_NotSupported</link>
#define     <link linkend="TC-IMPL-TC-GDA-NotSupported-0">TC_IMPL_TC_GDA_NotSupported_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-NotSupported-1">TC_IMPL_TC_GDA_NotSupported_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-NotSupported-2">TC_IMPL_TC_GDA_NotSupported_2</link>
#define     <link linkend="TC-GDA-NotSupported">TC_GDA_NotSupported</link>
<link linkend="GDA-NotSupported">GDA_NotSupported</link>* <link linkend="GDA-NotSupported--alloc">GDA_NotSupported__alloc</link>   (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-NotSupported--free">GDA_NotSupported__free</link>          (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
enum        <link linkend="GDA-ListenerAction">GDA_ListenerAction</link>;
#define     <link linkend="TC-IMPL-TC-GDA-ListenerAction-0">TC_IMPL_TC_GDA_ListenerAction_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-ListenerAction-1">TC_IMPL_TC_GDA_ListenerAction_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-ListenerAction-2">TC_IMPL_TC_GDA_ListenerAction_2</link>
#define     <link linkend="TC-GDA-ListenerAction">TC_GDA_ListenerAction</link>
#define     <link linkend="ORBIT-DECL-GDA-Listener">ORBIT_DECL_GDA_Listener</link>
#define     <link linkend="GDA-Listener--free">GDA_Listener__free</link>
typedef     <link linkend="GDA-Listener">GDA_Listener</link>;
extern      CORBA_unsigned_long <link linkend="GDA-Listener--classid">GDA_Listener__classid</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Listener-0">TC_IMPL_TC_GDA_Listener_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Listener-1">TC_IMPL_TC_GDA_Listener_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Listener-2">TC_IMPL_TC_GDA_Listener_2</link>
#define     <link linkend="TC-GDA-Listener">TC_GDA_Listener</link>
enum        <link linkend="GDA-ValueType">GDA_ValueType</link>;
#define     <link linkend="TC-IMPL-TC-GDA-ValueType-0">TC_IMPL_TC_GDA_ValueType_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-ValueType-1">TC_IMPL_TC_GDA_ValueType_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-ValueType-2">TC_IMPL_TC_GDA_ValueType_2</link>
#define     <link linkend="TC-GDA-ValueType">TC_GDA_ValueType</link>
typedef     <link linkend="GDA-Date">GDA_Date</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Date-0">TC_IMPL_TC_GDA_Date_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Date-1">TC_IMPL_TC_GDA_Date_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Date-2">TC_IMPL_TC_GDA_Date_2</link>
#define     <link linkend="TC-GDA-Date">TC_GDA_Date</link>
#define     <link linkend="TC-IMPL-TC-GDA-DbDate-0">TC_IMPL_TC_GDA_DbDate_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-DbDate-1">TC_IMPL_TC_GDA_DbDate_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-DbDate-2">TC_IMPL_TC_GDA_DbDate_2</link>
#define     <link linkend="TC-GDA-DbDate">TC_GDA_DbDate</link>
<link linkend="GDA-DbDate">GDA_DbDate</link>* <link linkend="GDA-DbDate--alloc">GDA_DbDate__alloc</link>               (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-DbDate--free">GDA_DbDate__free</link>                (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="TC-IMPL-TC-GDA-DbTime-0">TC_IMPL_TC_GDA_DbTime_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-DbTime-1">TC_IMPL_TC_GDA_DbTime_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-DbTime-2">TC_IMPL_TC_GDA_DbTime_2</link>
#define     <link linkend="TC-GDA-DbTime">TC_GDA_DbTime</link>
<link linkend="GDA-DbTime">GDA_DbTime</link>* <link linkend="GDA-DbTime--alloc">GDA_DbTime__alloc</link>               (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-DbTime--free">GDA_DbTime__free</link>                (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="TC-IMPL-TC-GDA-DbTimestamp-0">TC_IMPL_TC_GDA_DbTimestamp_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-DbTimestamp-1">TC_IMPL_TC_GDA_DbTimestamp_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-DbTimestamp-2">TC_IMPL_TC_GDA_DbTimestamp_2</link>
#define     <link linkend="TC-GDA-DbTimestamp">TC_GDA_DbTimestamp</link>
<link linkend="GDA-DbTimestamp">GDA_DbTimestamp</link>* <link linkend="GDA-DbTimestamp--alloc">GDA_DbTimestamp__alloc</link>     (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-DbTimestamp--free">GDA_DbTimestamp__free</link>           (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="ORBIT-DECL-CORBA-sequence-CORBA-octet">ORBIT_DECL_CORBA_sequence_CORBA_octet</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-CORBA-octet-0">ORBIT_IMPL_CORBA_sequence_CORBA_octet_0</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-CORBA-octet-1">ORBIT_IMPL_CORBA_sequence_CORBA_octet_1</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-CORBA-octet-2">ORBIT_IMPL_CORBA_sequence_CORBA_octet_2</link>
<link linkend="CORBA-octet">CORBA_octet</link>* <link linkend="CORBA-sequence-CORBA-octet-allocbuf">CORBA_sequence_CORBA_octet_allocbuf</link>
                                            (<link linkend="CORBA-unsigned-long">CORBA_unsigned_long</link> len);
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-CORBA-octet-0">TC_IMPL_TC_CORBA_sequence_CORBA_octet_0</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-CORBA-octet-1">TC_IMPL_TC_CORBA_sequence_CORBA_octet_1</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-CORBA-octet-2">TC_IMPL_TC_CORBA_sequence_CORBA_octet_2</link>
#define     <link linkend="TC-CORBA-sequence-CORBA-octet">TC_CORBA_sequence_CORBA_octet</link>
<link linkend="CORBA-sequence-CORBA-octet">CORBA_sequence_CORBA_octet</link>* <link linkend="CORBA-sequence-CORBA-octet--alloc">CORBA_sequence_CORBA_octet__alloc</link>
                                            (void);
<link linkend="gpointer">gpointer</link>    <link linkend="CORBA-sequence-CORBA-octet--free">CORBA_sequence_CORBA_octet__free</link>
                                            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
typedef     <link linkend="GDA-VarBinString">GDA_VarBinString</link>;
#define     <link linkend="TC-IMPL-TC-GDA-VarBinString-0">TC_IMPL_TC_GDA_VarBinString_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-VarBinString-1">TC_IMPL_TC_GDA_VarBinString_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-VarBinString-2">TC_IMPL_TC_GDA_VarBinString_2</link>
#define     <link linkend="TC-GDA-VarBinString">TC_GDA_VarBinString</link>
<link linkend="GDA-VarBinString">GDA_VarBinString</link>* <link linkend="GDA-VarBinString--alloc">GDA_VarBinString__alloc</link>   (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-VarBinString--free">GDA_VarBinString__free</link>          (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="TC-IMPL-TC-GDA-Value-0">TC_IMPL_TC_GDA_Value_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Value-1">TC_IMPL_TC_GDA_Value_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Value-2">TC_IMPL_TC_GDA_Value_2</link>
#define     <link linkend="TC-GDA-Value">TC_GDA_Value</link>
<link linkend="GDA-Value">GDA_Value</link>*  <link linkend="GDA-Value--alloc">GDA_Value__alloc</link>                (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-Value--free">GDA_Value__free</link>                 (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="TC-IMPL-TC-GDA-FieldValue-0">TC_IMPL_TC_GDA_FieldValue_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-FieldValue-1">TC_IMPL_TC_GDA_FieldValue_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-FieldValue-2">TC_IMPL_TC_GDA_FieldValue_2</link>
#define     <link linkend="TC-GDA-FieldValue">TC_GDA_FieldValue</link>
<link linkend="GDA-FieldValue">GDA_FieldValue</link>* <link linkend="GDA-FieldValue--alloc">GDA_FieldValue__alloc</link>       (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-FieldValue--free">GDA_FieldValue__free</link>            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="TC-IMPL-TC-GDA-Field-0">TC_IMPL_TC_GDA_Field_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Field-1">TC_IMPL_TC_GDA_Field_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Field-2">TC_IMPL_TC_GDA_Field_2</link>
#define     <link linkend="TC-GDA-Field">TC_GDA_Field</link>
<link linkend="GDA-Field">GDA_Field</link>*  <link linkend="GDA-Field--alloc">GDA_Field__alloc</link>                (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-Field--free">GDA_Field__free</link>                 (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="TC-IMPL-TC-GDA-FieldAttributes-0">TC_IMPL_TC_GDA_FieldAttributes_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-FieldAttributes-1">TC_IMPL_TC_GDA_FieldAttributes_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-FieldAttributes-2">TC_IMPL_TC_GDA_FieldAttributes_2</link>
#define     <link linkend="TC-GDA-FieldAttributes">TC_GDA_FieldAttributes</link>
<link linkend="GDA-FieldAttributes">GDA_FieldAttributes</link>* <link linkend="GDA-FieldAttributes--alloc">GDA_FieldAttributes__alloc</link>
                                            (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-FieldAttributes--free">GDA_FieldAttributes__free</link>       (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="ORBIT-DECL-CORBA-sequence-GDA-Field">ORBIT_DECL_CORBA_sequence_GDA_Field</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-Field-0">ORBIT_IMPL_CORBA_sequence_GDA_Field_0</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-Field-1">ORBIT_IMPL_CORBA_sequence_GDA_Field_1</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-Field-2">ORBIT_IMPL_CORBA_sequence_GDA_Field_2</link>
<link linkend="GDA-Field">GDA_Field</link>*  <link linkend="CORBA-sequence-GDA-Field-allocbuf">CORBA_sequence_GDA_Field_allocbuf</link>
                                            (<link linkend="CORBA-unsigned-long">CORBA_unsigned_long</link> len);
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-Field-0">TC_IMPL_TC_CORBA_sequence_GDA_Field_0</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-Field-1">TC_IMPL_TC_CORBA_sequence_GDA_Field_1</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-Field-2">TC_IMPL_TC_CORBA_sequence_GDA_Field_2</link>
#define     <link linkend="TC-CORBA-sequence-GDA-Field">TC_CORBA_sequence_GDA_Field</link>
<link linkend="CORBA-sequence-GDA-Field">CORBA_sequence_GDA_Field</link>* <link linkend="CORBA-sequence-GDA-Field--alloc">CORBA_sequence_GDA_Field__alloc</link>
                                            (void);
<link linkend="gpointer">gpointer</link>    <link linkend="CORBA-sequence-GDA-Field--free">CORBA_sequence_GDA_Field__free</link>  (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
typedef     <link linkend="GDA-Row">GDA_Row</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Row-0">TC_IMPL_TC_GDA_Row_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Row-1">TC_IMPL_TC_GDA_Row_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Row-2">TC_IMPL_TC_GDA_Row_2</link>
#define     <link linkend="TC-GDA-Row">TC_GDA_Row</link>
<link linkend="GDA-Row">GDA_Row</link>*    <link linkend="GDA-Row--alloc">GDA_Row__alloc</link>                  (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-Row--free">GDA_Row__free</link>                   (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="ORBIT-DECL-CORBA-sequence-GDA-FieldAttributes">ORBIT_DECL_CORBA_sequence_GDA_FieldAttributes</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-FieldAttributes-0">ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_0</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-FieldAttributes-1">ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_1</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-FieldAttributes-2">ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_2</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-FieldAttributes-0">TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_0</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-FieldAttributes-1">TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_1</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-FieldAttributes-2">TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_2</link>
#define     <link linkend="TC-CORBA-sequence-GDA-FieldAttributes">TC_CORBA_sequence_GDA_FieldAttributes</link>
<link linkend="gpointer">gpointer</link>    <link linkend="CORBA-sequence-GDA-FieldAttributes--free">CORBA_sequence_GDA_FieldAttributes__free</link>
                                            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
typedef     <link linkend="GDA-RowAttributes">GDA_RowAttributes</link>;
#define     <link linkend="TC-IMPL-TC-GDA-RowAttributes-0">TC_IMPL_TC_GDA_RowAttributes_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-RowAttributes-1">TC_IMPL_TC_GDA_RowAttributes_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-RowAttributes-2">TC_IMPL_TC_GDA_RowAttributes_2</link>
#define     <link linkend="TC-GDA-RowAttributes">TC_GDA_RowAttributes</link>
<link linkend="GDA-RowAttributes">GDA_RowAttributes</link>* <link linkend="GDA-RowAttributes--alloc">GDA_RowAttributes__alloc</link> (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-RowAttributes--free">GDA_RowAttributes__free</link>         (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
enum        <link linkend="GDA-LockType">GDA_LockType</link>;
#define     <link linkend="TC-IMPL-TC-GDA-LockType-0">TC_IMPL_TC_GDA_LockType_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-LockType-1">TC_IMPL_TC_GDA_LockType_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-LockType-2">TC_IMPL_TC_GDA_LockType_2</link>
#define     <link linkend="TC-GDA-LockType">TC_GDA_LockType</link>
enum        <link linkend="GDA-CursorType">GDA_CursorType</link>;
#define     <link linkend="TC-IMPL-TC-GDA-CursorType-0">TC_IMPL_TC_GDA_CursorType_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-CursorType-1">TC_IMPL_TC_GDA_CursorType_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-CursorType-2">TC_IMPL_TC_GDA_CursorType_2</link>
#define     <link linkend="TC-GDA-CursorType">TC_GDA_CursorType</link>
enum        <link linkend="GDA-Option">GDA_Option</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Option-0">TC_IMPL_TC_GDA_Option_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Option-1">TC_IMPL_TC_GDA_Option_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Option-2">TC_IMPL_TC_GDA_Option_2</link>
#define     <link linkend="TC-GDA-Option">TC_GDA_Option</link>
#define     <link linkend="ORBIT-DECL-GDA-Recordset">ORBIT_DECL_GDA_Recordset</link>
#define     <link linkend="GDA-Recordset--free">GDA_Recordset__free</link>
typedef     <link linkend="GDA-Recordset">GDA_Recordset</link>;
extern      CORBA_unsigned_long <link linkend="GDA-Recordset--classid">GDA_Recordset__classid</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Recordset-0">TC_IMPL_TC_GDA_Recordset_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Recordset-1">TC_IMPL_TC_GDA_Recordset_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Recordset-2">TC_IMPL_TC_GDA_Recordset_2</link>
#define     <link linkend="TC-GDA-Recordset">TC_GDA_Recordset</link>
#define     <link linkend="ORBIT-DECL-CORBA-sequence-GDA-Row">ORBIT_DECL_CORBA_sequence_GDA_Row</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-Row-0">ORBIT_IMPL_CORBA_sequence_GDA_Row_0</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-Row-1">ORBIT_IMPL_CORBA_sequence_GDA_Row_1</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-Row-2">ORBIT_IMPL_CORBA_sequence_GDA_Row_2</link>
<link linkend="GDA-Row">GDA_Row</link>*    <link linkend="CORBA-sequence-GDA-Row-allocbuf">CORBA_sequence_GDA_Row_allocbuf</link> (<link linkend="CORBA-unsigned-long">CORBA_unsigned_long</link> len);
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-Row-0">TC_IMPL_TC_CORBA_sequence_GDA_Row_0</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-Row-1">TC_IMPL_TC_CORBA_sequence_GDA_Row_1</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-Row-2">TC_IMPL_TC_CORBA_sequence_GDA_Row_2</link>
#define     <link linkend="TC-CORBA-sequence-GDA-Row">TC_CORBA_sequence_GDA_Row</link>
<link linkend="CORBA-sequence-GDA-Row">CORBA_sequence_GDA_Row</link>* <link linkend="CORBA-sequence-GDA-Row--alloc">CORBA_sequence_GDA_Row__alloc</link>
                                            (void);
<link linkend="gpointer">gpointer</link>    <link linkend="CORBA-sequence-GDA-Row--free">CORBA_sequence_GDA_Row__free</link>    (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
typedef     <link linkend="GDA-Recordset-Chunk">GDA_Recordset_Chunk</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Recordset-Chunk-0">TC_IMPL_TC_GDA_Recordset_Chunk_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Recordset-Chunk-1">TC_IMPL_TC_GDA_Recordset_Chunk_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Recordset-Chunk-2">TC_IMPL_TC_GDA_Recordset_Chunk_2</link>
#define     <link linkend="TC-GDA-Recordset-Chunk">TC_GDA_Recordset_Chunk</link>
<link linkend="GDA-Recordset-Chunk">GDA_Recordset_Chunk</link>* <link linkend="GDA-Recordset-Chunk--alloc">GDA_Recordset_Chunk__alloc</link>
                                            (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-Recordset-Chunk--free">GDA_Recordset_Chunk__free</link>       (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="ORBIT-DECL-GDA-Parameter">ORBIT_DECL_GDA_Parameter</link>
#define     <link linkend="GDA-Parameter--free">GDA_Parameter__free</link>
typedef     <link linkend="GDA-Parameter">GDA_Parameter</link>;
extern      CORBA_unsigned_long <link linkend="GDA-Parameter--classid">GDA_Parameter__classid</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Parameter-0">TC_IMPL_TC_GDA_Parameter_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Parameter-1">TC_IMPL_TC_GDA_Parameter_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Parameter-2">TC_IMPL_TC_GDA_Parameter_2</link>
#define     <link linkend="TC-GDA-Parameter">TC_GDA_Parameter</link>
typedef     <link linkend="GDA-Parameter-VarBinString">GDA_Parameter_VarBinString</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Parameter-VarBinString-0">TC_IMPL_TC_GDA_Parameter_VarBinString_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Parameter-VarBinString-1">TC_IMPL_TC_GDA_Parameter_VarBinString_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Parameter-VarBinString-2">TC_IMPL_TC_GDA_Parameter_VarBinString_2</link>
#define     <link linkend="TC-GDA-Parameter-VarBinString">TC_GDA_Parameter_VarBinString</link>
<link linkend="GDA-Parameter-VarBinString">GDA_Parameter_VarBinString</link>* <link linkend="GDA-Parameter-VarBinString--alloc">GDA_Parameter_VarBinString__alloc</link>
                                            (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-Parameter-VarBinString--free">GDA_Parameter_VarBinString__free</link>
                                            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
enum        <link linkend="GDA-ParameterDirection">GDA_ParameterDirection</link>;
#define     <link linkend="TC-IMPL-TC-GDA-ParameterDirection-0">TC_IMPL_TC_GDA_ParameterDirection_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-ParameterDirection-1">TC_IMPL_TC_GDA_ParameterDirection_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-ParameterDirection-2">TC_IMPL_TC_GDA_ParameterDirection_2</link>
#define     <link linkend="TC-GDA-ParameterDirection">TC_GDA_ParameterDirection</link>
#define     <link linkend="TC-IMPL-TC-GDA-CmdParameter-0">TC_IMPL_TC_GDA_CmdParameter_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-CmdParameter-1">TC_IMPL_TC_GDA_CmdParameter_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-CmdParameter-2">TC_IMPL_TC_GDA_CmdParameter_2</link>
#define     <link linkend="TC-GDA-CmdParameter">TC_GDA_CmdParameter</link>
<link linkend="GDA-CmdParameter">GDA_CmdParameter</link>* <link linkend="GDA-CmdParameter--alloc">GDA_CmdParameter__alloc</link>   (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-CmdParameter--free">GDA_CmdParameter__free</link>          (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="ORBIT-DECL-CORBA-sequence-GDA-CmdParameter">ORBIT_DECL_CORBA_sequence_GDA_CmdParameter</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-CmdParameter-0">ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_0</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-CmdParameter-1">ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_1</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-CmdParameter-2">ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_2</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-CmdParameter-0">TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_0</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-CmdParameter-1">TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_1</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-CmdParameter-2">TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_2</link>
#define     <link linkend="TC-CORBA-sequence-GDA-CmdParameter">TC_CORBA_sequence_GDA_CmdParameter</link>
<link linkend="gpointer">gpointer</link>    <link linkend="CORBA-sequence-GDA-CmdParameter--free">CORBA_sequence_GDA_CmdParameter__free</link>
                                            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
typedef     <link linkend="GDA-CmdParameterSeq">GDA_CmdParameterSeq</link>;
#define     <link linkend="TC-IMPL-TC-GDA-CmdParameterSeq-0">TC_IMPL_TC_GDA_CmdParameterSeq_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-CmdParameterSeq-1">TC_IMPL_TC_GDA_CmdParameterSeq_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-CmdParameterSeq-2">TC_IMPL_TC_GDA_CmdParameterSeq_2</link>
#define     <link linkend="TC-GDA-CmdParameterSeq">TC_GDA_CmdParameterSeq</link>
<link linkend="GDA-CmdParameterSeq">GDA_CmdParameterSeq</link>* <link linkend="GDA-CmdParameterSeq--alloc">GDA_CmdParameterSeq__alloc</link>
                                            (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-CmdParameterSeq--free">GDA_CmdParameterSeq__free</link>       (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="GDA-CMD-NORECORDS-CAPS">GDA_CMD_NORECORDS</link>
enum        <link linkend="GDA-CommandType">GDA_CommandType</link>;
#define     <link linkend="TC-IMPL-TC-GDA-CommandType-0">TC_IMPL_TC_GDA_CommandType_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-CommandType-1">TC_IMPL_TC_GDA_CommandType_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-CommandType-2">TC_IMPL_TC_GDA_CommandType_2</link>
#define     <link linkend="TC-GDA-CommandType">TC_GDA_CommandType</link>
#define     <link linkend="ORBIT-DECL-GDA-Command">ORBIT_DECL_GDA_Command</link>
#define     <link linkend="GDA-Command--free">GDA_Command__free</link>
typedef     <link linkend="GDA-Command">GDA_Command</link>;
extern      CORBA_unsigned_long <link linkend="GDA-Command--classid">GDA_Command__classid</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Command-0">TC_IMPL_TC_GDA_Command_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Command-1">TC_IMPL_TC_GDA_Command_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Command-2">TC_IMPL_TC_GDA_Command_2</link>
#define     <link linkend="TC-GDA-Command">TC_GDA_Command</link>
enum        <link linkend="GDA-CursorLocation">GDA_CursorLocation</link>;
#define     <link linkend="TC-IMPL-TC-GDA-CursorLocation-0">TC_IMPL_TC_GDA_CursorLocation_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-CursorLocation-1">TC_IMPL_TC_GDA_CursorLocation_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-CursorLocation-2">TC_IMPL_TC_GDA_CursorLocation_2</link>
#define     <link linkend="TC-GDA-CursorLocation">TC_GDA_CursorLocation</link>
#define     <link linkend="ORBIT-DECL-GDA-Connection">ORBIT_DECL_GDA_Connection</link>
#define     <link linkend="GDA-Connection--free">GDA_Connection__free</link>
typedef     <link linkend="GDA-Connection">GDA_Connection</link>;
extern      CORBA_unsigned_long <link linkend="GDA-Connection--classid">GDA_Connection__classid</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Connection-0">TC_IMPL_TC_GDA_Connection_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-1">TC_IMPL_TC_GDA_Connection_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-2">TC_IMPL_TC_GDA_Connection_2</link>
#define     <link linkend="TC-GDA-Connection">TC_GDA_Connection</link>
enum        <link linkend="GDA-Connection-QType">GDA_Connection_QType</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Connection-QType-0">TC_IMPL_TC_GDA_Connection_QType_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-QType-1">TC_IMPL_TC_GDA_Connection_QType_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-QType-2">TC_IMPL_TC_GDA_Connection_QType_2</link>
#define     <link linkend="TC-GDA-Connection-QType">TC_GDA_Connection_QType</link>
enum        <link linkend="GDA-Connection-ConstraintType">GDA_Connection_ConstraintType</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Connection-ConstraintType-0">TC_IMPL_TC_GDA_Connection_ConstraintType_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-ConstraintType-1">TC_IMPL_TC_GDA_Connection_ConstraintType_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-ConstraintType-2">TC_IMPL_TC_GDA_Connection_ConstraintType_2</link>
#define     <link linkend="TC-GDA-Connection-ConstraintType">TC_GDA_Connection_ConstraintType</link>
enum        <link linkend="GDA-Connection-Permission">GDA_Connection_Permission</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Connection-Permission-0">TC_IMPL_TC_GDA_Connection_Permission_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-Permission-1">TC_IMPL_TC_GDA_Connection_Permission_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-Permission-2">TC_IMPL_TC_GDA_Connection_Permission_2</link>
#define     <link linkend="TC-GDA-Connection-Permission">TC_GDA_Connection_Permission</link>
enum        <link linkend="GDA-Connection-Feature">GDA_Connection_Feature</link>;
#define     <link linkend="TC-IMPL-TC-GDA-Connection-Feature-0">TC_IMPL_TC_GDA_Connection_Feature_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-Feature-1">TC_IMPL_TC_GDA_Connection_Feature_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-Feature-2">TC_IMPL_TC_GDA_Connection_Feature_2</link>
#define     <link linkend="TC-GDA-Connection-Feature">TC_GDA_Connection_Feature</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-Constraint-0">TC_IMPL_TC_GDA_Connection_Constraint_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-Constraint-1">TC_IMPL_TC_GDA_Connection_Constraint_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-Constraint-2">TC_IMPL_TC_GDA_Connection_Constraint_2</link>
#define     <link linkend="TC-GDA-Connection-Constraint">TC_GDA_Connection_Constraint</link>
<link linkend="GDA-Connection-Constraint">GDA_Connection_Constraint</link>* <link linkend="GDA-Connection-Constraint--alloc">GDA_Connection_Constraint__alloc</link>
                                            (void);
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-Connection-Constraint--free">GDA_Connection_Constraint__free</link> (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="ORBIT-DECL-CORBA-sequence-GDA-Connection-Constraint">ORBIT_DECL_CORBA_sequence_GDA_Connection_Constraint</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-Connection-Constraint-0">ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_0</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-Connection-Constraint-1">ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_1</link>
#define     <link linkend="ORBIT-IMPL-CORBA-sequence-GDA-Connection-Constraint-2">ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_2</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-Connection-Constraint-0">TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_0</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-Connection-Constraint-1">TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_1</link>
#define     <link linkend="TC-IMPL-TC-CORBA-sequence-GDA-Connection-Constraint-2">TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_2</link>
#define     <link linkend="TC-CORBA-sequence-GDA-Connection-Constraint">TC_CORBA_sequence_GDA_Connection_Constraint</link>
<link linkend="gpointer">gpointer</link>    <link linkend="CORBA-sequence-GDA-Connection-Constraint--free">CORBA_sequence_GDA_Connection_Constraint__free</link>
                                            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
#define     <link linkend="TC-IMPL-TC-GDA-Connection-ConstraintSeq-0">TC_IMPL_TC_GDA_Connection_ConstraintSeq_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-ConstraintSeq-1">TC_IMPL_TC_GDA_Connection_ConstraintSeq_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-Connection-ConstraintSeq-2">TC_IMPL_TC_GDA_Connection_ConstraintSeq_2</link>
#define     <link linkend="TC-GDA-Connection-ConstraintSeq">TC_GDA_Connection_ConstraintSeq</link>
<link linkend="gpointer">gpointer</link>    <link linkend="GDA-Connection-ConstraintSeq--free">GDA_Connection_ConstraintSeq__free</link>
                                            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);
enum        <link linkend="GDA-AffectedRows">GDA_AffectedRows</link>;
#define     <link linkend="TC-IMPL-TC-GDA-AffectedRows-0">TC_IMPL_TC_GDA_AffectedRows_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-AffectedRows-1">TC_IMPL_TC_GDA_AffectedRows_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-AffectedRows-2">TC_IMPL_TC_GDA_AffectedRows_2</link>
#define     <link linkend="TC-GDA-AffectedRows">TC_GDA_AffectedRows</link>
enum        <link linkend="GDA-IsolationLevel">GDA_IsolationLevel</link>;
#define     <link linkend="TC-IMPL-TC-GDA-IsolationLevel-0">TC_IMPL_TC_GDA_IsolationLevel_0</link>
#define     <link linkend="TC-IMPL-TC-GDA-IsolationLevel-1">TC_IMPL_TC_GDA_IsolationLevel_1</link>
#define     <link linkend="TC-IMPL-TC-GDA-IsolationLevel-2">TC_IMPL_TC_GDA_IsolationLevel_2</link>
#define     <link linkend="TC-GDA-IsolationLevel">TC_GDA_IsolationLevel</link>
void        <link linkend="POA-GDA-Listener--init">POA_GDA_Listener__init</link>          (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="POA-GDA-Listener--fini">POA_GDA_Listener__fini</link>          (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="POA-GDA-Recordset--init">POA_GDA_Recordset__init</link>         (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="POA-GDA-Recordset--fini">POA_GDA_Recordset__fini</link>         (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="POA-GDA-Parameter--init">POA_GDA_Parameter__init</link>         (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="POA-GDA-Parameter--fini">POA_GDA_Parameter__fini</link>         (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="POA-GDA-Command--init">POA_GDA_Command__init</link>           (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="POA-GDA-Command--fini">POA_GDA_Command__fini</link>           (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="POA-GDA-Connection--init">POA_GDA_Connection__init</link>        (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="POA-GDA-Connection--fini">POA_GDA_Connection__fini</link>        (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
#define     <link linkend="GDA-Listener-ref">GDA_Listener_ref</link>
#define     <link linkend="GDA-Listener-unref">GDA_Listener_unref</link>
#define     <link linkend="GDA-Listener-queryInterface">GDA_Listener_queryInterface</link>
void        <link linkend="GDA-Listener-notifyAction">GDA_Listener_notifyAction</link>       (<link linkend="GDA-Listener">GDA_Listener</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *message,
                                             const <link linkend="GDA-ListenerAction">GDA_ListenerAction</link> action,
                                             const <link linkend="CORBA-char">CORBA_char</link> *description,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
#define     <link linkend="GDA-Recordset-ref">GDA_Recordset_ref</link>
#define     <link linkend="GDA-Recordset-unref">GDA_Recordset_unref</link>
#define     <link linkend="GDA-Recordset-queryInterface">GDA_Recordset_queryInterface</link>
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Recordset-getRowCount">GDA_Recordset_getRowCount</link>       (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Recordset-close">GDA_Recordset_close</link>             (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Recordset-moveFirst">GDA_Recordset_moveFirst</link>         (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Recordset-moveLast">GDA_Recordset_moveLast</link>          (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Recordset-moveNext">GDA_Recordset_moveNext</link>          (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Recordset-movePrev">GDA_Recordset_movePrev</link>          (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Recordset-reQuery">GDA_Recordset_reQuery</link>           (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-boolean">CORBA_boolean</link> <link linkend="GDA-Recordset-supports">GDA_Recordset_supports</link>        (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             const <link linkend="GDA-Option">GDA_Option</link> what,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="GDA-Recordset-Chunk">GDA_Recordset_Chunk</link>* <link linkend="GDA-Recordset-fetch">GDA_Recordset_fetch</link>    (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             const <link linkend="CORBA-long">CORBA_long</link> count,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="GDA-RowAttributes">GDA_RowAttributes</link>* <link linkend="GDA-Recordset-describe">GDA_Recordset_describe</link>   (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Parameter-appendChunk">GDA_Parameter_appendChunk</link>       (<link linkend="GDA-Parameter">GDA_Parameter</link> _obj,
                                             const <link linkend="GDA-Parameter-VarBinString">GDA_Parameter_VarBinString</link> *data,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
#define     <link linkend="GDA-Command-ref">GDA_Command_ref</link>
#define     <link linkend="GDA-Command-unref">GDA_Command_unref</link>
#define     <link linkend="GDA-Command-queryInterface">GDA_Command_queryInterface</link>
<link linkend="CORBA-char">CORBA_char</link>* <link linkend="GDA-Command--get-text">GDA_Command__get_text</link>           (<link linkend="GDA-Command">GDA_Command</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="GDA-Command--set-text">GDA_Command__set_text</link>           (<link linkend="GDA-Command">GDA_Command</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *value,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="GDA-CommandType">GDA_CommandType</link> <link linkend="GDA-Command--get-type">GDA_Command__get_type</link>       (<link linkend="GDA-Command">GDA_Command</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="GDA-Command--set-type">GDA_Command__set_type</link>           (<link linkend="GDA-Command">GDA_Command</link> _obj,
                                             const <link linkend="GDA-CommandType">GDA_CommandType</link> value,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="GDA-Recordset">GDA_Recordset</link> <link linkend="GDA-Command-open">GDA_Command_open</link>              (<link linkend="GDA-Command">GDA_Command</link> _obj,
                                             const <link linkend="GDA-CmdParameterSeq">GDA_CmdParameterSeq</link> *param,
                                             const <link linkend="GDA-CursorType">GDA_CursorType</link> ct,
                                             const <link linkend="GDA-LockType">GDA_LockType</link> lt,
                                             <link linkend="CORBA-unsigned-long">CORBA_unsigned_long</link> *affected,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
#define     <link linkend="GDA-Connection-ref">GDA_Connection_ref</link>
#define     <link linkend="GDA-Connection-unref">GDA_Connection_unref</link>
#define     <link linkend="GDA-Connection-queryInterface">GDA_Connection_queryInterface</link>
<link linkend="CORBA-char">CORBA_char</link>* <link linkend="GDA-Connection--get-version">GDA_Connection__get_version</link>     (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="GDA-ErrorSeq">GDA_ErrorSeq</link>* <link linkend="GDA-Connection--get-errors">GDA_Connection__get_errors</link>    (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Connection-beginTransaction">GDA_Connection_beginTransaction</link> (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Connection-commitTransaction">GDA_Connection_commitTransaction</link>
                                            (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Connection-rollbackTransaction">GDA_Connection_rollbackTransaction</link>
                                            (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Connection-close">GDA_Connection_close</link>            (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Connection-open">GDA_Connection_open</link>             (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *dsn,
                                             const <link linkend="CORBA-char">CORBA_char</link> *user,
                                             const <link linkend="CORBA-char">CORBA_char</link> *passwd,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="GDA-Recordset">GDA_Recordset</link> <link linkend="GDA-Connection-openSchema">GDA_Connection_openSchema</link>     (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="GDA-Connection-QType">GDA_Connection_QType</link> t,
                                             const <link linkend="GDA-Connection-ConstraintSeq">GDA_Connection_ConstraintSeq</link> *constraints,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Connection-modifySchema">GDA_Connection_modifySchema</link>     (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="GDA-Connection-QType">GDA_Connection_QType</link> t,
                                             const <link linkend="GDA-Connection-ConstraintSeq">GDA_Connection_ConstraintSeq</link> *constraints,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="GDA-Command">GDA_Command</link> <link linkend="GDA-Connection-createCommand">GDA_Connection_createCommand</link>    (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="GDA-Recordset">GDA_Recordset</link> <link linkend="GDA-Connection-createRecordset">GDA_Connection_createRecordset</link>
                                            (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Connection-startLogging">GDA_Connection_startLogging</link>     (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *filename,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-long">CORBA_long</link>  <link linkend="GDA-Connection-stopLogging">GDA_Connection_stopLogging</link>      (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-char">CORBA_char</link>* <link linkend="GDA-Connection-createTable">GDA_Connection_createTable</link>      (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *name,
                                             const <link linkend="GDA-RowAttributes">GDA_RowAttributes</link> *columns,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-boolean">CORBA_boolean</link> <link linkend="GDA-Connection-supports">GDA_Connection_supports</link>       (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="GDA-Connection-Feature">GDA_Connection_Feature</link> feature,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-char">CORBA_char</link>* <link linkend="GDA-Connection-sql2xml">GDA_Connection_sql2xml</link>          (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *sql,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
<link linkend="CORBA-char">CORBA_char</link>* <link linkend="GDA-Connection-xml2sql">GDA_Connection_xml2sql</link>          (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *xml,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="GDA-Connection-addListener">GDA_Connection_addListener</link>      (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="GDA-Listener">GDA_Listener</link> listener,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
void        <link linkend="GDA-Connection-removeListener">GDA_Connection_removeListener</link>   (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="GDA-Listener">GDA_Listener</link> listener,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);
</synopsis>
</refsynopsisdiv>





<refsect1>
<title>Description</title>
<para>

</para>
</refsect1>

<refsect1>
<title>Details</title>
<refsect2>
<title><anchor id="ORBIT-IDL-SERIAL-CAPS">ORBIT_IDL_SERIAL</title>
<programlisting>#define ORBIT_IDL_SERIAL 9
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-H-CAPS">GDA_H</title>
<programlisting>#define GDA_H 1
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Error-0">TC_IMPL_TC_GDA_Error_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Error_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Error-1">TC_IMPL_TC_GDA_Error_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Error_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Error-2">TC_IMPL_TC_GDA_Error_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Error_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Error">TC_GDA_Error</title>
<programlisting>#define TC_GDA_Error ((CORBA_TypeCode)&amp;TC_GDA_Error_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Error--alloc">GDA_Error__alloc ()</title>
<programlisting><link linkend="GDA-Error">GDA_Error</link>*  GDA_Error__alloc                (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Error--free">GDA_Error__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_Error__free                 (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="ORBIT-DECL-CORBA-sequence-GDA-Error">ORBIT_DECL_CORBA_sequence_GDA_Error</title>
<programlisting>#define ORBIT_DECL_CORBA_sequence_GDA_Error 1
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-Error-0">ORBIT_IMPL_CORBA_sequence_GDA_Error_0</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_Error_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-Error-1">ORBIT_IMPL_CORBA_sequence_GDA_Error_1</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_Error_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-Error-2">ORBIT_IMPL_CORBA_sequence_GDA_Error_2</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_Error_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-GDA-Error-allocbuf">CORBA_sequence_GDA_Error_allocbuf ()</title>
<programlisting><link linkend="GDA-Error">GDA_Error</link>*  CORBA_sequence_GDA_Error_allocbuf
                                            (<link linkend="CORBA-unsigned-long">CORBA_unsigned_long</link> len);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>len</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-Error-0">TC_IMPL_TC_CORBA_sequence_GDA_Error_0</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_Error_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-Error-1">TC_IMPL_TC_CORBA_sequence_GDA_Error_1</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_Error_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-Error-2">TC_IMPL_TC_CORBA_sequence_GDA_Error_2</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_Error_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-CORBA-sequence-GDA-Error">TC_CORBA_sequence_GDA_Error</title>
<programlisting>#define TC_CORBA_sequence_GDA_Error ((CORBA_TypeCode)&amp;TC_CORBA_sequence_GDA_Error_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-GDA-Error--alloc">CORBA_sequence_GDA_Error__alloc ()</title>
<programlisting><link linkend="CORBA-sequence-GDA-Error">CORBA_sequence_GDA_Error</link>* CORBA_sequence_GDA_Error__alloc
                                            (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-GDA-Error--free">CORBA_sequence_GDA_Error__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    CORBA_sequence_GDA_Error__free  (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-ErrorSeq">GDA_ErrorSeq</title>
<programlisting>   typedef CORBA_sequence_GDA_Error GDA_ErrorSeq;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-ErrorSeq-0">TC_IMPL_TC_GDA_ErrorSeq_0</title>
<programlisting>#define TC_IMPL_TC_GDA_ErrorSeq_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-ErrorSeq-1">TC_IMPL_TC_GDA_ErrorSeq_1</title>
<programlisting>#define TC_IMPL_TC_GDA_ErrorSeq_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-ErrorSeq-2">TC_IMPL_TC_GDA_ErrorSeq_2</title>
<programlisting>#define TC_IMPL_TC_GDA_ErrorSeq_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-ErrorSeq">TC_GDA_ErrorSeq</title>
<programlisting>#define TC_GDA_ErrorSeq ((CORBA_TypeCode)&amp;TC_GDA_ErrorSeq_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-ErrorSeq--alloc">GDA_ErrorSeq__alloc ()</title>
<programlisting><link linkend="GDA-ErrorSeq">GDA_ErrorSeq</link>* GDA_ErrorSeq__alloc           (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-ErrorSeq--free">GDA_ErrorSeq__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_ErrorSeq__free              (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="ex-GDA-DriverError">ex_GDA_DriverError</title>
<programlisting>#define ex_GDA_DriverError "IDL:GDA/DriverError:1.0"
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-DriverError-0">TC_IMPL_TC_GDA_DriverError_0</title>
<programlisting>#define TC_IMPL_TC_GDA_DriverError_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-DriverError-1">TC_IMPL_TC_GDA_DriverError_1</title>
<programlisting>#define TC_IMPL_TC_GDA_DriverError_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-DriverError-2">TC_IMPL_TC_GDA_DriverError_2</title>
<programlisting>#define TC_IMPL_TC_GDA_DriverError_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-DriverError">TC_GDA_DriverError</title>
<programlisting>#define TC_GDA_DriverError ((CORBA_TypeCode)&amp;TC_GDA_DriverError_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-DriverError--alloc">GDA_DriverError__alloc ()</title>
<programlisting><link linkend="GDA-DriverError">GDA_DriverError</link>* GDA_DriverError__alloc     (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-DriverError--free">GDA_DriverError__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_DriverError__free           (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="ex-GDA-NotSupported">ex_GDA_NotSupported</title>
<programlisting>#define ex_GDA_NotSupported "IDL:GDA/NotSupported:1.0"
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-NotSupported-0">TC_IMPL_TC_GDA_NotSupported_0</title>
<programlisting>#define TC_IMPL_TC_GDA_NotSupported_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-NotSupported-1">TC_IMPL_TC_GDA_NotSupported_1</title>
<programlisting>#define TC_IMPL_TC_GDA_NotSupported_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-NotSupported-2">TC_IMPL_TC_GDA_NotSupported_2</title>
<programlisting>#define TC_IMPL_TC_GDA_NotSupported_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-NotSupported">TC_GDA_NotSupported</title>
<programlisting>#define TC_GDA_NotSupported ((CORBA_TypeCode)&amp;TC_GDA_NotSupported_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-NotSupported--alloc">GDA_NotSupported__alloc ()</title>
<programlisting><link linkend="GDA-NotSupported">GDA_NotSupported</link>* GDA_NotSupported__alloc   (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-NotSupported--free">GDA_NotSupported__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_NotSupported__free          (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-ListenerAction">enum GDA_ListenerAction</title>
<programlisting>   typedef enum
   {
      GDA_LISTENER_ACTION_DATABASE,
      GDA_LISTENER_ACTION_ERROR,
      GDA_LISTENER_ACTION_SHUTDOWN
   }
   GDA_ListenerAction;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-ListenerAction-0">TC_IMPL_TC_GDA_ListenerAction_0</title>
<programlisting>#define TC_IMPL_TC_GDA_ListenerAction_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-ListenerAction-1">TC_IMPL_TC_GDA_ListenerAction_1</title>
<programlisting>#define TC_IMPL_TC_GDA_ListenerAction_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-ListenerAction-2">TC_IMPL_TC_GDA_ListenerAction_2</title>
<programlisting>#define TC_IMPL_TC_GDA_ListenerAction_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-ListenerAction">TC_GDA_ListenerAction</title>
<programlisting>#define TC_GDA_ListenerAction ((CORBA_TypeCode)&amp;TC_GDA_ListenerAction_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-DECL-GDA-Listener">ORBIT_DECL_GDA_Listener</title>
<programlisting>#define ORBIT_DECL_GDA_Listener 1
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Listener--free">GDA_Listener__free</title>
<programlisting>#define GDA_Listener__free CORBA_Object__free
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Listener">GDA_Listener</title>
<programlisting>   typedef CORBA_Object GDA_Listener;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Listener--classid">GDA_Listener__classid</title>
<programlisting>   extern CORBA_unsigned_long GDA_Listener__classid;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Listener-0">TC_IMPL_TC_GDA_Listener_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Listener_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Listener-1">TC_IMPL_TC_GDA_Listener_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Listener_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Listener-2">TC_IMPL_TC_GDA_Listener_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Listener_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Listener">TC_GDA_Listener</title>
<programlisting>#define TC_GDA_Listener ((CORBA_TypeCode)&amp;TC_GDA_Listener_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-ValueType">enum GDA_ValueType</title>
<programlisting>   typedef enum
   {
      GDA_TypeNull,
      GDA_TypeBigint,
      GDA_TypeBinary,
      GDA_TypeBoolean,
      GDA_TypeBstr,
      GDA_TypeChar,
      GDA_TypeCurrency,
      GDA_TypeDate,
      GDA_TypeDbDate,
      GDA_TypeDbTime,
      GDA_TypeDbTimestamp,
      GDA_TypeDecimal,
      GDA_TypeDouble,
      GDA_TypeError,
      GDA_TypeInteger,
      GDA_TypeLongvarbin,
      GDA_TypeLongvarchar,
      GDA_TypeLongvarwchar,
      GDA_TypeNumeric,
      GDA_TypeSingle,
      GDA_TypeSmallint,
      GDA_TypeTinyint,
      GDA_TypeUBigint,
      GDA_TypeUSmallint,
      GDA_TypeVarchar,
      GDA_TypeVarbin,
      GDA_TypeVarwchar,
      GDA_TypeFixchar,
      GDA_TypeFixbin,
      GDA_TypeFixwchar,
      GDA_TypeUnknown,
      GDA_TypeLastValue
   }
   GDA_ValueType;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-ValueType-0">TC_IMPL_TC_GDA_ValueType_0</title>
<programlisting>#define TC_IMPL_TC_GDA_ValueType_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-ValueType-1">TC_IMPL_TC_GDA_ValueType_1</title>
<programlisting>#define TC_IMPL_TC_GDA_ValueType_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-ValueType-2">TC_IMPL_TC_GDA_ValueType_2</title>
<programlisting>#define TC_IMPL_TC_GDA_ValueType_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-ValueType">TC_GDA_ValueType</title>
<programlisting>#define TC_GDA_ValueType ((CORBA_TypeCode)&amp;TC_GDA_ValueType_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Date">GDA_Date</title>
<programlisting>   typedef CORBA_long GDA_Date;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Date-0">TC_IMPL_TC_GDA_Date_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Date_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Date-1">TC_IMPL_TC_GDA_Date_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Date_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Date-2">TC_IMPL_TC_GDA_Date_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Date_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Date">TC_GDA_Date</title>
<programlisting>#define TC_GDA_Date ((CORBA_TypeCode)&amp;TC_GDA_Date_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-DbDate-0">TC_IMPL_TC_GDA_DbDate_0</title>
<programlisting>#define TC_IMPL_TC_GDA_DbDate_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-DbDate-1">TC_IMPL_TC_GDA_DbDate_1</title>
<programlisting>#define TC_IMPL_TC_GDA_DbDate_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-DbDate-2">TC_IMPL_TC_GDA_DbDate_2</title>
<programlisting>#define TC_IMPL_TC_GDA_DbDate_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-DbDate">TC_GDA_DbDate</title>
<programlisting>#define TC_GDA_DbDate ((CORBA_TypeCode)&amp;TC_GDA_DbDate_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-DbDate--alloc">GDA_DbDate__alloc ()</title>
<programlisting><link linkend="GDA-DbDate">GDA_DbDate</link>* GDA_DbDate__alloc               (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-DbDate--free">GDA_DbDate__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_DbDate__free                (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-DbTime-0">TC_IMPL_TC_GDA_DbTime_0</title>
<programlisting>#define TC_IMPL_TC_GDA_DbTime_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-DbTime-1">TC_IMPL_TC_GDA_DbTime_1</title>
<programlisting>#define TC_IMPL_TC_GDA_DbTime_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-DbTime-2">TC_IMPL_TC_GDA_DbTime_2</title>
<programlisting>#define TC_IMPL_TC_GDA_DbTime_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-DbTime">TC_GDA_DbTime</title>
<programlisting>#define TC_GDA_DbTime ((CORBA_TypeCode)&amp;TC_GDA_DbTime_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-DbTime--alloc">GDA_DbTime__alloc ()</title>
<programlisting><link linkend="GDA-DbTime">GDA_DbTime</link>* GDA_DbTime__alloc               (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-DbTime--free">GDA_DbTime__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_DbTime__free                (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-DbTimestamp-0">TC_IMPL_TC_GDA_DbTimestamp_0</title>
<programlisting>#define TC_IMPL_TC_GDA_DbTimestamp_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-DbTimestamp-1">TC_IMPL_TC_GDA_DbTimestamp_1</title>
<programlisting>#define TC_IMPL_TC_GDA_DbTimestamp_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-DbTimestamp-2">TC_IMPL_TC_GDA_DbTimestamp_2</title>
<programlisting>#define TC_IMPL_TC_GDA_DbTimestamp_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-DbTimestamp">TC_GDA_DbTimestamp</title>
<programlisting>#define TC_GDA_DbTimestamp ((CORBA_TypeCode)&amp;TC_GDA_DbTimestamp_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-DbTimestamp--alloc">GDA_DbTimestamp__alloc ()</title>
<programlisting><link linkend="GDA-DbTimestamp">GDA_DbTimestamp</link>* GDA_DbTimestamp__alloc     (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-DbTimestamp--free">GDA_DbTimestamp__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_DbTimestamp__free           (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="ORBIT-DECL-CORBA-sequence-CORBA-octet">ORBIT_DECL_CORBA_sequence_CORBA_octet</title>
<programlisting>#define     ORBIT_DECL_CORBA_sequence_CORBA_octet</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-CORBA-octet-0">ORBIT_IMPL_CORBA_sequence_CORBA_octet_0</title>
<programlisting>#define     ORBIT_IMPL_CORBA_sequence_CORBA_octet_0</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-CORBA-octet-1">ORBIT_IMPL_CORBA_sequence_CORBA_octet_1</title>
<programlisting>#define     ORBIT_IMPL_CORBA_sequence_CORBA_octet_1</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-CORBA-octet-2">ORBIT_IMPL_CORBA_sequence_CORBA_octet_2</title>
<programlisting>#define     ORBIT_IMPL_CORBA_sequence_CORBA_octet_2</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-CORBA-octet-allocbuf">CORBA_sequence_CORBA_octet_allocbuf ()</title>
<programlisting><link linkend="CORBA-octet">CORBA_octet</link>* CORBA_sequence_CORBA_octet_allocbuf
                                            (<link linkend="CORBA-unsigned-long">CORBA_unsigned_long</link> len);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>len</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-CORBA-octet-0">TC_IMPL_TC_CORBA_sequence_CORBA_octet_0</title>
<programlisting>#define     TC_IMPL_TC_CORBA_sequence_CORBA_octet_0</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-CORBA-octet-1">TC_IMPL_TC_CORBA_sequence_CORBA_octet_1</title>
<programlisting>#define     TC_IMPL_TC_CORBA_sequence_CORBA_octet_1</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-CORBA-octet-2">TC_IMPL_TC_CORBA_sequence_CORBA_octet_2</title>
<programlisting>#define     TC_IMPL_TC_CORBA_sequence_CORBA_octet_2</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-CORBA-sequence-CORBA-octet">TC_CORBA_sequence_CORBA_octet</title>
<programlisting>#define     TC_CORBA_sequence_CORBA_octet</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-CORBA-octet--alloc">CORBA_sequence_CORBA_octet__alloc ()</title>
<programlisting><link linkend="CORBA-sequence-CORBA-octet">CORBA_sequence_CORBA_octet</link>* CORBA_sequence_CORBA_octet__alloc
                                            (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-CORBA-octet--free">CORBA_sequence_CORBA_octet__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    CORBA_sequence_CORBA_octet__free
                                            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-VarBinString">GDA_VarBinString</title>
<programlisting>   typedef CORBA_sequence_CORBA_octet GDA_VarBinString;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-VarBinString-0">TC_IMPL_TC_GDA_VarBinString_0</title>
<programlisting>#define TC_IMPL_TC_GDA_VarBinString_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-VarBinString-1">TC_IMPL_TC_GDA_VarBinString_1</title>
<programlisting>#define TC_IMPL_TC_GDA_VarBinString_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-VarBinString-2">TC_IMPL_TC_GDA_VarBinString_2</title>
<programlisting>#define TC_IMPL_TC_GDA_VarBinString_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-VarBinString">TC_GDA_VarBinString</title>
<programlisting>#define TC_GDA_VarBinString ((CORBA_TypeCode)&amp;TC_GDA_VarBinString_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-VarBinString--alloc">GDA_VarBinString__alloc ()</title>
<programlisting><link linkend="GDA-VarBinString">GDA_VarBinString</link>* GDA_VarBinString__alloc   (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-VarBinString--free">GDA_VarBinString__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_VarBinString__free          (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Value-0">TC_IMPL_TC_GDA_Value_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Value_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Value-1">TC_IMPL_TC_GDA_Value_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Value_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Value-2">TC_IMPL_TC_GDA_Value_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Value_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Value">TC_GDA_Value</title>
<programlisting>#define TC_GDA_Value ((CORBA_TypeCode)&amp;TC_GDA_Value_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Value--alloc">GDA_Value__alloc ()</title>
<programlisting><link linkend="GDA-Value">GDA_Value</link>*  GDA_Value__alloc                (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Value--free">GDA_Value__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_Value__free                 (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-FieldValue-0">TC_IMPL_TC_GDA_FieldValue_0</title>
<programlisting>#define TC_IMPL_TC_GDA_FieldValue_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-FieldValue-1">TC_IMPL_TC_GDA_FieldValue_1</title>
<programlisting>#define TC_IMPL_TC_GDA_FieldValue_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-FieldValue-2">TC_IMPL_TC_GDA_FieldValue_2</title>
<programlisting>#define TC_IMPL_TC_GDA_FieldValue_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-FieldValue">TC_GDA_FieldValue</title>
<programlisting>#define TC_GDA_FieldValue ((CORBA_TypeCode)&amp;TC_GDA_FieldValue_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-FieldValue--alloc">GDA_FieldValue__alloc ()</title>
<programlisting><link linkend="GDA-FieldValue">GDA_FieldValue</link>* GDA_FieldValue__alloc       (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-FieldValue--free">GDA_FieldValue__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_FieldValue__free            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Field-0">TC_IMPL_TC_GDA_Field_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Field_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Field-1">TC_IMPL_TC_GDA_Field_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Field_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Field-2">TC_IMPL_TC_GDA_Field_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Field_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Field">TC_GDA_Field</title>
<programlisting>#define TC_GDA_Field ((CORBA_TypeCode)&amp;TC_GDA_Field_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Field--alloc">GDA_Field__alloc ()</title>
<programlisting><link linkend="GDA-Field">GDA_Field</link>*  GDA_Field__alloc                (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Field--free">GDA_Field__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_Field__free                 (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-FieldAttributes-0">TC_IMPL_TC_GDA_FieldAttributes_0</title>
<programlisting>#define TC_IMPL_TC_GDA_FieldAttributes_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-FieldAttributes-1">TC_IMPL_TC_GDA_FieldAttributes_1</title>
<programlisting>#define TC_IMPL_TC_GDA_FieldAttributes_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-FieldAttributes-2">TC_IMPL_TC_GDA_FieldAttributes_2</title>
<programlisting>#define TC_IMPL_TC_GDA_FieldAttributes_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-FieldAttributes">TC_GDA_FieldAttributes</title>
<programlisting>#define TC_GDA_FieldAttributes ((CORBA_TypeCode)&amp;TC_GDA_FieldAttributes_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-FieldAttributes--alloc">GDA_FieldAttributes__alloc ()</title>
<programlisting><link linkend="GDA-FieldAttributes">GDA_FieldAttributes</link>* GDA_FieldAttributes__alloc
                                            (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-FieldAttributes--free">GDA_FieldAttributes__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_FieldAttributes__free       (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="ORBIT-DECL-CORBA-sequence-GDA-Field">ORBIT_DECL_CORBA_sequence_GDA_Field</title>
<programlisting>#define ORBIT_DECL_CORBA_sequence_GDA_Field 1
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-Field-0">ORBIT_IMPL_CORBA_sequence_GDA_Field_0</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_Field_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-Field-1">ORBIT_IMPL_CORBA_sequence_GDA_Field_1</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_Field_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-Field-2">ORBIT_IMPL_CORBA_sequence_GDA_Field_2</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_Field_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-GDA-Field-allocbuf">CORBA_sequence_GDA_Field_allocbuf ()</title>
<programlisting><link linkend="GDA-Field">GDA_Field</link>*  CORBA_sequence_GDA_Field_allocbuf
                                            (<link linkend="CORBA-unsigned-long">CORBA_unsigned_long</link> len);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>len</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-Field-0">TC_IMPL_TC_CORBA_sequence_GDA_Field_0</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_Field_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-Field-1">TC_IMPL_TC_CORBA_sequence_GDA_Field_1</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_Field_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-Field-2">TC_IMPL_TC_CORBA_sequence_GDA_Field_2</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_Field_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-CORBA-sequence-GDA-Field">TC_CORBA_sequence_GDA_Field</title>
<programlisting>#define TC_CORBA_sequence_GDA_Field ((CORBA_TypeCode)&amp;TC_CORBA_sequence_GDA_Field_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-GDA-Field--alloc">CORBA_sequence_GDA_Field__alloc ()</title>
<programlisting><link linkend="CORBA-sequence-GDA-Field">CORBA_sequence_GDA_Field</link>* CORBA_sequence_GDA_Field__alloc
                                            (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-GDA-Field--free">CORBA_sequence_GDA_Field__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    CORBA_sequence_GDA_Field__free  (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Row">GDA_Row</title>
<programlisting>   typedef CORBA_sequence_GDA_Field GDA_Row;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Row-0">TC_IMPL_TC_GDA_Row_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Row_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Row-1">TC_IMPL_TC_GDA_Row_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Row_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Row-2">TC_IMPL_TC_GDA_Row_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Row_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Row">TC_GDA_Row</title>
<programlisting>#define TC_GDA_Row ((CORBA_TypeCode)&amp;TC_GDA_Row_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Row--alloc">GDA_Row__alloc ()</title>
<programlisting><link linkend="GDA-Row">GDA_Row</link>*    GDA_Row__alloc                  (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Row--free">GDA_Row__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_Row__free                   (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="ORBIT-DECL-CORBA-sequence-GDA-FieldAttributes">ORBIT_DECL_CORBA_sequence_GDA_FieldAttributes</title>
<programlisting>#define ORBIT_DECL_CORBA_sequence_GDA_FieldAttributes 1
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-FieldAttributes-0">ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_0</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-FieldAttributes-1">ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_1</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-FieldAttributes-2">ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_2</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_FieldAttributes_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-FieldAttributes-0">TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_0</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-FieldAttributes-1">TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_1</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-FieldAttributes-2">TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_2</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_FieldAttributes_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-CORBA-sequence-GDA-FieldAttributes">TC_CORBA_sequence_GDA_FieldAttributes</title>
<programlisting>#define TC_CORBA_sequence_GDA_FieldAttributes ((CORBA_TypeCode)&amp;TC_CORBA_sequence_GDA_FieldAttributes_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-GDA-FieldAttributes--free">CORBA_sequence_GDA_FieldAttributes__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    CORBA_sequence_GDA_FieldAttributes__free
                                            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-RowAttributes">GDA_RowAttributes</title>
<programlisting>   typedef CORBA_sequence_GDA_FieldAttributes GDA_RowAttributes;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-RowAttributes-0">TC_IMPL_TC_GDA_RowAttributes_0</title>
<programlisting>#define TC_IMPL_TC_GDA_RowAttributes_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-RowAttributes-1">TC_IMPL_TC_GDA_RowAttributes_1</title>
<programlisting>#define TC_IMPL_TC_GDA_RowAttributes_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-RowAttributes-2">TC_IMPL_TC_GDA_RowAttributes_2</title>
<programlisting>#define TC_IMPL_TC_GDA_RowAttributes_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-RowAttributes">TC_GDA_RowAttributes</title>
<programlisting>#define TC_GDA_RowAttributes ((CORBA_TypeCode)&amp;TC_GDA_RowAttributes_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-RowAttributes--alloc">GDA_RowAttributes__alloc ()</title>
<programlisting><link linkend="GDA-RowAttributes">GDA_RowAttributes</link>* GDA_RowAttributes__alloc (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-RowAttributes--free">GDA_RowAttributes__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_RowAttributes__free         (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-LockType">enum GDA_LockType</title>
<programlisting>   typedef enum
   {
      GDA_LOCK_READONLY,
      GDA_LOCK_PESSIMISTIC,
      GDA_LOCK_OPTIMISTIC,
      GDA_LOCK_BATCH
   }
   GDA_LockType;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-LockType-0">TC_IMPL_TC_GDA_LockType_0</title>
<programlisting>#define TC_IMPL_TC_GDA_LockType_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-LockType-1">TC_IMPL_TC_GDA_LockType_1</title>
<programlisting>#define TC_IMPL_TC_GDA_LockType_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-LockType-2">TC_IMPL_TC_GDA_LockType_2</title>
<programlisting>#define TC_IMPL_TC_GDA_LockType_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-LockType">TC_GDA_LockType</title>
<programlisting>#define TC_GDA_LockType ((CORBA_TypeCode)&amp;TC_GDA_LockType_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-CursorType">enum GDA_CursorType</title>
<programlisting>   typedef enum
   {
      GDA_OPEN_FWDONLY,
      GDA_OPEN_KEYSET,
      GDA_OPEN_DYNAMIC,
      GDA_OPEN_STATIC
   }
   GDA_CursorType;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CursorType-0">TC_IMPL_TC_GDA_CursorType_0</title>
<programlisting>#define TC_IMPL_TC_GDA_CursorType_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CursorType-1">TC_IMPL_TC_GDA_CursorType_1</title>
<programlisting>#define TC_IMPL_TC_GDA_CursorType_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CursorType-2">TC_IMPL_TC_GDA_CursorType_2</title>
<programlisting>#define TC_IMPL_TC_GDA_CursorType_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-CursorType">TC_GDA_CursorType</title>
<programlisting>#define TC_GDA_CursorType ((CORBA_TypeCode)&amp;TC_GDA_CursorType_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Option">enum GDA_Option</title>
<programlisting>   typedef enum
   {
      GDA_ADD_NEW,
      GDA_APPROX_POS,
      GDA_BOOKMARK,
      GDA_DELETE,
      GDA_HOLD_RECS,
      GDA_MOVE_PREV,
      GDA_DO_RESYNC,
      GDA_DO_UPDATE,
      GDA_UPDATE_BATCH
   }
   GDA_Option;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Option-0">TC_IMPL_TC_GDA_Option_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Option_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Option-1">TC_IMPL_TC_GDA_Option_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Option_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Option-2">TC_IMPL_TC_GDA_Option_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Option_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Option">TC_GDA_Option</title>
<programlisting>#define TC_GDA_Option ((CORBA_TypeCode)&amp;TC_GDA_Option_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-DECL-GDA-Recordset">ORBIT_DECL_GDA_Recordset</title>
<programlisting>#define ORBIT_DECL_GDA_Recordset 1
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset--free">GDA_Recordset__free</title>
<programlisting>#define GDA_Recordset__free CORBA_Object__free
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset">GDA_Recordset</title>
<programlisting>   typedef CORBA_Object GDA_Recordset;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset--classid">GDA_Recordset__classid</title>
<programlisting>   extern CORBA_unsigned_long GDA_Recordset__classid;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Recordset-0">TC_IMPL_TC_GDA_Recordset_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Recordset_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Recordset-1">TC_IMPL_TC_GDA_Recordset_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Recordset_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Recordset-2">TC_IMPL_TC_GDA_Recordset_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Recordset_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Recordset">TC_GDA_Recordset</title>
<programlisting>#define TC_GDA_Recordset ((CORBA_TypeCode)&amp;TC_GDA_Recordset_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-DECL-CORBA-sequence-GDA-Row">ORBIT_DECL_CORBA_sequence_GDA_Row</title>
<programlisting>#define ORBIT_DECL_CORBA_sequence_GDA_Row 1
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-Row-0">ORBIT_IMPL_CORBA_sequence_GDA_Row_0</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_Row_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-Row-1">ORBIT_IMPL_CORBA_sequence_GDA_Row_1</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_Row_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-Row-2">ORBIT_IMPL_CORBA_sequence_GDA_Row_2</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_Row_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-GDA-Row-allocbuf">CORBA_sequence_GDA_Row_allocbuf ()</title>
<programlisting><link linkend="GDA-Row">GDA_Row</link>*    CORBA_sequence_GDA_Row_allocbuf (<link linkend="CORBA-unsigned-long">CORBA_unsigned_long</link> len);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>len</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-Row-0">TC_IMPL_TC_CORBA_sequence_GDA_Row_0</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_Row_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-Row-1">TC_IMPL_TC_CORBA_sequence_GDA_Row_1</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_Row_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-Row-2">TC_IMPL_TC_CORBA_sequence_GDA_Row_2</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_Row_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-CORBA-sequence-GDA-Row">TC_CORBA_sequence_GDA_Row</title>
<programlisting>#define TC_CORBA_sequence_GDA_Row ((CORBA_TypeCode)&amp;TC_CORBA_sequence_GDA_Row_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-GDA-Row--alloc">CORBA_sequence_GDA_Row__alloc ()</title>
<programlisting><link linkend="CORBA-sequence-GDA-Row">CORBA_sequence_GDA_Row</link>* CORBA_sequence_GDA_Row__alloc
                                            (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-GDA-Row--free">CORBA_sequence_GDA_Row__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    CORBA_sequence_GDA_Row__free    (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-Chunk">GDA_Recordset_Chunk</title>
<programlisting>   typedef CORBA_sequence_GDA_Row GDA_Recordset_Chunk;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Recordset-Chunk-0">TC_IMPL_TC_GDA_Recordset_Chunk_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Recordset_Chunk_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Recordset-Chunk-1">TC_IMPL_TC_GDA_Recordset_Chunk_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Recordset_Chunk_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Recordset-Chunk-2">TC_IMPL_TC_GDA_Recordset_Chunk_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Recordset_Chunk_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Recordset-Chunk">TC_GDA_Recordset_Chunk</title>
<programlisting>#define TC_GDA_Recordset_Chunk ((CORBA_TypeCode)&amp;TC_GDA_Recordset_Chunk_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-Chunk--alloc">GDA_Recordset_Chunk__alloc ()</title>
<programlisting><link linkend="GDA-Recordset-Chunk">GDA_Recordset_Chunk</link>* GDA_Recordset_Chunk__alloc
                                            (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-Chunk--free">GDA_Recordset_Chunk__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_Recordset_Chunk__free       (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="ORBIT-DECL-GDA-Parameter">ORBIT_DECL_GDA_Parameter</title>
<programlisting>#define ORBIT_DECL_GDA_Parameter 1
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Parameter--free">GDA_Parameter__free</title>
<programlisting>#define GDA_Parameter__free CORBA_Object__free
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Parameter">GDA_Parameter</title>
<programlisting>   typedef CORBA_Object GDA_Parameter;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Parameter--classid">GDA_Parameter__classid</title>
<programlisting>   extern CORBA_unsigned_long GDA_Parameter__classid;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Parameter-0">TC_IMPL_TC_GDA_Parameter_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Parameter_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Parameter-1">TC_IMPL_TC_GDA_Parameter_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Parameter_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Parameter-2">TC_IMPL_TC_GDA_Parameter_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Parameter_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Parameter">TC_GDA_Parameter</title>
<programlisting>#define TC_GDA_Parameter ((CORBA_TypeCode)&amp;TC_GDA_Parameter_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Parameter-VarBinString">GDA_Parameter_VarBinString</title>
<programlisting>   typedef CORBA_sequence_CORBA_octet GDA_Parameter_VarBinString;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Parameter-VarBinString-0">TC_IMPL_TC_GDA_Parameter_VarBinString_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Parameter_VarBinString_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Parameter-VarBinString-1">TC_IMPL_TC_GDA_Parameter_VarBinString_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Parameter_VarBinString_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Parameter-VarBinString-2">TC_IMPL_TC_GDA_Parameter_VarBinString_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Parameter_VarBinString_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Parameter-VarBinString">TC_GDA_Parameter_VarBinString</title>
<programlisting>#define TC_GDA_Parameter_VarBinString ((CORBA_TypeCode)&amp;TC_GDA_Parameter_VarBinString_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Parameter-VarBinString--alloc">GDA_Parameter_VarBinString__alloc ()</title>
<programlisting><link linkend="GDA-Parameter-VarBinString">GDA_Parameter_VarBinString</link>* GDA_Parameter_VarBinString__alloc
                                            (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Parameter-VarBinString--free">GDA_Parameter_VarBinString__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_Parameter_VarBinString__free
                                            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-ParameterDirection">enum GDA_ParameterDirection</title>
<programlisting>   typedef enum
   {
      GDA_PARAM_IN,
      GDA_PARAM_OUT,
      GDA_PARAM_INOUT
   }
   GDA_ParameterDirection;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-ParameterDirection-0">TC_IMPL_TC_GDA_ParameterDirection_0</title>
<programlisting>#define TC_IMPL_TC_GDA_ParameterDirection_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-ParameterDirection-1">TC_IMPL_TC_GDA_ParameterDirection_1</title>
<programlisting>#define TC_IMPL_TC_GDA_ParameterDirection_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-ParameterDirection-2">TC_IMPL_TC_GDA_ParameterDirection_2</title>
<programlisting>#define TC_IMPL_TC_GDA_ParameterDirection_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-ParameterDirection">TC_GDA_ParameterDirection</title>
<programlisting>#define TC_GDA_ParameterDirection ((CORBA_TypeCode)&amp;TC_GDA_ParameterDirection_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CmdParameter-0">TC_IMPL_TC_GDA_CmdParameter_0</title>
<programlisting>#define TC_IMPL_TC_GDA_CmdParameter_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CmdParameter-1">TC_IMPL_TC_GDA_CmdParameter_1</title>
<programlisting>#define TC_IMPL_TC_GDA_CmdParameter_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CmdParameter-2">TC_IMPL_TC_GDA_CmdParameter_2</title>
<programlisting>#define TC_IMPL_TC_GDA_CmdParameter_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-CmdParameter">TC_GDA_CmdParameter</title>
<programlisting>#define TC_GDA_CmdParameter ((CORBA_TypeCode)&amp;TC_GDA_CmdParameter_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-CmdParameter--alloc">GDA_CmdParameter__alloc ()</title>
<programlisting><link linkend="GDA-CmdParameter">GDA_CmdParameter</link>* GDA_CmdParameter__alloc   (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-CmdParameter--free">GDA_CmdParameter__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_CmdParameter__free          (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="ORBIT-DECL-CORBA-sequence-GDA-CmdParameter">ORBIT_DECL_CORBA_sequence_GDA_CmdParameter</title>
<programlisting>#define ORBIT_DECL_CORBA_sequence_GDA_CmdParameter 1
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-CmdParameter-0">ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_0</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-CmdParameter-1">ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_1</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-CmdParameter-2">ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_2</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_CmdParameter_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-CmdParameter-0">TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_0</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-CmdParameter-1">TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_1</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-CmdParameter-2">TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_2</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_CmdParameter_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-CORBA-sequence-GDA-CmdParameter">TC_CORBA_sequence_GDA_CmdParameter</title>
<programlisting>#define TC_CORBA_sequence_GDA_CmdParameter ((CORBA_TypeCode)&amp;TC_CORBA_sequence_GDA_CmdParameter_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-GDA-CmdParameter--free">CORBA_sequence_GDA_CmdParameter__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    CORBA_sequence_GDA_CmdParameter__free
                                            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-CmdParameterSeq">GDA_CmdParameterSeq</title>
<programlisting>   typedef CORBA_sequence_GDA_CmdParameter GDA_CmdParameterSeq;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CmdParameterSeq-0">TC_IMPL_TC_GDA_CmdParameterSeq_0</title>
<programlisting>#define TC_IMPL_TC_GDA_CmdParameterSeq_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CmdParameterSeq-1">TC_IMPL_TC_GDA_CmdParameterSeq_1</title>
<programlisting>#define TC_IMPL_TC_GDA_CmdParameterSeq_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CmdParameterSeq-2">TC_IMPL_TC_GDA_CmdParameterSeq_2</title>
<programlisting>#define TC_IMPL_TC_GDA_CmdParameterSeq_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-CmdParameterSeq">TC_GDA_CmdParameterSeq</title>
<programlisting>#define TC_GDA_CmdParameterSeq ((CORBA_TypeCode)&amp;TC_GDA_CmdParameterSeq_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-CmdParameterSeq--alloc">GDA_CmdParameterSeq__alloc ()</title>
<programlisting><link linkend="GDA-CmdParameterSeq">GDA_CmdParameterSeq</link>* GDA_CmdParameterSeq__alloc
                                            (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-CmdParameterSeq--free">GDA_CmdParameterSeq__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_CmdParameterSeq__free       (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-CMD-NORECORDS-CAPS">GDA_CMD_NORECORDS</title>
<programlisting>#define GDA_CMD_NORECORDS 2147483648
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-CommandType">enum GDA_CommandType</title>
<programlisting>   typedef enum
   {
      GDA_COMMAND_TYPE_TEXT,
      GDA_COMMAND_TYPE_TABLE,
      GDA_COMMAND_TYPE_TABLEDIRECT,
      GDA_COMMAND_TYPE_STOREDPROCEDURE,
      GDA_COMMAND_TYPE_FILE,
      GDA_COMMAND_TYPE_XML
   }
   GDA_CommandType;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CommandType-0">TC_IMPL_TC_GDA_CommandType_0</title>
<programlisting>#define TC_IMPL_TC_GDA_CommandType_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CommandType-1">TC_IMPL_TC_GDA_CommandType_1</title>
<programlisting>#define TC_IMPL_TC_GDA_CommandType_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CommandType-2">TC_IMPL_TC_GDA_CommandType_2</title>
<programlisting>#define TC_IMPL_TC_GDA_CommandType_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-CommandType">TC_GDA_CommandType</title>
<programlisting>#define TC_GDA_CommandType ((CORBA_TypeCode)&amp;TC_GDA_CommandType_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-DECL-GDA-Command">ORBIT_DECL_GDA_Command</title>
<programlisting>#define ORBIT_DECL_GDA_Command 1
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Command--free">GDA_Command__free</title>
<programlisting>#define GDA_Command__free CORBA_Object__free
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Command">GDA_Command</title>
<programlisting>   typedef CORBA_Object GDA_Command;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Command--classid">GDA_Command__classid</title>
<programlisting>   extern CORBA_unsigned_long GDA_Command__classid;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Command-0">TC_IMPL_TC_GDA_Command_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Command_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Command-1">TC_IMPL_TC_GDA_Command_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Command_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Command-2">TC_IMPL_TC_GDA_Command_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Command_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Command">TC_GDA_Command</title>
<programlisting>#define TC_GDA_Command ((CORBA_TypeCode)&amp;TC_GDA_Command_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-CursorLocation">enum GDA_CursorLocation</title>
<programlisting>   typedef enum
   {
      GDA_USE_CLIENT_CURSOR,
      GDA_USE_SERVER_CURSOR
   }
   GDA_CursorLocation;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CursorLocation-0">TC_IMPL_TC_GDA_CursorLocation_0</title>
<programlisting>#define TC_IMPL_TC_GDA_CursorLocation_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CursorLocation-1">TC_IMPL_TC_GDA_CursorLocation_1</title>
<programlisting>#define TC_IMPL_TC_GDA_CursorLocation_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-CursorLocation-2">TC_IMPL_TC_GDA_CursorLocation_2</title>
<programlisting>#define TC_IMPL_TC_GDA_CursorLocation_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-CursorLocation">TC_GDA_CursorLocation</title>
<programlisting>#define TC_GDA_CursorLocation ((CORBA_TypeCode)&amp;TC_GDA_CursorLocation_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-DECL-GDA-Connection">ORBIT_DECL_GDA_Connection</title>
<programlisting>#define ORBIT_DECL_GDA_Connection 1
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Connection--free">GDA_Connection__free</title>
<programlisting>#define GDA_Connection__free CORBA_Object__free
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Connection">GDA_Connection</title>
<programlisting>   typedef CORBA_Object GDA_Connection;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Connection--classid">GDA_Connection__classid</title>
<programlisting>   extern CORBA_unsigned_long GDA_Connection__classid;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-0">TC_IMPL_TC_GDA_Connection_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-1">TC_IMPL_TC_GDA_Connection_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-2">TC_IMPL_TC_GDA_Connection_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Connection">TC_GDA_Connection</title>
<programlisting>#define TC_GDA_Connection ((CORBA_TypeCode)&amp;TC_GDA_Connection_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-QType">enum GDA_Connection_QType</title>
<programlisting>   typedef enum
   {
      GDA_Connection_GDCN_SCHEMA_AGGREGATES,
      GDA_Connection_GDCN_SCHEMA_ASSERTS,
      GDA_Connection_GDCN_SCHEMA_CATALOGS,
      GDA_Connection_GDCN_SCHEMA_CHARSETS,
      GDA_Connection_GDCN_SCHEMA_CHECK_CONSTRAINTS,
      GDA_Connection_GDCN_SCHEMA_COLLATIONS,
      GDA_Connection_GDCN_SCHEMA_COL_DOM_USAGE,
      GDA_Connection_GDCN_SCHEMA_COL_PRIVS,
      GDA_Connection_GDCN_SCHEMA_COLS,
      GDA_Connection_GDCN_SCHEMA_CONSTR_COL_USAGE,
      GDA_Connection_GDCN_SCHEMA_CONSTR_TAB_USAGE,
      GDA_Connection_GDCN_SCHEMA_FOREIGN_KEYS,
      GDA_Connection_GDCN_SCHEMA_INDEXES,
      GDA_Connection_GDCN_SCHEMA_INDEX_COLS,
      GDA_Connection_GDCN_SCHEMA_KEY_COL_USAGE,
      GDA_Connection_GDCN_SCHEMA_PRIM_KEYS,
      GDA_Connection_GDCN_SCHEMA_PROC_COLUMNS,
      GDA_Connection_GDCN_SCHEMA_PROC_PARAMS,
      GDA_Connection_GDCN_SCHEMA_PROCS,
      GDA_Connection_GDCN_SCHEMA_PROV_SPEC,
      GDA_Connection_GDCN_SCHEMA_PROV_TYPES,
      GDA_Connection_GDCN_SCHEMA_REF_CONSTRAINTS,
      GDA_Connection_GDCN_SCHEMA_SEQUENCES,
      GDA_Connection_GDCN_SCHEMA_SQL_LANG,
      GDA_Connection_GDCN_SCHEMA_STATISTICS,
      GDA_Connection_GDCN_SCHEMA_TAB_CONSTRAINTS,
      GDA_Connection_GDCN_SCHEMA_TAB_PARENTS,
      GDA_Connection_GDCN_SCHEMA_TAB_PRIVS,
      GDA_Connection_GDCN_SCHEMA_TABLES,
      GDA_Connection_GDCN_SCHEMA_TRANSLATIONS,
      GDA_Connection_GDCN_SCHEMA_USAGE_PROVS,
      GDA_Connection_GDCN_SCHEMA_VIEW_COL_USAGE,
      GDA_Connection_GDCN_SCHEMA_VIEW_TAB_USAGE,
      GDA_Connection_GDCN_SCHEMA_VIEWS,
      GDA_Connection_GDCN_SCHEMA_LAST
   }
   GDA_Connection_QType;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-QType-0">TC_IMPL_TC_GDA_Connection_QType_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_QType_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-QType-1">TC_IMPL_TC_GDA_Connection_QType_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_QType_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-QType-2">TC_IMPL_TC_GDA_Connection_QType_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_QType_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Connection-QType">TC_GDA_Connection_QType</title>
<programlisting>#define TC_GDA_Connection_QType ((CORBA_TypeCode)&amp;TC_GDA_Connection_QType_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-ConstraintType">enum GDA_Connection_ConstraintType</title>
<programlisting>   typedef enum
   {
      GDA_Connection_no_CONSTRAINT,
      GDA_Connection_OBJECT_CATALOG,
      GDA_Connection_OBJECT_SCHEMA,
      GDA_Connection_OBJECT_NAME,
      GDA_Connection_TABLE_TYPE,
      GDA_Connection_COLUMN_NAME,
      GDA_Connection_INDEX_NAME,
      GDA_Connection_TYPE,
      GDA_Connection_EXTRA_INFO
   }
   GDA_Connection_ConstraintType;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-ConstraintType-0">TC_IMPL_TC_GDA_Connection_ConstraintType_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_ConstraintType_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-ConstraintType-1">TC_IMPL_TC_GDA_Connection_ConstraintType_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_ConstraintType_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-ConstraintType-2">TC_IMPL_TC_GDA_Connection_ConstraintType_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_ConstraintType_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Connection-ConstraintType">TC_GDA_Connection_ConstraintType</title>
<programlisting>#define TC_GDA_Connection_ConstraintType ((CORBA_TypeCode)&amp;TC_GDA_Connection_ConstraintType_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-Permission">enum GDA_Connection_Permission</title>
<programlisting>   typedef enum
   {
      GDA_Connection_PERM_UNKNOWN,
      GDA_Connection_PERM_READ,
      GDA_Connection_PERM_WRITE,
      GDA_Connection_PERM_RW,
      GDA_Connection_PERM_DENY_READ,
      GDA_Connection_PERM_DENY_WRITE,
      GDA_Connection_PERM_EXCLUSIVE
   }
   GDA_Connection_Permission;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-Permission-0">TC_IMPL_TC_GDA_Connection_Permission_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_Permission_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-Permission-1">TC_IMPL_TC_GDA_Connection_Permission_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_Permission_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-Permission-2">TC_IMPL_TC_GDA_Connection_Permission_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_Permission_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Connection-Permission">TC_GDA_Connection_Permission</title>
<programlisting>#define TC_GDA_Connection_Permission ((CORBA_TypeCode)&amp;TC_GDA_Connection_Permission_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-Feature">enum GDA_Connection_Feature</title>
<programlisting>   typedef enum
   {
      GDA_Connection_FEATURE_FOREIGN_KEYS,
      GDA_Connection_FEATURE_INHERITANCE,
      GDA_Connection_FEATURE_OBJECT_ID,
      GDA_Connection_FEATURE_PROCS,
      GDA_Connection_FEATURE_SEQUENCES,
      GDA_Connection_FEATURE_SQL,
      GDA_Connection_FEATURE_SQL_SUBSELECT,
      GDA_Connection_FEATURE_TRANSACTIONS,
      GDA_Connection_FEATURE_TRIGGERS,
      GDA_Connection_FEATURE_VIEWS,
      GDA_Connection_FEATURE_XML_QUERIES
   }
   GDA_Connection_Feature;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-Feature-0">TC_IMPL_TC_GDA_Connection_Feature_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_Feature_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-Feature-1">TC_IMPL_TC_GDA_Connection_Feature_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_Feature_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-Feature-2">TC_IMPL_TC_GDA_Connection_Feature_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_Feature_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Connection-Feature">TC_GDA_Connection_Feature</title>
<programlisting>#define TC_GDA_Connection_Feature ((CORBA_TypeCode)&amp;TC_GDA_Connection_Feature_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-Constraint-0">TC_IMPL_TC_GDA_Connection_Constraint_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_Constraint_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-Constraint-1">TC_IMPL_TC_GDA_Connection_Constraint_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_Constraint_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-Constraint-2">TC_IMPL_TC_GDA_Connection_Constraint_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_Constraint_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Connection-Constraint">TC_GDA_Connection_Constraint</title>
<programlisting>#define TC_GDA_Connection_Constraint ((CORBA_TypeCode)&amp;TC_GDA_Connection_Constraint_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-Constraint--alloc">GDA_Connection_Constraint__alloc ()</title>
<programlisting><link linkend="GDA-Connection-Constraint">GDA_Connection_Constraint</link>* GDA_Connection_Constraint__alloc
                                            (void);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-Constraint--free">GDA_Connection_Constraint__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_Connection_Constraint__free (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="ORBIT-DECL-CORBA-sequence-GDA-Connection-Constraint">ORBIT_DECL_CORBA_sequence_GDA_Connection_Constraint</title>
<programlisting>#define ORBIT_DECL_CORBA_sequence_GDA_Connection_Constraint 1
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-Connection-Constraint-0">ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_0</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-Connection-Constraint-1">ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_1</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="ORBIT-IMPL-CORBA-sequence-GDA-Connection-Constraint-2">ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_2</title>
<programlisting>#define ORBIT_IMPL_CORBA_sequence_GDA_Connection_Constraint_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-Connection-Constraint-0">TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_0</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-Connection-Constraint-1">TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_1</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-CORBA-sequence-GDA-Connection-Constraint-2">TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_2</title>
<programlisting>#define TC_IMPL_TC_CORBA_sequence_GDA_Connection_Constraint_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-CORBA-sequence-GDA-Connection-Constraint">TC_CORBA_sequence_GDA_Connection_Constraint</title>
<programlisting>#define TC_CORBA_sequence_GDA_Connection_Constraint ((CORBA_TypeCode)&amp;TC_CORBA_sequence_GDA_Connection_Constraint_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="CORBA-sequence-GDA-Connection-Constraint--free">CORBA_sequence_GDA_Connection_Constraint__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    CORBA_sequence_GDA_Connection_Constraint__free
                                            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-ConstraintSeq-0">TC_IMPL_TC_GDA_Connection_ConstraintSeq_0</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_ConstraintSeq_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-ConstraintSeq-1">TC_IMPL_TC_GDA_Connection_ConstraintSeq_1</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_ConstraintSeq_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-Connection-ConstraintSeq-2">TC_IMPL_TC_GDA_Connection_ConstraintSeq_2</title>
<programlisting>#define TC_IMPL_TC_GDA_Connection_ConstraintSeq_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-Connection-ConstraintSeq">TC_GDA_Connection_ConstraintSeq</title>
<programlisting>#define TC_GDA_Connection_ConstraintSeq ((CORBA_TypeCode)&amp;TC_GDA_Connection_ConstraintSeq_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-ConstraintSeq--free">GDA_Connection_ConstraintSeq__free ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    GDA_Connection_ConstraintSeq__free
                                            (<link linkend="gpointer">gpointer</link> mem,
                                             <link linkend="gpointer">gpointer</link> dat,
                                             <link linkend="CORBA-boolean">CORBA_boolean</link> free_strings);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>mem</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dat</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>free_strings</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-AffectedRows">enum GDA_AffectedRows</title>
<programlisting>   typedef enum
   {
      GDA_GDR_AFFECT_CURRENT,
      GDA_GDR_AFFECT_GROUP,
      GDA_GDR_AFFECT_ALL
   }
   GDA_AffectedRows;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-AffectedRows-0">TC_IMPL_TC_GDA_AffectedRows_0</title>
<programlisting>#define TC_IMPL_TC_GDA_AffectedRows_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-AffectedRows-1">TC_IMPL_TC_GDA_AffectedRows_1</title>
<programlisting>#define TC_IMPL_TC_GDA_AffectedRows_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-AffectedRows-2">TC_IMPL_TC_GDA_AffectedRows_2</title>
<programlisting>#define TC_IMPL_TC_GDA_AffectedRows_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-AffectedRows">TC_GDA_AffectedRows</title>
<programlisting>#define TC_GDA_AffectedRows ((CORBA_TypeCode)&amp;TC_GDA_AffectedRows_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-IsolationLevel">enum GDA_IsolationLevel</title>
<programlisting>   typedef enum
   {
      GDA_IL_UNSPECIFIED,
      GDA_IL_CHAOS,
      GDA_IL_BROWSE,
      GDA_IL_READ_COMMITED,
      GDA_IL_READ_INCOMMTED,
      GDA_IL_READ_REPEATED,
      GDA_IL_READ_SERIALIZABLE
   }
   GDA_IsolationLevel;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-IsolationLevel-0">TC_IMPL_TC_GDA_IsolationLevel_0</title>
<programlisting>#define TC_IMPL_TC_GDA_IsolationLevel_0 'G'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-IsolationLevel-1">TC_IMPL_TC_GDA_IsolationLevel_1</title>
<programlisting>#define TC_IMPL_TC_GDA_IsolationLevel_1 'D'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-IMPL-TC-GDA-IsolationLevel-2">TC_IMPL_TC_GDA_IsolationLevel_2</title>
<programlisting>#define TC_IMPL_TC_GDA_IsolationLevel_2 'A'
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="TC-GDA-IsolationLevel">TC_GDA_IsolationLevel</title>
<programlisting>#define TC_GDA_IsolationLevel ((CORBA_TypeCode)&amp;TC_GDA_IsolationLevel_struct)
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="POA-GDA-Listener--init">POA_GDA_Listener__init ()</title>
<programlisting>void        POA_GDA_Listener__init          (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>servant</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="POA-GDA-Listener--fini">POA_GDA_Listener__fini ()</title>
<programlisting>void        POA_GDA_Listener__fini          (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>servant</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="POA-GDA-Recordset--init">POA_GDA_Recordset__init ()</title>
<programlisting>void        POA_GDA_Recordset__init         (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>servant</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="POA-GDA-Recordset--fini">POA_GDA_Recordset__fini ()</title>
<programlisting>void        POA_GDA_Recordset__fini         (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>servant</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="POA-GDA-Parameter--init">POA_GDA_Parameter__init ()</title>
<programlisting>void        POA_GDA_Parameter__init         (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>servant</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="POA-GDA-Parameter--fini">POA_GDA_Parameter__fini ()</title>
<programlisting>void        POA_GDA_Parameter__fini         (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>servant</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="POA-GDA-Command--init">POA_GDA_Command__init ()</title>
<programlisting>void        POA_GDA_Command__init           (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>servant</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="POA-GDA-Command--fini">POA_GDA_Command__fini ()</title>
<programlisting>void        POA_GDA_Command__fini           (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>servant</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="POA-GDA-Connection--init">POA_GDA_Connection__init ()</title>
<programlisting>void        POA_GDA_Connection__init        (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>servant</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="POA-GDA-Connection--fini">POA_GDA_Connection__fini ()</title>
<programlisting>void        POA_GDA_Connection__fini        (<link linkend="PortableServer-Servant">PortableServer_Servant</link> servant,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>servant</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Listener-ref">GDA_Listener_ref</title>
<programlisting>#define GDA_Listener_ref Bonobo_Unknown_ref
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Listener-unref">GDA_Listener_unref</title>
<programlisting>#define GDA_Listener_unref Bonobo_Unknown_unref
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Listener-queryInterface">GDA_Listener_queryInterface</title>
<programlisting>#define GDA_Listener_queryInterface Bonobo_Unknown_queryInterface
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Listener-notifyAction">GDA_Listener_notifyAction ()</title>
<programlisting>void        GDA_Listener_notifyAction       (<link linkend="GDA-Listener">GDA_Listener</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *message,
                                             const <link linkend="GDA-ListenerAction">GDA_ListenerAction</link> action,
                                             const <link linkend="CORBA-char">CORBA_char</link> *description,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>message</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>action</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>description</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-ref">GDA_Recordset_ref</title>
<programlisting>#define GDA_Recordset_ref Bonobo_Unknown_ref
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-unref">GDA_Recordset_unref</title>
<programlisting>#define GDA_Recordset_unref Bonobo_Unknown_unref
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-queryInterface">GDA_Recordset_queryInterface</title>
<programlisting>#define GDA_Recordset_queryInterface Bonobo_Unknown_queryInterface
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-getRowCount">GDA_Recordset_getRowCount ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Recordset_getRowCount       (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-close">GDA_Recordset_close ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Recordset_close             (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-moveFirst">GDA_Recordset_moveFirst ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Recordset_moveFirst         (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-moveLast">GDA_Recordset_moveLast ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Recordset_moveLast          (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-moveNext">GDA_Recordset_moveNext ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Recordset_moveNext          (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-movePrev">GDA_Recordset_movePrev ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Recordset_movePrev          (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-reQuery">GDA_Recordset_reQuery ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Recordset_reQuery           (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-supports">GDA_Recordset_supports ()</title>
<programlisting><link linkend="CORBA-boolean">CORBA_boolean</link> GDA_Recordset_supports        (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             const <link linkend="GDA-Option">GDA_Option</link> what,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>what</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-fetch">GDA_Recordset_fetch ()</title>
<programlisting><link linkend="GDA-Recordset-Chunk">GDA_Recordset_Chunk</link>* GDA_Recordset_fetch    (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             const <link linkend="CORBA-long">CORBA_long</link> count,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>count</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Recordset-describe">GDA_Recordset_describe ()</title>
<programlisting><link linkend="GDA-RowAttributes">GDA_RowAttributes</link>* GDA_Recordset_describe   (<link linkend="GDA-Recordset">GDA_Recordset</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Parameter-appendChunk">GDA_Parameter_appendChunk ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Parameter_appendChunk       (<link linkend="GDA-Parameter">GDA_Parameter</link> _obj,
                                             const <link linkend="GDA-Parameter-VarBinString">GDA_Parameter_VarBinString</link> *data,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>data</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Command-ref">GDA_Command_ref</title>
<programlisting>#define GDA_Command_ref Bonobo_Unknown_ref
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Command-unref">GDA_Command_unref</title>
<programlisting>#define GDA_Command_unref Bonobo_Unknown_unref
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Command-queryInterface">GDA_Command_queryInterface</title>
<programlisting>#define GDA_Command_queryInterface Bonobo_Unknown_queryInterface
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Command--get-text">GDA_Command__get_text ()</title>
<programlisting><link linkend="CORBA-char">CORBA_char</link>* GDA_Command__get_text           (<link linkend="GDA-Command">GDA_Command</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Command--set-text">GDA_Command__set_text ()</title>
<programlisting>void        GDA_Command__set_text           (<link linkend="GDA-Command">GDA_Command</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *value,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Command--get-type">GDA_Command__get_type ()</title>
<programlisting><link linkend="GDA-CommandType">GDA_CommandType</link> GDA_Command__get_type       (<link linkend="GDA-Command">GDA_Command</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Command--set-type">GDA_Command__set_type ()</title>
<programlisting>void        GDA_Command__set_type           (<link linkend="GDA-Command">GDA_Command</link> _obj,
                                             const <link linkend="GDA-CommandType">GDA_CommandType</link> value,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Command-open">GDA_Command_open ()</title>
<programlisting><link linkend="GDA-Recordset">GDA_Recordset</link> GDA_Command_open              (<link linkend="GDA-Command">GDA_Command</link> _obj,
                                             const <link linkend="GDA-CmdParameterSeq">GDA_CmdParameterSeq</link> *param,
                                             const <link linkend="GDA-CursorType">GDA_CursorType</link> ct,
                                             const <link linkend="GDA-LockType">GDA_LockType</link> lt,
                                             <link linkend="CORBA-unsigned-long">CORBA_unsigned_long</link> *affected,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>param</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ct</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>lt</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>affected</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-ref">GDA_Connection_ref</title>
<programlisting>#define GDA_Connection_ref Bonobo_Unknown_ref
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-unref">GDA_Connection_unref</title>
<programlisting>#define GDA_Connection_unref Bonobo_Unknown_unref
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-queryInterface">GDA_Connection_queryInterface</title>
<programlisting>#define GDA_Connection_queryInterface Bonobo_Unknown_queryInterface
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GDA-Connection--get-version">GDA_Connection__get_version ()</title>
<programlisting><link linkend="CORBA-char">CORBA_char</link>* GDA_Connection__get_version     (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection--get-errors">GDA_Connection__get_errors ()</title>
<programlisting><link linkend="GDA-ErrorSeq">GDA_ErrorSeq</link>* GDA_Connection__get_errors    (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-beginTransaction">GDA_Connection_beginTransaction ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Connection_beginTransaction (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-commitTransaction">GDA_Connection_commitTransaction ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Connection_commitTransaction
                                            (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-rollbackTransaction">GDA_Connection_rollbackTransaction ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Connection_rollbackTransaction
                                            (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-close">GDA_Connection_close ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Connection_close            (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-open">GDA_Connection_open ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Connection_open             (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *dsn,
                                             const <link linkend="CORBA-char">CORBA_char</link> *user,
                                             const <link linkend="CORBA-char">CORBA_char</link> *passwd,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>dsn</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>user</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>passwd</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-openSchema">GDA_Connection_openSchema ()</title>
<programlisting><link linkend="GDA-Recordset">GDA_Recordset</link> GDA_Connection_openSchema     (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="GDA-Connection-QType">GDA_Connection_QType</link> t,
                                             const <link linkend="GDA-Connection-ConstraintSeq">GDA_Connection_ConstraintSeq</link> *constraints,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>t</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>constraints</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-modifySchema">GDA_Connection_modifySchema ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Connection_modifySchema     (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="GDA-Connection-QType">GDA_Connection_QType</link> t,
                                             const <link linkend="GDA-Connection-ConstraintSeq">GDA_Connection_ConstraintSeq</link> *constraints,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>t</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>constraints</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-createCommand">GDA_Connection_createCommand ()</title>
<programlisting><link linkend="GDA-Command">GDA_Command</link> GDA_Connection_createCommand    (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-createRecordset">GDA_Connection_createRecordset ()</title>
<programlisting><link linkend="GDA-Recordset">GDA_Recordset</link> GDA_Connection_createRecordset
                                            (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-startLogging">GDA_Connection_startLogging ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Connection_startLogging     (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *filename,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>filename</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-stopLogging">GDA_Connection_stopLogging ()</title>
<programlisting><link linkend="CORBA-long">CORBA_long</link>  GDA_Connection_stopLogging      (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-createTable">GDA_Connection_createTable ()</title>
<programlisting><link linkend="CORBA-char">CORBA_char</link>* GDA_Connection_createTable      (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *name,
                                             const <link linkend="GDA-RowAttributes">GDA_RowAttributes</link> *columns,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>columns</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-supports">GDA_Connection_supports ()</title>
<programlisting><link linkend="CORBA-boolean">CORBA_boolean</link> GDA_Connection_supports       (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="GDA-Connection-Feature">GDA_Connection_Feature</link> feature,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>feature</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-sql2xml">GDA_Connection_sql2xml ()</title>
<programlisting><link linkend="CORBA-char">CORBA_char</link>* GDA_Connection_sql2xml          (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *sql,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>sql</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-xml2sql">GDA_Connection_xml2sql ()</title>
<programlisting><link linkend="CORBA-char">CORBA_char</link>* GDA_Connection_xml2sql          (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="CORBA-char">CORBA_char</link> *xml,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>xml</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-addListener">GDA_Connection_addListener ()</title>
<programlisting>void        GDA_Connection_addListener      (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="GDA-Listener">GDA_Listener</link> listener,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>listener</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GDA-Connection-removeListener">GDA_Connection_removeListener ()</title>
<programlisting>void        GDA_Connection_removeListener   (<link linkend="GDA-Connection">GDA_Connection</link> _obj,
                                             const <link linkend="GDA-Listener">GDA_Listener</link> listener,
                                             <link linkend="CORBA-Environment">CORBA_Environment</link> *ev);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>_obj</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>listener</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>ev</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>

</refsect1>




</refentry>
