dbdict.hpp

mysql-5.0.22.tar.gz源码包

    void setError(const CreateTrigRef* ref) {
      m_lastError = AlterIndxRef::NoError;
      if (ref != 0) {
        m_lastError = (AlterIndxRef::ErrorCode)ref->getErrorCode();
        if (! hasError()) {
          m_errorCode = m_lastError;
          m_errorLine = ref->getErrorLine();
          m_errorNode = ref->getErrorNode();
        }
      }
    }
    void setError(const DropTrigRef* ref) {
      m_lastError = AlterIndxRef::NoError;
      if (ref != 0) {
        m_lastError = (AlterIndxRef::ErrorCode)ref->getErrorCode();
        if (! hasError()) {
          m_errorCode = m_lastError;
          m_errorLine = ref->getErrorLine();
          m_errorNode = ref->getErrorNode();
        }
      }
    }
  };
  typedef Ptr<OpAlterIndex> OpAlterIndexPtr;

  /**
   * Operation record for build index.
   */
  struct OpBuildIndex : OpRecordCommon {
    // original request plus buffer for attribute lists
    BuildIndxReq m_request;
    AttributeList m_attrList;
    AttributeList m_tableKeyList;
    // coordinator DICT
    Uint32 m_coordinatorRef;
    bool m_isMaster;
    // state info
    BuildIndxReq::RequestType m_requestType;
    Uint32 m_requestFlag;
    Uint32 m_constrTriggerId;
    // error info
    BuildIndxRef::ErrorCode m_lastError;
    BuildIndxRef::ErrorCode m_errorCode;
    Uint32 m_errorLine;
    Uint32 m_errorNode;
    // counters
    SignalCounter m_signalCounter;
    // ctor
    OpBuildIndex() {
      memset(&m_request, 0, sizeof(m_request));
      m_coordinatorRef = 0;
      m_requestType = BuildIndxReq::RT_UNDEFINED;
      m_requestFlag = 0;
      m_lastError = BuildIndxRef::NoError;
      m_errorCode = BuildIndxRef::NoError;
      m_errorLine = 0;
      m_errorNode = 0;
    }
    void save(const BuildIndxReq* req) {
      m_request = *req;
      m_requestType = req->getRequestType();
      m_requestFlag = req->getRequestFlag();
    }
    bool hasLastError() {
      return m_lastError != BuildIndxRef::NoError;
    }
    bool hasError() {
      return m_errorCode != BuildIndxRef::NoError;
    }
    void setError(const BuildIndxRef* ref) {
      m_lastError = BuildIndxRef::NoError;
      if (ref != 0) {
        m_lastError = ref->getErrorCode();
        if (! hasError()) {
          m_errorCode = m_lastError;
          m_errorLine = 0;
          m_errorNode = 0;
        }
      }
    }
    void setError(const AlterIndxRef* ref) {
      m_lastError = BuildIndxRef::NoError;
      if (ref != 0) {
        m_lastError = (BuildIndxRef::ErrorCode)ref->getErrorCode();
        if (! hasError()) {
          m_errorCode = m_lastError;
          m_errorLine = ref->getErrorLine();
          m_errorNode = ref->getErrorNode();
        }
      }
    }
    void setError(const CreateTrigRef* ref) {
      m_lastError = BuildIndxRef::NoError;
      if (ref != 0) {
        m_lastError = (BuildIndxRef::ErrorCode)ref->getErrorCode();
        if (! hasError()) {
          m_errorCode = m_lastError;
          m_errorLine = ref->getErrorLine();
          m_errorNode = ref->getErrorNode();
        }
      }
    }
    void setError(const DropTrigRef* ref) {
      m_lastError = BuildIndxRef::NoError;
      if (ref != 0) {
        m_lastError = (BuildIndxRef::ErrorCode)ref->getErrorCode();
        if (! hasError()) {
          m_errorCode = m_lastError;
          m_errorLine = ref->getErrorLine();
          m_errorNode = ref->getErrorNode();
        }
      }
    }
  };
  typedef Ptr<OpBuildIndex> OpBuildIndexPtr;

  /**
   * Operation record for Util Signals.
   */
  struct OpSignalUtil : OpRecordCommon{
    Callback m_callback;
    Uint32 m_userData;
  };
  typedef Ptr<OpSignalUtil> OpSignalUtilPtr;

  /**
   * Operation record for subscribe-start-stop
   */
  struct OpSubEvent : OpRecordCommon {
    Uint32 m_senderRef;
    Uint32 m_senderData;
    Uint32 m_errorCode;
    RequestTracker m_reqTracker;
  };
  typedef Ptr<OpSubEvent> OpSubEventPtr;

  static const Uint32 sysTab_NDBEVENTS_0_szs[];

  /**
   * Operation record for create event.
   */
  struct OpCreateEvent : OpRecordCommon {
    // original request (event id will be added)
    CreateEvntReq m_request;
    //AttributeMask m_attrListBitmask;
    //    AttributeList m_attrList;
    sysTab_NDBEVENTS_0 m_eventRec;
    //    char m_eventName[MAX_TAB_NAME_SIZE];
    //    char m_tableName[MAX_TAB_NAME_SIZE];

    // coordinator DICT
    RequestTracker m_reqTracker;
    // state info
    CreateEvntReq::RequestType m_requestType;
    Uint32 m_requestFlag;
    // error info
    CreateEvntRef::ErrorCode m_errorCode;
    Uint32 m_errorLine;
    Uint32 m_errorNode;
    // ctor
    OpCreateEvent() {
      memset(&m_request, 0, sizeof(m_request));
      m_requestType = CreateEvntReq::RT_UNDEFINED;
      m_requestFlag = 0;
      m_errorCode = CreateEvntRef::NoError;
      m_errorLine = 0;
      m_errorNode = 0;
    }
    void init(const CreateEvntReq* req, Dbdict* dp) {
      m_request = *req;
      m_errorCode = CreateEvntRef::NoError;
      m_errorLine = 0;
      m_errorNode = 0;
      m_requestType = req->getRequestType();
      m_requestFlag = req->getRequestFlag();
    }
    bool hasError() {
      return m_errorCode != CreateEvntRef::NoError;
    }
    void setError(const CreateEvntRef* ref) {
      if (ref != 0 && ! hasError()) {
        m_errorCode = ref->getErrorCode();
        m_errorLine = ref->getErrorLine();
        m_errorNode = ref->getErrorNode();
      }
    }

  };
  typedef Ptr<OpCreateEvent> OpCreateEventPtr;

  /**
   * Operation record for drop event.
   */
  struct OpDropEvent : OpRecordCommon {
    // original request
    DropEvntReq m_request;
    //    char m_eventName[MAX_TAB_NAME_SIZE];
    sysTab_NDBEVENTS_0 m_eventRec;
    RequestTracker m_reqTracker;
    // error info
    DropEvntRef::ErrorCode m_errorCode;
    Uint32 m_errorLine;
    Uint32 m_errorNode;
    // ctor
    OpDropEvent() {
      memset(&m_request, 0, sizeof(m_request));
      m_errorCode = DropEvntRef::NoError;
      m_errorLine = 0;
      m_errorNode = 0;
    }
    void init(const DropEvntReq* req) {
      m_request = *req;
      m_errorCode = DropEvntRef::NoError;
      m_errorLine = 0;
      m_errorNode = 0;
    }
    bool hasError() {
      return m_errorCode != DropEvntRef::NoError;
    }
    void setError(const DropEvntRef* ref) {
      if (ref != 0 && ! hasError()) {
        m_errorCode = ref->getErrorCode();
        m_errorLine = ref->getErrorLine();
        m_errorNode = ref->getErrorNode();
      }
    }
  };
  typedef Ptr<OpDropEvent> OpDropEventPtr;

  /**
   * Operation record for create trigger.
   */
  struct OpCreateTrigger : OpRecordCommon {
    // original request (trigger id will be added)
    CreateTrigReq m_request;
    char m_triggerName[MAX_TAB_NAME_SIZE];
    // coordinator DICT
    Uint32 m_coordinatorRef;
    bool m_isMaster;
    // state info
    CreateTrigReq::RequestType m_requestType;
    Uint32 m_requestFlag;
    // error info
    CreateTrigRef::ErrorCode m_lastError;
    CreateTrigRef::ErrorCode m_errorCode;
    Uint32 m_errorLine;
    Uint32 m_errorNode;
    // counters
    SignalCounter m_signalCounter;
    // ctor
    OpCreateTrigger() {
      memset(&m_request, 0, sizeof(m_request));
      m_coordinatorRef = 0;
      m_requestType = CreateTrigReq::RT_UNDEFINED;
      m_requestFlag = 0;
      m_lastError = CreateTrigRef::NoError;
      m_errorCode = CreateTrigRef::NoError;
      m_errorLine = 0;
      m_errorNode = 0;
    }
    void save(const CreateTrigReq* req) {
      m_request = *req;
      m_requestType = req->getRequestType();
      m_requestFlag = req->getRequestFlag();
    }
    bool hasLastError() {
      return m_lastError != CreateTrigRef::NoError;
    }
    bool hasError() {
      return m_errorCode != CreateTrigRef::NoError;
    }
    void setError(const CreateTrigRef* ref) {
      m_lastError = CreateTrigRef::NoError;
      if (ref != 0) {
        m_lastError = ref->getErrorCode();
        if (! hasError()) {
          m_errorCode = m_lastError;
          m_errorLine = ref->getErrorLine();
          m_errorNode = ref->getErrorNode();
        }
      }
    }
    void setError(const AlterTrigRef* ref) {
      m_lastError = CreateTrigRef::NoError;
      if (ref != 0) {
        m_lastError = (CreateTrigRef::ErrorCode)ref->getErrorCode();
        if (! hasError()) {
          m_errorCode = m_lastError;
          m_errorLine = ref->getErrorLine();
          m_errorNode = ref->getErrorNode();
        }
      }
    }
  };
  typedef Ptr<OpCreateTrigger> OpCreateTriggerPtr;

  /**
   * Operation record for drop trigger.
   */
  struct OpDropTrigger : OpRecordCommon {
    // original request
    DropTrigReq m_request;
    // coordinator DICT
    Uint32 m_coordinatorRef;
    bool m_isMaster;
    // state info
    DropTrigReq::RequestType m_requestType;
    Uint32 m_requestFlag;
    // error info
    DropTrigRef::ErrorCode m_lastError;
    DropTrigRef::ErrorCode m_errorCode;
    Uint32 m_errorLine;
    Uint32 m_errorNode;
    // counters
    SignalCounter m_signalCounter;
    // ctor
    OpDropTrigger() {
      memset(&m_request, 0, sizeof(m_request));
      m_coordinatorRef = 0;
      m_requestType = DropTrigReq::RT_UNDEFINED;
      m_requestFlag = 0;
      m_lastError = DropTrigRef::NoError;
      m_errorCode = DropTrigRef::NoError;
      m_errorLine = 0;
      m_errorNode = 0;
    }
    void save(const DropTrigReq* req) {
      m_request = *req;
      m_requestType = req->getRequestType();
      m_requestFlag = req->getRequestFlag();
    }
    bool hasLastError() {
      return m_lastError != DropTrigRef::NoError;
    }
    bool hasError() {
      return m_errorCode != DropTrigRef::NoError;
    }
    void setError(const DropTrigRef* ref) {
      m_lastError = DropTrigRef::NoError;
      if (ref != 0) {
        m_lastError = ref->getErrorCode();
        if (! hasError()) {
          m_errorCode = m_lastError;
          m_errorLine = ref->getErrorLine();
          m_errorNode = ref->getErrorNode();
        }
      }
    }
    void setError(const AlterTrigRef* ref) {
      m_lastError = DropTrigRef::NoError;
      if (ref != 0) {
        m_lastError = (DropTrigRef::ErrorCode)ref->getErrorCode();
        if (! hasError()) {
          m_errorCode = m_lastError;
          m_errorLine = ref->getErrorLine();
          m_errorNode = ref->getErrorNode();
        }
      }
    }
  };
  typedef Ptr<OpDropTrigger> OpDropTriggerPtr;

  /**
   * Operation record for alter trigger.
   */
  struct OpAlterTrigger : OpRecordCommon {
    // original request
    AlterTrigReq m_request;
    // nodes participating in operation
    NdbNodeBitmask m_nodes;
    // coordinator DICT
    Uint32 m_coordinatorRef;
    bool m_isMaster;
    // state info
    AlterTrigReq::RequestType m_requestType;
    Uint32 m_requestFlag;
    // error info
    AlterTrigRef::ErrorCode m_lastError;
    AlterTrigRef::ErrorCode m_errorCode;
    Uint32 m_errorLine;
    Uint32 m_errorNode;
    // counters
    SignalCounter m_signalCounter;
    // ctor
    OpAlterTrigger() {
      memset(&m_request, 0, sizeof(m_request));
      m_coordinatorRef = 0;
      m_requestType = AlterTrigReq::RT_UNDEFINED;
      m_requestFlag = 0;
      m_lastError = AlterTrigRef::NoError;
      m_errorCode = AlterTrigRef::NoError;
      m_errorLine = 0;
      m_errorNode = 0;
    }
    void save(const AlterTrigReq* req) {
      m_request = *req;
      m_requestType = req->getRequestType();
      m_requestFlag = req->getRequestFlag();
    }
    bool hasLastError() {
      return m_lastError != AlterTrigRef::NoError;
    }
    bool hasError() {
      return m_errorCode != AlterTrigRef::NoError;
    }
    void setError(const AlterTrigRef* ref) {
      m_lastError = AlterTrigRef::NoError;
      if (ref != 0) {
        m_lastError = (AlterTrigRef::ErrorCode)ref->getErrorCode();
        if (! hasError()) {