---

defs.cc

/*
*  Name:         defs.cc
*  Author:       Rafael Jesus Alcantara Perez
*  Contributor:  Francisco Vides Fernandez
*  Summary:      UESQLC definitions
*  Date:         $Date: 2003/10/06 13:21:35 $
*  Revision:     $Revision: 1.2 $
*
*  Copyright (C) 1996-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#include <mpcl/text/string.hh>
#include <mpcl/util/collection/map.hh>
#include <uesqlc/defs.hh>


namespace uesqlc
{

  //
  //  L O C A L   V A R I A B L E S
  //

  static const char*   _pkcSqlerrorDescription = "uesql: SQLERROR condition";

  static const char*   _pkcNotFoundDescription = "uesql: NOT FOUND condition";


  //
  //  E X P O R T E D   V A R I A B L E S   F O R   U E S Q L C - C O M P I L E R
  //
  //   G E N E R A T E D   S O U R C E S   A N D   C L I E N T   P R O G R A M S
  // 

  mpcl::util::collection::TMap<mpcl::text::TString, int>   TSqlstateDescriptor::_tValueToIntMap;
  long int                                                 SQLCODE    = 0;
  mpcl::text::TString                                      SQLMESSAGE = "";
  mpcl::text::TString                                      SQLSTATE   = "00000";


  //
  //  SQLSTATE class and subclass values.
  //    Classes has been represented as a C++ namespace, and subclasses have
  //    been represented as a constant pointer to a zero terminated string.
  //

  
  namespace ambiguous_cursor_name
  {
    const char*   pkcNO_SUBCLASS = "3C000";
  }

  namespace cardinality_violation
  {
    const char*   pkcNO_SUBCLASS = "21000";
  }
  
  namespace connection_exception
  {
    const char*   pkcNO_SUBCLASS                                       = "08000";
    const char*   pkcCONNECTION_DOES_NOT_EXIST                         = "08003";
    const char*   pkcCONNECTION_FAILURE                                = "08006";
    const char*   pkcCONNECTION_NAME_IN_USE                            = "08002";
    const char*   pkcSQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION       = "08001";
    const char*   pkcSQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION = "08004";
    const char*   pkcTRANSACTION_RESOLUTION_UNKNOWN                    = "08007";
  }
  
  namespace data_exception
  {
    const char*   pkcNO_SUBCLASS                          = "22000";
    const char*   pkcCHARACTER_NOT_IN_REPERTOIRE          = "22021";
    const char*   pkcDATETIME_FIELD_OVERFLOW              = "22008";
    const char*   pkcDIVISION_BY_ZERO                     = "22012";
    const char*   pkcERROR_IN_ASSIGNMENT                  = "22005";
    const char*   pkcINDICATOR_OVERFLOW                   = "22022";
    const char*   pkcINTERVAL_FIELD_OVERFLOW              = "22015";
    const char*   pkcINVALID_CHARACTER_VALUE_FOR_CAST     = "22018";
    const char*   pkcINVALID_DATETIME_FORMAT              = "22007";
    const char*   pkcINVALID_ESCAPE_CHARACTER             = "22019";
    const char*   pkcINVALID_ESCAPE_SEQUENCE              = "22025";
    const char*   pkcINVALID_PARAMETER_VALUE              = "22023";
    const char*   pkcINVALID_TIME_ZONE_DISPLACEMENT_VALUE = "22009";
    const char*   pkcNULL_VALUE_NO_INDICATOR_PARAMETER    = "22002";
    const char*   pkcNUMERIC_VALUE_OUT_OF_RANGE           = "22003";
    const char*   pkcSTRING_DATA_LENGTH_MISMATCH          = "22026";
    const char*   pkcSTRING_DATA_RIGHT_TRUNCATION         = "22001";
    const char*   pkcSUBSTRING_ERROR                      = "22011";
    const char*   pkcTRIM_ERROR                           = "22027";
    const char*   pkcUNTERMINATED_C_STRING                = "22024";
  }
  
  namespace dependent_privilege_descriptors_still_exist
  {
    const char*   pkcNO_SUBCLASS = "2B000";
  }
  
  namespace dynamic_sql_error
  {
    const char*   pkcNO_SUBCLASS                                        = "07000";
    const char*   pkcCURSOR_SPECIFICATION_CANNOT_BE_EXECUTED            = "07003";
    const char*   pkcINVALID_DESCRIPTOR_COUNT                           = "07008";
    const char*   pkcINVALID_DESCRIPTOR_INDEX                           = "07009";
    const char*   pkcPREPARED_STATEMENT_NOT_A_CURSOR_SPECIFICATION      = "07005";
    const char*   pkcRESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION           = "07006";
    const char*   pkcUSING_CLAUSE_DOES_NOT_MATCH_DYNAMIC_PARAMETER_SPEC = "07001";
    const char*   pkcUSING_CLAUSE_DOES_NOT_MATCH_TARGET_SPEC            = "07002";
    const char*   pkcUSING_CLAUSE_REQUIRED_FOR_DYNAMIC_PARAMETERS       = "07004";
    const char*   pkcUSING_CLAUSE_REQUIRED_FOR_RESULT_FIELDS            = "07007";
  }
  
  namespace feature_not_supported
  {
    const char*   pkcNO_SUBCLASS                       = "0A000";
    const char*   pkcMULTIPLE_ENVIRONMENT_TRANSACTIONS = "0A001";
  }
  
  namespace integrity_constraint_violation
  {
    const char*   pkcNO_SUBCLASS = "23000";
  }
  
  namespace invalid_authorization_specification
  {
    const char*   pkcNO_SUBCLASS = "28000";
  }
  
  namespace invalid_catalog_name
  {
    const char*   pkcNO_SUBCLASS = "3D000";
  }
  
  namespace invalid_character_set_name
  {
    const char*   pkcNO_SUBCLASS = "2C000";
  }
  
  namespace invalid_condition_number
  {
    const char*   pkcNO_SUBCLASS = "35000";
  }
  
  namespace invalid_connection_name
  {
    const char*   pkcNO_SUBCLASS = "2E000";
  }
  
  namespace invalid_cursor_name
  {
    const char*   pkcNO_SUBCLASS = "34000";
  }
  
  namespace invalid_cursor_state
  {
    const char*   pkcNO_SUBCLASS = "24000";
  }
  
  namespace invalid_schema_name
  {
    const char*   pkcNO_SUBCLASS = "3F000";
  }
  
  namespace invalid_sql_descriptor_name
  {
    const char*   pkcNO_SUBCLASS = "33000";
  }
  
  namespace invalid_sql_statement_name
  {
    const char*   pkcNO_SUBCLASS = "26000";
  }
  
  namespace invalid_transaction_state
  {
    const char*   pkcNO_SUBCLASS = "25000";
  }
  
  namespace invalid_transaction_termination
  {
    const char*   pkcNO_SUBCLASS = "2D000";
  }
  
  namespace no_data
  {
    const char*   pkcNO_SUBCLASS = "02000";
  }
  
  namespace remote_database_access
  {
    const char*   pkcNO_SUBCLASS = "HZ000";
  }
  
  namespace successful_completion
  {
    const char*   pkcNO_SUBCLASS = "00000";
  }
  
  namespace syntax_error_or_access_rule_violation
  {
    const char*   pkcNO_SUBCLASS = "42000";
  }
  
  namespace syntax_error_or_access_rule_violation_in_direct_statement
  {
    const char*   pkcNO_SUBCLASS = "2A000";
  }
  
  namespace syntax_error_or_access_rule_violation_in_dynamic_statement
  {
    const char*   pkcNO_SUBCLASS = "37000";
  }
  
  namespace transaction_rollback
  {
    const char*   pkcNO_SUBCLASS                    = "40000";
    const char*   pkcINTEGRITY_CONSTRAINT_VIOLATION = "40002";
    const char*   pkcSERIALIZATION_FAILURE          = "40001";
    const char*   pkcSTATEMENT_COMPLETION_UNKNOWN   = "40003";
  }
  
  namespace triggered_data_change_violation
  {
    const char*   pkcNO_SUBCLASS = "27000";
  }
  
  namespace warning
  {
    const char*   pkcNO_SUBCLASS                                      = "01000";
    const char*   pkcCURSOR_OPERATION_CONFLICT                        = "01001";
    const char*   pkcDISCONNECT_ERROR                                 = "01002";
    const char*   pkcIMPLICIT_ZERO_BIT_PADDING                        = "01008";
    const char*   pkcINSUFFICIENT_ITEM_DESCRIPTOR_AREAS               = "01005";
    const char*   pkcNULL_VALUE_ELIMINATED_IN_SET_FUNCTION            = "01003";
    const char*   pkcPRIVILEGE_NOT_GRANTED                            = "01007";
    const char*   pkcPRIVILEGE_NOT_REVOKED                            = "01006";
    const char*   pkcQUERY_EXPRESSION_TOO_LONG_FOR_INFORMATION_SCHEMA = "0100A";
    const char*   pkcSEARCH_CONDITION_TOO_LONG_FOR_INFORMATION_SCHEMA = "01009";
    const char*   pkcSTRING_DATA_RIGHT_TRUNCATION                     = "01004";
  }
  
  namespace with_check_option_violation
  {
    const char*   pkcNO_SUBCLASS = "44000";
  }

}  // namespace uesqlc


//
//  L O C A L   F U N C T I O N S
//

void uesqlc::TSqlstateDescriptor::
_addCondition ( const char* pkcSQLSTATE ,
                int         iVALUE      )
{

  _tValueToIntMap.insert (std::make_pair (pkcSQLSTATE, iVALUE));

}  // _addCondition()


void uesqlc::TSqlstateDescriptor::_initialize (void)
{

  if ( _tValueToIntMap.empty() )
  {
    _addCondition (ambiguous_cursor_name::pkcNO_SUBCLASS, ambiguous_cursor_name::eNO_SUBCLASS);
    _addCondition (cardinality_violation::pkcNO_SUBCLASS, cardinality_violation::eNO_SUBCLASS);
    _addCondition (connection_exception::pkcNO_SUBCLASS, connection_exception::eNO_SUBCLASS);
    _addCondition (connection_exception::pkcCONNECTION_DOES_NOT_EXIST, connection_exception::eCONNECTION_DOES_NOT_EXIST);
    _addCondition (connection_exception::pkcCONNECTION_FAILURE, connection_exception::eCONNECTION_FAILURE);
    _addCondition (connection_exception::pkcCONNECTION_NAME_IN_USE, connection_exception::eCONNECTION_NAME_IN_USE);
    _addCondition (connection_exception::pkcSQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION, connection_exception::eSQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION);
    _addCondition (connection_exception::pkcSQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION, connection_exception::eSQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION);
    _addCondition (connection_exception::pkcTRANSACTION_RESOLUTION_UNKNOWN, connection_exception::eTRANSACTION_RESOLUTION_UNKNOWN);
    _addCondition (data_exception::pkcNO_SUBCLASS, data_exception::eNO_SUBCLASS);
    _addCondition (data_exception::pkcCHARACTER_NOT_IN_REPERTOIRE, data_exception::eCHARACTER_NOT_IN_REPERTOIRE);
    _addCondition (data_exception::pkcDATETIME_FIELD_OVERFLOW, data_exception::eDATETIME_FIELD_OVERFLOW);
    _addCondition (data_exception::pkcDIVISION_BY_ZERO, data_exception::eDIVISION_BY_ZERO);
    _addCondition (data_exception::pkcERROR_IN_ASSIGNMENT, data_exception::eERROR_IN_ASSIGNMENT);
    _addCondition (data_exception::pkcINDICATOR_OVERFLOW, data_exception::eINDICATOR_OVERFLOW);
    _addCondition (data_exception::pkcINTERVAL_FIELD_OVERFLOW, data_exception::eINTERVAL_FIELD_OVERFLOW);
    _addCondition (data_exception::pkcINVALID_CHARACTER_VALUE_FOR_CAST, data_exception::eINVALID_CHARACTER_VALUE_FOR_CAST);
    _addCondition (data_exception::pkcINVALID_DATETIME_FORMAT, data_exception::eINVALID_DATETIME_FORMAT);
    _addCondition (data_exception::pkcINVALID_ESCAPE_CHARACTER, data_exception::eINVALID_ESCAPE_CHARACTER);
    _addCondition (data_exception::pkcINVALID_ESCAPE_SEQUENCE, data_exception::eINVALID_ESCAPE_SEQUENCE);
    _addCondition (data_exception::pkcINVALID_PARAMETER_VALUE, data_exception::eINVALID_PARAMETER_VALUE);
    _addCondition (data_exception::pkcINVALID_TIME_ZONE_DISPLACEMENT_VALUE, data_exception::eINVALID_TIME_ZONE_DISPLACEMENT_VALUE);
    _addCondition (data_exception::pkcNULL_VALUE_NO_INDICATOR_PARAMETER, data_exception::eNULL_VALUE_NO_INDICATOR_PARAMETER);
    _addCondition (data_exception::pkcNUMERIC_VALUE_OUT_OF_RANGE, data_exception::eNUMERIC_VALUE_OUT_OF_RANGE);
    _addCondition (data_exception::pkcSTRING_DATA_LENGTH_MISMATCH, data_exception::eSTRING_DATA_LENGTH_MISMATCH);
    _addCondition (data_exception::pkcSTRING_DATA_RIGHT_TRUNCATION, data_exception::eSTRING_DATA_RIGHT_TRUNCATION);
    _addCondition (data_exception::pkcSUBSTRING_ERROR, data_exception::eSUBSTRING_ERROR);
    _addCondition (data_exception::pkcTRIM_ERROR, data_exception::eTRIM_ERROR);
    _addCondition (data_exception::pkcUNTERMINATED_C_STRING, data_exception::eUNTERMINATED_C_STRING);
    _addCondition (dependent_privilege_descriptors_still_exist::pkcNO_SUBCLASS, dependent_privilege_descriptors_still_exist::eNO_SUBCLASS);
    _addCondition (dynamic_sql_error::pkcNO_SUBCLASS, dynamic_sql_error::eNO_SUBCLASS);
    _addCondition (dynamic_sql_error::pkcCURSOR_SPECIFICATION_CANNOT_BE_EXECUTED, dynamic_sql_error::eCURSOR_SPECIFICATION_CANNOT_BE_EXECUTED);
    _addCondition (dynamic_sql_error::pkcINVALID_DESCRIPTOR_COUNT, dynamic_sql_error::eINVALID_DESCRIPTOR_COUNT);
    _addCondition (dynamic_sql_error::pkcINVALID_DESCRIPTOR_INDEX, dynamic_sql_error::eINVALID_DESCRIPTOR_INDEX);
    _addCondition (dynamic_sql_error::pkcPREPARED_STATEMENT_NOT_A_CURSOR_SPECIFICATION, dynamic_sql_error::ePREPARED_STATEMENT_NOT_A_CURSOR_SPECIFICATION);
    _addCondition (dynamic_sql_error::pkcRESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, dynamic_sql_error::eRESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION);
    _addCondition (dynamic_sql_error::pkcUSING_CLAUSE_DOES_NOT_MATCH_DYNAMIC_PARAMETER_SPEC, dynamic_sql_error::eUSING_CLAUSE_DOES_NOT_MATCH_DYNAMIC_PARAMETER_SPEC);
    _addCondition (dynamic_sql_error::pkcUSING_CLAUSE_DOES_NOT_MATCH_TARGET_SPEC, dynamic_sql_error::eUSING_CLAUSE_DOES_NOT_MATCH_TARGET_SPEC);
    _addCondition (dynamic_sql_error::pkcUSING_CLAUSE_REQUIRED_FOR_DYNAMIC_PARAMETERS, dynamic_sql_error::eUSING_CLAUSE_REQUIRED_FOR_DYNAMIC_PARAMETERS);
    _addCondition (dynamic_sql_error::pkcUSING_CLAUSE_REQUIRED_FOR_RESULT_FIELDS, dynamic_sql_error::eUSING_CLAUSE_REQUIRED_FOR_RESULT_FIELDS);
    _addCondition (feature_not_supported::pkcNO_SUBCLASS, feature_not_supported::eNO_SUBCLASS);
    _addCondition (feature_not_supported::pkcMULTIPLE_ENVIRONMENT_TRANSACTIONS, feature_not_supported::eMULTIPLE_ENVIRONMENT_TRANSACTIONS);
    _addCondition (integrity_constraint_violation::pkcNO_SUBCLASS, integrity_constraint_violation::eNO_SUBCLASS);
    _addCondition (invalid_authorization_specification::pkcNO_SUBCLASS, invalid_authorization_specification::eNO_SUBCLASS);
    _addCondition (invalid_catalog_name::pkcNO_SUBCLASS, invalid_catalog_name::eNO_SUBCLASS);
    _addCondition (invalid_character_set_name::pkcNO_SUBCLASS, invalid_character_set_name::eNO_SUBCLASS);
    _addCondition (invalid_condition_number::pkcNO_SUBCLASS, invalid_condition_number::eNO_SUBCLASS);
    _addCondition (invalid_connection_name::pkcNO_SUBCLASS, invalid_connection_name::eNO_SUBCLASS);
    _addCondition (invalid_cursor_name::pkcNO_SUBCLASS, invalid_cursor_name::eNO_SUBCLASS);
    _addCondition (invalid_cursor_state::pkcNO_SUBCLASS, invalid_cursor_state::eNO_SUBCLASS);
    _addCondition (invalid_schema_name::pkcNO_SUBCLASS, invalid_schema_name::eNO_SUBCLASS);
    _addCondition (invalid_sql_descriptor_name::pkcNO_SUBCLASS, invalid_sql_descriptor_name::eNO_SUBCLASS);
    _addCondition (invalid_sql_statement_name::pkcNO_SUBCLASS, invalid_sql_statement_name::eNO_SUBCLASS);
    _addCondition (invalid_transaction_state::pkcNO_SUBCLASS, invalid_transaction_state::eNO_SUBCLASS);
    _addCondition (invalid_transaction_termination::pkcNO_SUBCLASS, invalid_transaction_termination::eNO_SUBCLASS);
    _addCondition (no_data::pkcNO_SUBCLASS, no_data::eNO_SUBCLASS);
    _addCondition (remote_database_access::pkcNO_SUBCLASS, remote_database_access::eNO_SUBCLASS);
    _addCondition (successful_completion::pkcNO_SUBCLASS, successful_completion::eNO_SUBCLASS);
    _addCondition (syntax_error_or_access_rule_violation::pkcNO_SUBCLASS, syntax_error_or_access_rule_violation::eNO_SUBCLASS);
    _addCondition (syntax_error_or_access_rule_violation_in_direct_statement::pkcNO_SUBCLASS, syntax_error_or_access_rule_violation_in_direct_statement::eNO_SUBCLASS);
    _addCondition (syntax_error_or_access_rule_violation_in_dynamic_statement::pkcNO_SUBCLASS, syntax_error_or_access_rule_violation_in_dynamic_statement::eNO_SUBCLASS);
    _addCondition (transaction_rollback::pkcNO_SUBCLASS, transaction_rollback::eNO_SUBCLASS);
    _addCondition (transaction_rollback::pkcINTEGRITY_CONSTRAINT_VIOLATION, transaction_rollback::eINTEGRITY_CONSTRAINT_VIOLATION);
    _addCondition (transaction_rollback::pkcSERIALIZATION_FAILURE, transaction_rollback::eSERIALIZATION_FAILURE);
    _addCondition (transaction_rollback::pkcSTATEMENT_COMPLETION_UNKNOWN, transaction_rollback::eSTATEMENT_COMPLETION_UNKNOWN);
    _addCondition (triggered_data_change_violation::pkcNO_SUBCLASS, triggered_data_change_violation::eNO_SUBCLASS);
    _addCondition (warning::pkcNO_SUBCLASS, warning::eNO_SUBCLASS);
    _addCondition (warning::pkcCURSOR_OPERATION_CONFLICT, warning::eCURSOR_OPERATION_CONFLICT);
    _addCondition (warning::pkcDISCONNECT_ERROR, warning::eDISCONNECT_ERROR);
    _addCondition (warning::pkcIMPLICIT_ZERO_BIT_PADDING, warning::eIMPLICIT_ZERO_BIT_PADDING);
    _addCondition (warning::pkcINSUFFICIENT_ITEM_DESCRIPTOR_AREAS, warning::eINSUFFICIENT_ITEM_DESCRIPTOR_AREAS);
    _addCondition (warning::pkcNULL_VALUE_ELIMINATED_IN_SET_FUNCTION, warning::eNULL_VALUE_ELIMINATED_IN_SET_FUNCTION);
    _addCondition (warning::pkcPRIVILEGE_NOT_GRANTED, warning::ePRIVILEGE_NOT_GRANTED);
    _addCondition (warning::pkcPRIVILEGE_NOT_REVOKED, warning::ePRIVILEGE_NOT_REVOKED);
    _addCondition (warning::pkcQUERY_EXPRESSION_TOO_LONG_FOR_INFORMATION_SCHEMA, warning::eQUERY_EXPRESSION_TOO_LONG_FOR_INFORMATION_SCHEMA);
    _addCondition (warning::pkcSEARCH_CONDITION_TOO_LONG_FOR_INFORMATION_SCHEMA, warning::eSEARCH_CONDITION_TOO_LONG_FOR_INFORMATION_SCHEMA);
    _addCondition (warning::pkcSTRING_DATA_RIGHT_TRUNCATION, warning::eSTRING_DATA_RIGHT_TRUNCATION);
    _addCondition (with_check_option_violation::pkcNO_SUBCLASS, with_check_option_violation::eNO_SUBCLASS);
  }

}  // TSqlstateDescriptor::_initialize()
  

//
//  C O N S T R U C T O R S
//

const char* uesqlc::TSqlstateDescriptor::getClassValue (const char* pkcSQLSTATE) const
{

  const char*   pkcClass = NULL;
    
  switch (getUniqueValue (pkcSQLSTATE))
  {
    case ambiguous_cursor_name::eNO_SUBCLASS:
    {
      pkcClass = "ambiguous cursor name";
      break;
    }
    case cardinality_violation::eNO_SUBCLASS:
    {
      pkcClass = "cardinality violation";
      break;
    }
    case connection_exception::eNO_SUBCLASS:
    case connection_exception::eCONNECTION_DOES_NOT_EXIST:
    case connection_exception::eCONNECTION_FAILURE:
    case connection_exception::eCONNECTION_NAME_IN_USE:
    case connection_exception::eSQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION:
    case connection_exception::eSQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION:
    case connection_exception::eTRANSACTION_RESOLUTION_UNKNOWN:
    {
      pkcClass = "connection exception";
      break;
    }
    case data_exception::eNO_SUBCLASS:
    case data_exception::eCHARACTER_NOT_IN_REPERTOIRE:
    case data_exception::eDATETIME_FIELD_OVERFLOW:
    case data_exception::eDIVISION_BY_ZERO:
    case data_exception::eERROR_IN_ASSIGNMENT:
    case data_exception::eINDICATOR_OVERFLOW:
    case data_exception::eINTERVAL_FIELD_OVERFLOW:
    case data_exception::eINVALID_CHARACTER_VALUE_FOR_CAST:
    case data_exception::eINVALID_DATETIME_FORMAT:
    case data_exception::eINVALID_ESCAPE_CHARACTER:
    case data_exception::eINVALID_ESCAPE_SEQUENCE:
    case data_exception::eINVALID_PARAMETER_VALUE:
    case data_exception::eINVALID_TIME_ZONE_DISPLACEMENT_VALUE:
    case data_exception::eNULL_VALUE_NO_INDICATOR_PARAMETER:
    case data_exception::eNUMERIC_VALUE_OUT_OF_RANGE:
    case data_exception::eSTRING_DATA_LENGTH_MISMATCH:
    case data_exception::eSTRING_DATA_RIGHT_TRUNCATION:
    case data_exception::eSUBSTRING_ERROR:
    case data_exception::eTRIM_ERROR:
    case data_exception::eUNTERMINATED_C_STRING:
    {
      pkcClass = "data exception";
      break;
    }
    case dependent_privilege_descriptors_still_exist::eNO_SUBCLASS:
    {
      pkcClass = "dependent privilege descriptors still exist";
      break;
    }
    case dynamic_sql_error::eNO_SUBCLASS:
    case dynamic_sql_error::eCURSOR_SPECIFICATION_CANNOT_BE_EXECUTED:
    case dynamic_sql_error::eINVALID_DESCRIPTOR_COUNT:
    case dynamic_sql_error::eINVALID_DESCRIPTOR_INDEX:
    case dynamic_sql_error::ePREPARED_STATEMENT_NOT_A_CURSOR_SPECIFICATION:
    case dynamic_sql_error::eRESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION:
    case dynamic_sql_error::eUSING_CLAUSE_DOES_NOT_MATCH_DYNAMIC_PARAMETER_SPEC:
    case dynamic_sql_error::eUSING_CLAUSE_DOES_NOT_MATCH_TARGET_SPEC:
    case dynamic_sql_error::eUSING_CLAUSE_REQUIRED_FOR_DYNAMIC_PARAMETERS:
    case dynamic_sql_error::eUSING_CLAUSE_REQUIRED_FOR_RESULT_FIELDS:
    {
      pkcClass = "dynamic SQL error";
      break;
    }
    case feature_not_supported::eNO_SUBCLASS:
    case feature_not_supported::eMULTIPLE_ENVIRONMENT_TRANSACTIONS:
    {
      pkcClass = "feature not supported";
      break;
    }
    case integrity_constraint_violation::eNO_SUBCLASS:
    {
      pkcClass = "integrity constraint violation";
      break;
    }
    case invalid_authorization_specification::eNO_SUBCLASS:
    {
      pkcClass = "invalid authorization specification";
      break;
    }
    case invalid_catalog_name::eNO_SUBCLASS:
    {
      pkcClass = "invalid catalog name";
      break;
    }
    case invalid_character_set_name::eNO_SUBCLASS:
    {
      pkcClass = "invalid character set name";
      break;
    }
    case invalid_condition_number::eNO_SUBCLASS:
    {
      pkcClass = "invalid condition number";
      break;
    }
    case invalid_connection_name::eNO_SUBCLASS:
    {
      pkcClass = "invalid connection name";
      break;
    }
    case invalid_cursor_name::eNO_SUBCLASS:
    {
      pkcClass = "invalid cursor name";
      break;
    }
    case invalid_cursor_state::eNO_SUBCLASS:
    {
      pkcClass = "invalid cursor state";
      break;
    }
    case invalid_schema_name::eNO_SUBCLASS:
    {
      pkcClass = "invalid schema name";
      break;
    }
    case invalid_sql_descriptor_name::eNO_SUBCLASS:
    {
      pkcClass = "invalid SQL descriptor name";
      break;
    }
    case invalid_sql_statement_name::eNO_SUBCLASS:
    {
      pkcClass = "invalid SQL statement name";
      break;
    }
    case invalid_transaction_state::eNO_SUBCLASS:
    {
      pkcClass = "invalid transaction state";
      break;
    }
    case invalid_transaction_termination::eNO_SUBCLASS:
    {
      pkcClass = "invalid transaction termination";
      break;
    }
    case no_data::eNO_SUBCLASS:
    {
      pkcClass = "no data";
      break;
    }
    case remote_database_access::eNO_SUBCLASS:
    {
      pkcClass = "remote database access";
      break;
    }
    case successful_completion::eNO_SUBCLASS:
    {
      pkcClass = "successful completion";
      break;
    }
    case syntax_error_or_access_rule_violation::eNO_SUBCLASS:
    {
      pkcClass = "syntax error or access rule violation";
      break;
    }
    case syntax_error_or_access_rule_violation_in_direct_statement::eNO_SUBCLASS:
    {
      pkcClass = "syntax error or access rule violation in direct statement";
      break;
    }
    case syntax_error_or_access_rule_violation_in_dynamic_statement::eNO_SUBCLASS:
    {
      pkcClass = "syntax error or access rule violation in dynamic statement";
      break;
    }
    case transaction_rollback::eNO_SUBCLASS:
    case transaction_rollback::eINTEGRITY_CONSTRAINT_VIOLATION:
    case transaction_rollback::eSERIALIZATION_FAILURE:
    case transaction_rollback::eSTATEMENT_COMPLETION_UNKNOWN:
    {
      pkcClass = "transaction rollback";
      break;
    }
    case triggered_data_change_violation::eNO_SUBCLASS:
    {
      pkcClass = "triggered data change violation";
      break;
    }
    case warning::eNO_SUBCLASS:
    case warning::eCURSOR_OPERATION_CONFLICT:
    case warning::eDISCONNECT_ERROR:
    case warning::eIMPLICIT_ZERO_BIT_PADDING:
    case warning::eINSUFFICIENT_ITEM_DESCRIPTOR_AREAS:
    case warning::eNULL_VALUE_ELIMINATED_IN_SET_FUNCTION:
    case warning::ePRIVILEGE_NOT_GRANTED:
    case warning::ePRIVILEGE_NOT_REVOKED:
    case warning::eQUERY_EXPRESSION_TOO_LONG_FOR_INFORMATION_SCHEMA:
    case warning::eSEARCH_CONDITION_TOO_LONG_FOR_INFORMATION_SCHEMA:
    case warning::eSTRING_DATA_RIGHT_TRUNCATION:
    {
      pkcClass = "warning";
      break;
    }
    case with_check_option_violation::eNO_SUBCLASS:
    {
      pkcClass = "with check option violation";
      break;
    }
    default:
    {
      pkcClass = "unknown code";
    }
  }
  return pkcClass;
  
}  // TSqlstateDescriptor::getClassValue()


mpcl::text::TString uesqlc::TSqlstateDescriptor::
getDescription (const char* pkcSQLSTATE) const
{

  mpcl::text::TString   yDescription (getClassValue (pkcSQLSTATE));
  
  yDescription.append (": ");
  yDescription.append (getSubclassValue (pkcSQLSTATE));
  if ( !uesqlc::SQLMESSAGE.empty() )
  {
    yDescription.append (" (");
    yDescription.append (uesqlc::SQLMESSAGE);
    yDescription.append (")");
  }
  return yDescription;

}  // TSqlstateDescriptor::getDescription()


const char* uesqlc::TSqlstateDescriptor::
getSubclassValue (const char* pkcSQLSTATE) const
{
  
  const char*   pkcSubclass = NULL;
  
  switch (getUniqueValue (pkcSQLSTATE))
  {
    case ambiguous_cursor_name::eNO_SUBCLASS:
    case cardinality_violation::eNO_SUBCLASS:
    case connection_exception::eNO_SUBCLASS:
    case data_exception::eNO_SUBCLASS:
    case dependent_privilege_descriptors_still_exist::eNO_SUBCLASS:
    case dynamic_sql_error::eNO_SUBCLASS:
    case feature_not_supported::eNO_SUBCLASS:
    case integrity_constraint_violation::eNO_SUBCLASS:
    case invalid_authorization_specification::eNO_SUBCLASS:
    case invalid_catalog_name::eNO_SUBCLASS:
    case invalid_character_set_name::eNO_SUBCLASS:
    case invalid_condition_number::eNO_SUBCLASS:
    case invalid_connection_name::eNO_SUBCLASS:
    case invalid_cursor_name::eNO_SUBCLASS:
    case invalid_cursor_state::eNO_SUBCLASS:
    case invalid_schema_name::eNO_SUBCLASS:
    case invalid_sql_descriptor_name::eNO_SUBCLASS:
    case invalid_sql_statement_name::eNO_SUBCLASS:
    case invalid_transaction_state::eNO_SUBCLASS:
    case invalid_transaction_termination::eNO_SUBCLASS:
    case no_data::eNO_SUBCLASS:
    case remote_database_access::eNO_SUBCLASS:
    case successful_completion::eNO_SUBCLASS:
    case syntax_error_or_access_rule_violation::eNO_SUBCLASS:
    case syntax_error_or_access_rule_violation_in_direct_statement::eNO_SUBCLASS:
    case syntax_error_or_access_rule_violation_in_dynamic_statement::eNO_SUBCLASS:
    case transaction_rollback::eNO_SUBCLASS:
    case triggered_data_change_violation::eNO_SUBCLASS:
    case warning::eNO_SUBCLASS:
    case with_check_option_violation::eNO_SUBCLASS:
    {
      pkcSubclass = "(no subclass)";
      break;
    }
    case connection_exception::eCONNECTION_DOES_NOT_EXIST:
    {
      pkcSubclass = "connection does not exist";
      break;
    }
    case connection_exception::eCONNECTION_FAILURE:
    {
      pkcSubclass = "connection failure";
      break;
    }
    case connection_exception::eCONNECTION_NAME_IN_USE:
    {
      pkcSubclass = "connection name in use";
      break;
    }
    case connection_exception::eSQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION:
    {
      pkcSubclass = "SQL-client unable to establish SQL-connection";
      break;
    }
    case connection_exception::eSQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION:
    {
      pkcSubclass = "SQL-server rejected establishment of SQL-connection";
      break;
    }
    case connection_exception::eTRANSACTION_RESOLUTION_UNKNOWN:
    {
      pkcSubclass = "transaction resolution unknown";
      break;
    }
    case data_exception::eCHARACTER_NOT_IN_REPERTOIRE:
    {
      pkcSubclass = "character not in repertoire";
      break;
    }
    case data_exception::eDATETIME_FIELD_OVERFLOW:
    {
      pkcSubclass = "datetime field overflow";
      break;
    }
    case data_exception::eDIVISION_BY_ZERO:
    {
      pkcSubclass = "division by zero";
      break;
    }
    case data_exception::eERROR_IN_ASSIGNMENT:
    {
      pkcSubclass = "error in assignment";
      break;
    }
    case data_exception::eINDICATOR_OVERFLOW:
    {
      pkcSubclass = "indicator overflow";
      break;
    }
    case data_exception::eINTERVAL_FIELD_OVERFLOW:
    {
      pkcSubclass = "interval field overflow";
      break;
    }
    case data_exception::eINVALID_CHARACTER_VALUE_FOR_CAST:
    {
      pkcSubclass = "invalid character value for cast";
      break;
    }
    case data_exception::eINVALID_DATETIME_FORMAT:
    {
      pkcSubclass = "invalid datetime format";
      break;
    }
    case data_exception::eINVALID_ESCAPE_CHARACTER:
    {
      pkcSubclass = "invalid escape character";
      break;
    }
    case data_exception::eINVALID_ESCAPE_SEQUENCE:
    {
      pkcSubclass = "invalid escape sequence";
      break;
    }
    case data_exception::eINVALID_PARAMETER_VALUE:
    {
      pkcSubclass = "invalid parameter value";
      break;
    }
    case data_exception::eINVALID_TIME_ZONE_DISPLACEMENT_VALUE:
    {
      pkcSubclass = "invalid time zone displacement value";
      break;
    }
    case data_exception::eNULL_VALUE_NO_INDICATOR_PARAMETER:
    {
      pkcSubclass = "null value, no indicator parameter";
      break;
    }
    case data_exception::eNUMERIC_VALUE_OUT_OF_RANGE:
    {
      pkcSubclass = "numeric value out of range";
      break;
    }
    case data_exception::eSTRING_DATA_LENGTH_MISMATCH:
    {
      pkcSubclass = "string data, length mismatch";
      break;
    }
    case data_exception::eSTRING_DATA_RIGHT_TRUNCATION:
    {
      pkcSubclass = "string data, right truncation";
      break;
    }
    case data_exception::eSUBSTRING_ERROR:
    {
      pkcSubclass = "substring error";
      break;
    }
    case data_exception::eTRIM_ERROR:
    {
      pkcSubclass = "trim error";
      break;
    }
    case data_exception::eUNTERMINATED_C_STRING:
    {
      pkcSubclass = "unterminated C string";
      break;
    }
    case dynamic_sql_error::eCURSOR_SPECIFICATION_CANNOT_BE_EXECUTED:
    {
      pkcSubclass = "cursor specification cannot be executed";
      break;
    }
    case dynamic_sql_error::eINVALID_DESCRIPTOR_COUNT:
    {
      pkcSubclass = "invalid descriptor count";
      break;
    }
    case dynamic_sql_error::eINVALID_DESCRIPTOR_INDEX:
    {
      pkcSubclass = "invalid descriptor index";
      break;
    }
    case dynamic_sql_error::ePREPARED_STATEMENT_NOT_A_CURSOR_SPECIFICATION:
    {
      pkcSubclass = "prepared statement not a cursor specification";
      break;
    }
    case dynamic_sql_error::eRESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION:
    {
      pkcSubclass = "restricted data type attribute violation";
      break;
    }
    case dynamic_sql_error::eUSING_CLAUSE_DOES_NOT_MATCH_DYNAMIC_PARAMETER_SPEC:
    {
      pkcSubclass = "using clause does not match dynamic parameter specifications";
      break;
    }
    case dynamic_sql_error::eUSING_CLAUSE_DOES_NOT_MATCH_TARGET_SPEC:
    {
      pkcSubclass = "using clause does not match target specifications";
      break;
    }
    case dynamic_sql_error::eUSING_CLAUSE_REQUIRED_FOR_DYNAMIC_PARAMETERS:
    {
      pkcSubclass = "using clause required for dynamic parameters";
      break;
    }
    case dynamic_sql_error::eUSING_CLAUSE_REQUIRED_FOR_RESULT_FIELDS:
    {
      pkcSubclass = "using clause required for result fields";
      break;
    }
    case feature_not_supported::eMULTIPLE_ENVIRONMENT_TRANSACTIONS:
    {
      pkcSubclass = "multiple environment transactions";
      break;
    }
    case transaction_rollback::eINTEGRITY_CONSTRAINT_VIOLATION:
    {
      pkcSubclass = "integrity constraint violation";
      break;
    }
    case transaction_rollback::eSERIALIZATION_FAILURE:
    {
      pkcSubclass = "serialization failure";
      break;
    }
    case transaction_rollback::eSTATEMENT_COMPLETION_UNKNOWN:
    {
      pkcSubclass = "statement completion unknown";
      break;
    }
    case warning::eCURSOR_OPERATION_CONFLICT:
    {
      pkcSubclass = "cursor operation conflict";
      break;
    }
    case warning::eDISCONNECT_ERROR:
    {
      pkcSubclass = "disconnect error";
      break;
    }
    case warning::eIMPLICIT_ZERO_BIT_PADDING:
    {
      pkcSubclass = "implicit zero-bit padding";
      break;
    }
    case warning::eINSUFFICIENT_ITEM_DESCRIPTOR_AREAS:
    {
      pkcSubclass = "insufficient item descriptor areas";
      break;
    }
    case warning::eNULL_VALUE_ELIMINATED_IN_SET_FUNCTION:
    {
      pkcSubclass = "null value eliminated in set function";
      break;
    }
    case warning::ePRIVILEGE_NOT_GRANTED:
    {
      pkcSubclass = "privilege not granted";
      break;
    }
    case warning::ePRIVILEGE_NOT_REVOKED:
    {
      pkcSubclass = "privilege not revoked";
      break;
    }
    case warning::eQUERY_EXPRESSION_TOO_LONG_FOR_INFORMATION_SCHEMA:
    {
      pkcSubclass = "query expression too long for information schema";
      break;
    }
    case warning::eSEARCH_CONDITION_TOO_LONG_FOR_INFORMATION_SCHEMA:
    {
      pkcSubclass = "search condition too long for information schema";
      break;
    }
    case warning::eSTRING_DATA_RIGHT_TRUNCATION:
    {
      pkcSubclass = "string data, right truncation";
      break;
    }
    default:
    {
      pkcSubclass = "unknown code";
    }
  }
  return pkcSubclass;
  
}  // TSqlstateDescriptor::getSubclassValue()


uesqlc::TNotFoundException::
TNotFoundException ( const char* pkcFILE_NAME  ,
                     const int   kiLINE_NUMBER )      :
  mpcl::TException        ( _pkcNotFoundDescription ,
                            ""                      ,
                            pkcFILE_NAME            ,
                            kiLINE_NUMBER           ) ,
  mpcl::TWarningException ()                          ,
  TSqlstateDescriptor     ()
{

  yRationale = getDescription (uesqlc::SQLSTATE.c_str());

}  // TNotFoundException()


uesqlc::TSqlerrorException::
TSqlerrorException ( const char* pkcFILE_NAME  ,
                     const int   kiLINE_NUMBER )    :
  mpcl::TException      ( _pkcSqlerrorDescription ,
                          ""                      ,
                          pkcFILE_NAME            ,
                          kiLINE_NUMBER           ) ,
  mpcl::TErrorException ()                          ,
  TSqlstateDescriptor   ()                                                   
{

  yRationale = getDescription (uesqlc::SQLSTATE.c_str());

}  // TSqlerrorException()


//
//  S E L E C T O R S
//

const std::string uesqlc::TSqlerrorException::
what (void) const
{

  std::string   yDescription;
  
  if ( !yFileName.empty() )
  {
    yDescription = mpcl::text::Format ( "%s:%d:"          ,
                                        yFileName.c_str() ,
                                        iLineNumber       );
  }
  yDescription.append (ySynopsis);
  yDescription.append ("; ");
  if ( yRationale.empty() )
  {
    yDescription.append (getDescription (SQLSTATE.c_str()));
  }
  else
  {
    yDescription.append (yRationale);
  }
  return yDescription;

}  // TSqlerrorException::what()


const std::string uesqlc::TNotFoundException::
what (void) const
{

  std::string   yDescription;
  
  if ( !yFileName.empty() )
  {
    yDescription = mpcl::text::Format ( "%s:%d:"          ,
                                        yFileName.c_str() ,
                                        iLineNumber       );
  }
  yDescription.append (ySynopsis);
  yDescription.append ("; ");
  if ( yRationale.empty() )
  {
    yDescription.append (getDescription (SQLSTATE.c_str()));
  }
  else
  {
    yDescription.append (yRationale);
  }
  return yDescription;

}  // TNotFoundException::what()


//
//  E X P O R T E D   F U N C T I O N S
//

uesqlc::TString uesqlc::
ComposeSchemaLocation ( const std::string& rkyHOST_NAME   ,
                        const std::string& rkySCHEMA_NAME )
{

  return mpcl::text::Format ( "%s/%s"                ,
                              rkyHOST_NAME.c_str()   ,
                              rkySCHEMA_NAME.c_str() );

}  // ComposeSchemaLocation()


uesqlc::TString uesqlc::
ComposeUserLogin ( const std::string& rkyUSER_NAME     ,
                   const std::string& rkyUSER_PASSWORD )
{

  return mpcl::text::Format ( "%s/%s"                  ,
                              rkyUSER_NAME.c_str()     ,
                              rkyUSER_PASSWORD.c_str() );

}  // ComposeUserLogin()


uesqlc::TString uesqlc::ToString (bool gVALUE)
{

  return mpcl::text::Format ("%d", (int) gVALUE);

}  // ToString()


uesqlc::TString uesqlc::ToString (long double ldNUMBER)
{

  return mpcl::text::Format ("%Lf", ldNUMBER);

}  // ToString()


uesqlc::TString uesqlc::ToString (long int liNUMBER)
{

  return mpcl::text::Format ("%ld", liNUMBER);

}  // ToString()


uesqlc::TString uesqlc::ToString (long unsigned int luiNUMBER)
{

  return mpcl::text::Format ("%lu", luiNUMBER);

}  // ToString()

---