| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| #ifndef NAERROR_H |
| #define NAERROR_H |
| /* -*-C++-*- |
| ************************************************************************** |
| * |
| * File: NAError.h |
| * Description: New Architecture Error Class |
| * Created: 01/23/95 |
| * Language: C++ |
| * |
| * |
| ************************************************************************** |
| */ |
| |
| #include "ErrorCondition.h" |
| #include "NAExit.h" |
| |
| // ----------------------------------------------------------------------- |
| // Global defines and functions |
| // ----------------------------------------------------------------------- |
| |
| void NAError_stub_for_breakpoints(); // in BaseTypes.cpp not NAError! |
| void NAArkcmpExceptionEpilogue(); |
| |
| #define ARKCMP_EXCEPTION_EPILOGUE(str) NAArkcmpExceptionEpilogue() |
| #define EXECUTOR_EXCEPTION_EPILOGUE(str) NAError_stub_for_breakpoints() |
| #define SQLCI_EXCEPTION_EPILOGUE(str) NAError_stub_for_breakpoints() |
| #define UDRSERV_EXCEPTION_EPILOGUE(str) NAError_stub_for_breakpoints() |
| #define MXEXPORTDDL_EXCEPTION_EPILOGUE(str) NAError_stub_for_breakpoints() |
| #define MXIMPORTDDL_EXCEPTION_EPILOGUE(str) NAError_stub_for_breakpoints() |
| #define MXPREPAREMAP_EXCEPTION_EPILOGUE(str) NAError_stub_for_breakpoints() |
| |
| // ----------------------------------------------------------------------- |
| // Classes declared in this file. |
| // ----------------------------------------------------------------------- |
| class NAError; |
| class NAErrorParam; |
| class NAErrorParamArray; |
| class NAErrorStack; |
| |
| // *********************************************************************** |
| // The error code datatype. |
| // *********************************************************************** |
| typedef Lng32 NAErrorCode; |
| |
| // *********************************************************************** |
| // A wrapper for an error parameter. |
| // *********************************************************************** |
| class NAErrorParam |
| { |
| public: |
| |
| enum NAErrorParamType { |
| NAERROR_PARAM_TYPE_INTEGER, |
| NAERROR_PARAM_TYPE_CHAR_STRING |
| }; |
| |
| |
| // --------------------------------------------------------------------- |
| // Constructor |
| // --------------------------------------------------------------------- |
| NAErrorParam(Lng32 l) : errParamType_(NAERROR_PARAM_TYPE_INTEGER), |
| longValue_(l) |
| { } |
| |
| NAErrorParam(char * s) : errParamType_(NAERROR_PARAM_TYPE_CHAR_STRING), |
| stringValue_(s) |
| { } |
| |
| // --------------------------------------------------------------------- |
| // Destructor |
| // --------------------------------------------------------------------- |
| virtual ~NAErrorParam() {}; |
| |
| // --------------------------------------------------------------------- |
| // Ideally, there should be just one method for returning a string for |
| // the value contained in an ErrParam. However, the NAError class can |
| // also be constructed by the executor, which can be running in an SRL |
| // (aka DLL) on Guardian. This imposes a restriction on the use of |
| // conversion functions such as sprintf. This is because they require |
| // the allocation of global data in the code space of the caller; an |
| // SRL cannot contain global data because of the privilege model that |
| // is implemented on Guardian. Thus, we cannot use formatting functions |
| // such as sprintf and support a single method here. |
| // |
| // The programming model for a caller who wants to interpret the |
| // contents of an NAErrorParam is illustrated by the pseudo code below: |
| // char errorParamValue[BUFFER_SIZE]; |
| // char * S = errorParamValue; |
| // |
| // switch (NAErrorParamVariable.getNAErrorParamType()) |
| // { |
| // case NAERROR_PARAM_TYPE_INTEGER: |
| // sprintf(S,"%d",NAErrorParamVariable.getIntegerNAErrorParam()); |
| // break; |
| // case NAERROR_PARAM_TYPE_CHAR_STRING: |
| // sprintf(S,"%s",NAErrorParamVariable.getStringNAErrorParam()); |
| // break; |
| // default: |
| // // error case |
| // break; |
| // } |
| // |
| // --------------------------------------------------------------------- |
| NAErrorParamType getNAErrorParamType() const |
| { return errParamType_; } |
| |
| Lng32 getIntegerNAErrorParam() const |
| { return longValue_; } |
| |
| char * getStringNAErrorParam() const |
| { return stringValue_; } |
| |
| protected: |
| NAErrorParamType errParamType_; |
| Lng32 longValue_; |
| char * stringValue_; |
| |
| }; // class NAErrorParam |
| |
| |
| // *********************************************************************** |
| // NAErrorParamArray |
| // A wrapper for supplying a single package of N NAErrorParam objects. |
| // This wrapper is designed to be a readonly object. No mutator functions |
| // are supported on it. |
| // *********************************************************************** |
| class NAErrorParamArray |
| { |
| public: |
| |
| // --------------------------------------------------------------------- |
| // The first argument, numParams, ends up deciding how many of the |
| // following parameters are relevant. |
| // --------------------------------------------------------------------- |
| NAErrorParamArray(Lng32 numParams = 0, |
| NAErrorParam * errParam0 = 0, |
| NAErrorParam * errParam1 = 0, |
| NAErrorParam * errParam2 = 0, |
| NAErrorParam * errParam3 = 0, |
| NAErrorParam * errParam4 = 0, |
| NAErrorParam * errParam5 = 0, |
| NAErrorParam * errParam6 = 0, |
| NAErrorParam * errParam7 = 0, |
| NAErrorParam * errParam8 = 0, |
| NAErrorParam * errParam9 = 0 |
| ); |
| |
| virtual ~NAErrorParamArray(); |
| |
| // --------------------------------------------------------------------- |
| // How many NAErrorParams are contained in the NAErrorParamArray? |
| // --------------------------------------------------------------------- |
| Lng32 entries() const { return numParams_; } |
| |
| // --------------------------------------------------------------------- |
| // Accessor function. |
| // --------------------------------------------------------------------- |
| NAErrorParam * getNAErrorParam(Lng32 paramNo) const |
| { |
| if ( (paramNo >= 0) && (paramNo < numParams_ ) ) |
| return array_[paramNo].errParam_; |
| else |
| return 0; |
| } |
| |
| // --------------------------------------------------------------------- |
| // NO MUTATOR FUNCTIONS. |
| // --------------------------------------------------------------------- |
| |
| private: |
| // --------------------------------------------------------------------- |
| // A private declaration |
| // --------------------------------------------------------------------- |
| struct NAErrorParamArrayElement |
| { |
| NAErrorParam * errParam_; |
| }; // struct NAErrorParamArrayElement |
| |
| private: |
| Lng32 numParams_; |
| NAErrorParamArrayElement * array_; |
| }; // class NAErrorParamArray |
| |
| // *********************************************************************** |
| // An error issued by an SQL subsystem. |
| // *********************************************************************** |
| class NAError |
| { |
| public: |
| |
| // --------------------------------------------------------------------- |
| // A classification for the type of error that is issued. |
| // --------------------------------------------------------------------- |
| enum NAErrorType { |
| NAERROR_NONE, |
| NAERROR_WARNING, |
| NAERROR_SYNTAX, |
| NAERROR_SQL_SEMANTICS, |
| NAERROR_EXPR_SEMANTICS, |
| NAERROR_INTERNAL, |
| NAERROR_EXCEPTION |
| }; |
| |
| // --------------------------------------------------------------------- |
| // An id for the subsystem that issues the error. |
| // --------------------------------------------------------------------- |
| enum NASubsys { |
| NA_CATMAN = 1000, |
| NA_COMPMAIN = 2000, |
| NA_PARSER = 3000, |
| NA_BINDER = 4000, |
| NA_NORMALIZER = 5000, |
| NA_OPTIMIZER = 6000, |
| NA_CODEGEN = 7000, |
| NA_EXPRGEN = 8000, |
| NA_EXECUTOR = 9000, |
| NA_EXPREVAL = 10000, |
| NA_FILESYSTEM = 11000, |
| NA_OS = 12000, |
| NA_SQLC = 13000, |
| NA_UNKNOWN = 14000 |
| }; |
| |
| // --------------------------------------------------------------------- |
| // Constructor |
| // --------------------------------------------------------------------- |
| NAError(const NAErrorCode errCode = 0, |
| const NAErrorType errType = NAERROR_NONE, |
| const NASubsys subsys = NA_UNKNOWN, |
| NAErrorParamArray * errParams = 0, |
| char * procName = 0, |
| const ULng32 lineNumber = 0, |
| const ULng32 offset = 0 |
| ); |
| |
| // --------------------------------------------------------------------- |
| // Destructor |
| // --------------------------------------------------------------------- |
| ~NAError(); |
| |
| // --------------------------------------------------------------------- |
| // Accessor functions. |
| // --------------------------------------------------------------------- |
| NAErrorCode getErrCode() const { return errCode_; } |
| NAErrorType getErrType() const { return errType_; } |
| NASubsys getSubsys() const { return subsysId_; } |
| |
| // --------------------------------------------------------------------- |
| // Error Parameters. |
| // --------------------------------------------------------------------- |
| Lng32 getErrParamCount() const |
| { |
| if (errParams_) |
| return errParams_->entries(); |
| else |
| return 0; |
| } |
| |
| NAErrorParam * getNAErrorParam(Lng32 paramNo) const |
| { |
| if (errParams_) |
| return errParams_->getNAErrorParam(paramNo); |
| else |
| return 0; |
| } |
| |
| // --------------------------------------------------------------------- |
| // Procedure name and line numbers. |
| // --------------------------------------------------------------------- |
| char * getProcName() const { return procName_; } |
| |
| Lng32 getLineNumber() const { return lineNumber_; } |
| |
| // --------------------------------------------------------------------- |
| // Method for traversing error list |
| // --------------------------------------------------------------------- |
| void setNext(NAError * errPtr) { next_ = errPtr; } |
| NAError * getNext() const { return next_; } |
| |
| // --------------------------------------------------------------------- |
| // Linearization and De-linearization functions to copy SQLDiagArea |
| // tree to and from contiguous storage. |
| // --------------------------------------------------------------------- |
| Long pack(void * space); |
| Lng32 unpack(Lng32); |
| |
| private: |
| |
| // --------------------------------------------------------------------- |
| // Link to its predecessor. |
| // --------------------------------------------------------------------- |
| NAError * next_; |
| |
| // --------------------------------------------------------------------- |
| // Error code and type. |
| // --------------------------------------------------------------------- |
| const NAErrorCode errCode_; // error code |
| const NAErrorType errType_; // error type |
| const NASubsys subsysId_; // id of subsystem that issues the error |
| |
| // --------------------------------------------------------------------- |
| // Error Parameters. |
| // --------------------------------------------------------------------- |
| NAErrorParamArray * errParams_; |
| |
| // --------------------------------------------------------------------- |
| // Procedure name and line numbers. |
| // --------------------------------------------------------------------- |
| const Lng32 lineNumber_; |
| char * procName_; |
| const Lng32 offset_; |
| |
| }; // class NAError |
| |
| // *********************************************************************** |
| // The error stack |
| // *********************************************************************** |
| class NAErrorStack |
| { |
| public: |
| |
| // --------------------------------------------------------------------- |
| // Constructor |
| // --------------------------------------------------------------------- |
| NAErrorStack(Lng32 maxSize) |
| : maxEntries_(maxSize), numEntries_(0), errEntry_(0), |
| nextEntry_(0), iterEntries_(0) |
| { |
| } |
| |
| // --------------------------------------------------------------------- |
| // Destructor |
| // --------------------------------------------------------------------- |
| ~NAErrorStack(); |
| |
| // --------------------------------------------------------------------- |
| // Method for initializing an error stack - once per statement |
| // --------------------------------------------------------------------- |
| void clear(); |
| |
| // --------------------------------------------------------------------- |
| // Method for returning the error code for the latest error |
| // --------------------------------------------------------------------- |
| NAErrorCode getErrCode() |
| { |
| if (errEntry_ != (NAError *)0) |
| return errEntry_->getErrCode(); |
| else |
| return (NAErrorCode)0; |
| } |
| |
| // --------------------------------------------------------------------- |
| // Method for adding a new Error |
| // --------------------------------------------------------------------- |
| void addErrEntry(NAError * errPtr); |
| |
| // --------------------------------------------------------------------- |
| // Iterator over all errors |
| // --------------------------------------------------------------------- |
| NAError * getFirst(); // initialize the iterator |
| NAError * getNext(); // behaviour undefined unless getFirst() was called |
| |
| private: |
| |
| // --------------------------------------------------------------------- |
| // The error stack |
| // --------------------------------------------------------------------- |
| Lng32 maxEntries_; // if prescribed by a SET TRANSACTION |
| Lng32 numEntries_; // number of entries allocated so far |
| NAError * errEntry_; // an array of NAError |
| NAError * nextEntry_; // maintained after an iterator is initialized |
| Lng32 iterEntries_; // for terminating iterations over unused entries |
| |
| }; // class NAErrorStack |
| |
| |
| #endif /* NAERROR_H */ |
| |
| |
| |
| |
| |
| |
| |
| |
