NebulaGraph CPP Client  release-3.8
Response.h
1 /* Copyright (c) 2020 vesoft inc. All rights reserved.
2  *
3  * This source code is licensed under Apache 2.0 License.
4  */
5 
6 #pragma once
7 
8 #include <algorithm>
9 #include <memory>
10 #include <ostream>
11 #include <unordered_map>
12 #include <vector>
13 
14 #include "common/datatypes/DataSet.h"
15 
16 #define ErrorCodeEnums \
17  /* for common code */ \
18  X(SUCCEEDED, 0) \
19  \
20  X(E_DISCONNECTED, -1) /* RPC Failure */ \
21  X(E_FAIL_TO_CONNECT, -2) \
22  X(E_RPC_FAILURE, -3) \
23  X(E_LEADER_CHANGED, -4) \
24  \
25  /* only unify metad and storaged error code */ \
26  X(E_SPACE_NOT_FOUND, -5) \
27  X(E_TAG_NOT_FOUND, -6) \
28  X(E_EDGE_NOT_FOUND, -7) \
29  X(E_INDEX_NOT_FOUND, -8) \
30  X(E_EDGE_PROP_NOT_FOUND, -9) \
31  X(E_TAG_PROP_NOT_FOUND, -10) \
32  X(E_ROLE_NOT_FOUND, -11) \
33  X(E_CONFIG_NOT_FOUND, -12) \
34  X(E_MACHINE_NOT_FOUND, -13) \
35  X(E_ZONE_NOT_FOUND, -14) \
36  X(E_LISTENER_NOT_FOUND, -15) \
37  X(E_PART_NOT_FOUND, -16) \
38  X(E_KEY_NOT_FOUND, -17) \
39  X(E_USER_NOT_FOUND, -18) \
40  X(E_DRAINER_NOT_FOUND, -21) \
41  X(E_DRAINER_CLIENT_NOT_FOUND, -22) \
42  X(E_PART_STOPPED, -23) \
43  \
44  /* backup failed */ \
45  X(E_BACKUP_FAILED, -24) \
46  X(E_BACKUP_EMPTY_TABLE, -25) \
47  X(E_BACKUP_TABLE_FAILED, -26) \
48  X(E_PARTIAL_RESULT, -27) \
49  X(E_REBUILD_INDEX_FAILED, -28) \
50  X(E_INVALID_PASSWORD, -29) \
51  X(E_FAILED_GET_ABS_PATH, -30) \
52  X(E_LISTENER_PROGRESS_FAILED, -31) \
53  X(E_SYNC_LISTENER_NOT_FOUND, -32) \
54  X(E_DRAINER_PROGRESS_FAILED, -33) \
55  X(E_PART_DISABLED, -34) \
56  X(E_PART_ALREADY_STARTED, -35) \
57  X(E_PART_ALREADY_STOPPED, -36) \
58  \
59  /* 1xxx for graphd */ \
60  X(E_BAD_USERNAME_PASSWORD, -1001) /* Authentication error */ \
61  X(E_SESSION_INVALID, -1002) /* Execution errors */ \
62  X(E_SESSION_TIMEOUT, -1003) \
63  X(E_SYNTAX_ERROR, -1004) \
64  X(E_EXECUTION_ERROR, -1005) \
65  X(E_STATEMENT_EMPTY, -1006) /* Nothing is executed When command is empty */ \
66  \
67  X(E_BAD_PERMISSION, -1008) \
68  X(E_SEMANTIC_ERROR, -1009) /* semantic error */ \
69  X(E_TOO_MANY_CONNECTIONS, -1010) \
70  X(E_PARTIAL_SUCCEEDED, -1011) \
71  \
72  /* 2xxx for metad */ \
73  X(E_NO_HOSTS, -2001) /* Operation Failure*/ \
74  X(E_EXISTED, -2002) \
75  X(E_INVALID_HOST, -2003) \
76  X(E_UNSUPPORTED, -2004) \
77  X(E_NOT_DROP, -2005) \
78  X(E_BALANCER_RUNNING, -2006) \
79  X(E_CONFIG_IMMUTABLE, -2007) \
80  X(E_CONFLICT, -2008) \
81  X(E_INVALID_PARM, -2009) \
82  X(E_WRONGCLUSTER, -2010) \
83  X(E_ZONE_NOT_ENOUGH, -2011) \
84  X(E_ZONE_IS_EMPTY, -2012) \
85  X(E_LISTENER_CONFLICT, -2013) \
86  X(E_SCHEMA_NAME_EXISTS, -2014) \
87  X(E_RELATED_INDEX_EXISTS, -2015) \
88  X(E_RELATED_SPACE_EXISTS, -2016) \
89  X(E_RELATED_FULLTEXT_INDEX_EXISTS, -2017) \
90  X(E_HISTORY_CONFLICT, -2018) \
91  \
92  X(E_STORE_FAILURE, -2021) \
93  X(E_STORE_SEGMENT_ILLEGAL, -2022) \
94  X(E_BAD_BALANCE_PLAN, -2023) \
95  X(E_BALANCED, -2024) \
96  X(E_NO_RUNNING_BALANCE_PLAN, -2025) \
97  X(E_NO_VALID_HOST, -2026) \
98  X(E_CORRUPTED_BALANCE_PLAN, -2027) \
99  X(E_NO_INVALID_BALANCE_PLAN, -2028) \
100  X(E_NO_VALID_DRAINER, -2029) \
101  \
102  /* Authentication Failure */ \
103  X(E_IMPROPER_ROLE, -2030) \
104  X(E_INVALID_PARTITION_NUM, -2031) \
105  X(E_INVALID_REPLICA_FACTOR, -2032) \
106  X(E_INVALID_CHARSET, -2033) \
107  X(E_INVALID_COLLATE, -2034) \
108  X(E_CHARSET_COLLATE_NOT_MATCH, -2035) \
109  X(E_PRIVILEGE_ALL_TAG_EDGE_SETTLED, -2036) \
110  X(E_PRIVILEGE_NOT_EXIST, -2037) \
111  X(E_PRIVILEGE_NEED_BASIC_ROLE, -2038) \
112  X(E_PRIVILEGE_ACTION_INVALID, -2039) \
113  \
114  /* Admin Failure */ \
115  X(E_SNAPSHOT_FAILURE, -2040) \
116  X(E_SNAPSHOT_RUNNING_JOBS, -2056) \
117  X(E_SNAPSHOT_NOT_FOUND, -2057) \
118  X(E_BLOCK_WRITE_FAILURE, -2041) \
119  X(E_REBUILD_INDEX_FAILURE, -2042) \
120  X(E_INDEX_WITH_TTL, -2043) \
121  X(E_ADD_JOB_FAILURE, -2044) \
122  X(E_STOP_JOB_FAILURE, -2045) \
123  X(E_SAVE_JOB_FAILURE, -2046) \
124  X(E_BALANCER_FAILURE, -2047) \
125  X(E_JOB_NOT_FINISHED, -2048) \
126  X(E_TASK_REPORT_OUT_DATE, -2049) \
127  X(E_JOB_NOT_IN_SPACE, -2050) \
128  X(E_JOB_NEED_RECOVER, -2051) \
129  X(E_JOB_ALREADY_FINISH, -2052) \
130  X(E_JOB_SUBMITTED, -2053) \
131  X(E_JOB_NOT_STOPPABLE, -2054) \
132  X(E_JOB_HAS_NO_TARGET_STORAGE, -2055) \
133  X(E_INVALID_JOB, -2065) \
134  \
135  /* Backup Failure */ \
136  X(E_BACKUP_RUNNING_JOBS, -2066) \
137  X(E_BACKUP_SPACE_NOT_FOUND, -2067) \
138  \
139  /* RESTORE Failure */ \
140  X(E_RESTORE_FAILURE, -2068) \
141  X(E_SESSION_NOT_FOUND, -2069) \
142  \
143  /* ListClusterInfo Failure */ \
144  X(E_LIST_CLUSTER_FAILURE, -2070) \
145  X(E_LIST_CLUSTER_GET_ABS_PATH_FAILURE, -2071) \
146  X(E_LIST_CLUSTER_NO_AGENT_FAILURE, -2072) \
147  \
148  X(E_QUERY_NOT_FOUND, -2073) \
149  X(E_AGENT_HB_FAILUE, -2074) \
150  X(E_INVALID_VARIABLE, -2080) \
151  X(E_VARIABLE_TYPE_VALUE_MISMATCH, -2081) \
152  X(E_HOST_CAN_NOT_BE_ADDED, -2082) \
153  X(E_ACCESS_ES_FAILURE, -2090) \
154  X(E_GRAPH_MEMORY_EXCEEDED, -2600) \
155  /* 3xxx for storaged */ \
156  X(E_CONSENSUS_ERROR, -3001) \
157  X(E_KEY_HAS_EXISTS, -3002) \
158  X(E_DATA_TYPE_MISMATCH, -3003) \
159  X(E_INVALID_FIELD_VALUE, -3004) \
160  X(E_INVALID_OPERATION, -3005) \
161  X(E_NOT_NULLABLE, -3006) /* Not allowed to be null */ \
162  /* The field neither can be NULL, nor has a default value */ \
163  X(E_FIELD_UNSET, -3007) \
164  /* Value exceeds the range of type */ \
165  X(E_OUT_OF_RANGE, -3008) \
166  /* Atomic operation failed */ \
167  X(E_ATOMIC_OP_FAILED, -3009) \
168  /* data conflict, for index write without toss. */ \
169  X(E_DATA_CONFLICT_ERROR, -3010) \
170  \
171  X(E_WRITE_STALLED, -3011) \
172  \
173  /* meta failures */ \
174  X(E_IMPROPER_DATA_TYPE, -3021) \
175  X(E_INVALID_SPACEVIDLEN, -3022) \
176  \
177  /* Invalid request */ \
178  X(E_INVALID_FILTER, -3031) \
179  X(E_INVALID_UPDATER, -3032) \
180  X(E_INVALID_STORE, -3033) \
181  X(E_INVALID_PEER, -3034) \
182  X(E_RETRY_EXHAUSTED, -3035) \
183  X(E_TRANSFER_LEADER_FAILED, -3036) \
184  X(E_INVALID_STAT_TYPE, -3037) \
185  X(E_INVALID_VID, -3038) \
186  X(E_NO_TRANSFORMED, -3039) \
187  \
188  /* meta client failed */ \
189  X(E_LOAD_META_FAILED, -3040) \
190  \
191  /* checkpoint failed */ \
192  X(E_FAILED_TO_CHECKPOINT, -3041) \
193  X(E_CHECKPOINT_BLOCKED, -3042) \
194  \
195  /* Filter out */ \
196  X(E_FILTER_OUT, -3043) \
197  X(E_INVALID_DATA, -3044) \
198  \
199  X(E_MUTATE_EDGE_CONFLICT, -3045) \
200  X(E_MUTATE_TAG_CONFLICT, -3046) \
201  \
202  /* transaction */ \
203  X(E_OUTDATED_LOCK, -3047) \
204  \
205  /* task manager failed */ \
206  X(E_INVALID_TASK_PARA, -3051) \
207  X(E_USER_CANCEL, -3052) \
208  X(E_TASK_EXECUTION_FAILED, -3053) \
209  \
210  X(E_PLAN_IS_KILLED, -3060) \
211  X(E_CLIENT_SERVER_INCOMPATIBLE, -3061) \
212  \
213  X(E_ID_FAILED, -3062) \
214  \
215  /* 35xx for storaged raft */ \
216  X(E_RAFT_UNKNOWN_PART, -3500) \
217  \
218  /* Raft consensus errors */ \
219  X(E_RAFT_LOG_GAP, -3501) \
220  X(E_RAFT_LOG_STALE, -3502) \
221  X(E_RAFT_TERM_OUT_OF_DATE, -3503) \
222  X(E_RAFT_UNKNOWN_APPEND_LOG, -3504) \
223  \
224  /* Raft state errors */ \
225  X(E_RAFT_WAITING_SNAPSHOT, -3511) \
226  X(E_RAFT_SENDING_SNAPSHOT, -3512) \
227  X(E_RAFT_INVALID_PEER, -3513) \
228  X(E_RAFT_NOT_READY, -3514) \
229  X(E_RAFT_STOPPED, -3515) \
230  X(E_RAFT_BAD_ROLE, -3516) \
231  \
232  /* Local errors */ \
233  X(E_RAFT_WAL_FAIL, -3521) \
234  X(E_RAFT_HOST_STOPPED, -3522) \
235  X(E_RAFT_TOO_MANY_REQUESTS, -3523) \
236  X(E_RAFT_PERSIST_SNAPSHOT_FAILED, -3524) \
237  X(E_RAFT_RPC_EXCEPTION, -3525) \
238  X(E_RAFT_NO_WAL_FOUND, -3526) \
239  X(E_RAFT_HOST_PAUSED, -3527) \
240  X(E_RAFT_WRITE_BLOCKED, -3528) \
241  X(E_RAFT_BUFFER_OVERFLOW, -3529) \
242  X(E_RAFT_ATOMIC_OP_FAILED, -3530) \
243  X(E_LEADER_LEASE_FAILED, -3531) \
244  X(E_RAFT_CAUGHT_UP, -3532) \
245  \
246  /* 4xxx for drainer */ \
247  X(E_LOG_GAP, -4001) \
248  X(E_LOG_STALE, -4002) \
249  X(E_INVALID_DRAINER_STORE, -4003) \
250  X(E_SPACE_MISMATCH, -4004) \
251  X(E_PART_MISMATCH, -4005) \
252  X(E_DATA_CONFLICT, -4006) \
253  X(E_REQ_CONFLICT, -4007) \
254  X(E_DATA_ILLEGAL, -4008) \
255  \
256  /* 5xxx for cache */ \
257  X(E_CACHE_CONFIG_ERROR, -5001) \
258  X(E_NOT_ENOUGH_SPACE, -5002) \
259  X(E_CACHE_MISS, -5003) \
260  X(E_POOL_NOT_FOUND, -5004) \
261  X(E_CACHE_WRITE_FAILURE, -5005) \
262  \
263  /* 7xxx for nebula enterprise */ \
264  /* license related */ \
265  X(E_NODE_NUMBER_EXCEED_LIMIT, -7001) \
266  X(E_PARSING_LICENSE_FAILURE, -7002) \
267  \
268  X(E_STORAGE_MEMORY_EXCEEDED, -3600) \
269  X(E_UNKNOWN, -8000)
270 
271 namespace nebula {
272 
273 #define X(EnumName, EnumNumber) EnumName = EnumNumber,
274 
275 enum class ErrorCode { ErrorCodeEnums };
276 
277 #undef X
278 
279 #define X(EnumName, EnumNumber) \
280  case ErrorCode::EnumName: \
281  return #EnumName;
282 
283 static inline const char* getErrorCode(ErrorCode code) {
284  switch (code) { ErrorCodeEnums }
285  return "Unknown error";
286 }
287 
288 static inline std::ostream &operator<<(std::ostream &os, ErrorCode code) {
289  os << getErrorCode(code);
290  return os;
291 }
292 
293 #undef X
294 
295 template <typename T>
296 bool inline checkPointer(const T *lhs, const T *rhs) {
297  if (lhs == rhs) {
298  return true;
299  } else if (lhs != nullptr && rhs != nullptr) {
300  return *lhs == *rhs;
301  } else {
302  return false;
303  }
304 }
305 
306 // TODO(shylock) use optional for optional in thrift instead of pointer
307 
308 struct AuthResponse {
309  void __clear() {
310  errorCode = ErrorCode::SUCCEEDED;
311  sessionId = nullptr;
312  errorMsg = nullptr;
313  }
314 
315  void clear() {
316  __clear();
317  }
318 
319  bool operator==(const AuthResponse &rhs) const {
320  if (errorCode != rhs.errorCode) {
321  return false;
322  }
323  if (!checkPointer(sessionId.get(), rhs.sessionId.get())) {
324  return false;
325  }
326  if (!checkPointer(errorMsg.get(), rhs.errorMsg.get())) {
327  return false;
328  }
329  if (!checkPointer(timeZoneOffsetSeconds.get(), rhs.timeZoneOffsetSeconds.get())) {
330  return false;
331  }
332  return checkPointer(timeZoneName.get(), timeZoneName.get());
333  }
334 
335  ErrorCode errorCode{ErrorCode::SUCCEEDED};
336  std::unique_ptr<int64_t> sessionId{nullptr};
337  std::unique_ptr<std::string> errorMsg{nullptr};
338  std::unique_ptr<int32_t> timeZoneOffsetSeconds{nullptr};
339  std::unique_ptr<std::string> timeZoneName{nullptr};
340 };
341 
342 struct ProfilingStats {
343  void __clear() {
344  rows = 0;
345  execDurationInUs = 0;
346  totalDurationInUs = 0;
347  otherStats = nullptr;
348  }
349 
350  void clear() {
351  __clear();
352  }
353 
354  bool operator==(const ProfilingStats &rhs) const {
355  if (rows != rhs.rows) {
356  return false;
357  }
358  if (execDurationInUs != rhs.execDurationInUs) {
359  return false;
360  }
361  if (totalDurationInUs != rhs.totalDurationInUs) {
362  return false;
363  }
364  return checkPointer(otherStats.get(), rhs.otherStats.get());
365  }
366 
367  // How many rows being processed in an executor.
368  int64_t rows{0};
369  // Duration spent in an executor.
370  int64_t execDurationInUs{0};
371  // Total duration spent in an executor, contains schedule time
372  int64_t totalDurationInUs{0};
373  // Other profiling stats data map
374  std::unique_ptr<std::unordered_map<std::string, std::string>> otherStats;
375 };
376 
377 // The info used for select/loop.
378 struct PlanNodeBranchInfo {
379  void __clear() {
380  isDoBranch = false;
381  conditionNodeId = -1;
382  }
383 
384  void clear() {
385  __clear();
386  }
387 
388  bool operator==(const PlanNodeBranchInfo &rhs) const {
389  return isDoBranch == rhs.isDoBranch && conditionNodeId == rhs.conditionNodeId;
390  }
391 
392  // True if loop body or then branch of select
393  bool isDoBranch{0};
394  // select/loop node id
395  int64_t conditionNodeId{-1};
396 };
397 
398 struct Pair {
399  void __clear() {
400  key.clear();
401  value.clear();
402  }
403 
404  void clear() {
405  __clear();
406  }
407 
408  bool operator==(const Pair &rhs) const {
409  return key == rhs.key && value == rhs.value;
410  }
411 
412  std::string key;
413  std::string value;
414 };
415 
416 struct PlanNodeDescription {
417  void __clear() {
418  name.clear();
419  id = -1;
420  outputVar.clear();
421  description = nullptr;
422  profiles = nullptr;
423  branchInfo = nullptr;
424  dependencies = nullptr;
425  }
426 
427  void clear() {
428  __clear();
429  }
430 
431  bool operator==(const PlanNodeDescription &rhs) const {
432  if (name != rhs.name) {
433  return false;
434  }
435  if (id != rhs.id) {
436  return false;
437  }
438  if (!checkPointer(description.get(), rhs.description.get())) {
439  return false;
440  }
441  if (!checkPointer(profiles.get(), rhs.profiles.get())) {
442  return false;
443  }
444  if (!checkPointer(branchInfo.get(), rhs.branchInfo.get())) {
445  return false;
446  }
447  return checkPointer(dependencies.get(), rhs.dependencies.get());
448  }
449 
450  std::string name;
451  int64_t id{-1};
452  std::string outputVar;
453  // other description of an executor
454  std::unique_ptr<std::vector<Pair>> description{nullptr};
455  // If an executor would be executed multi times,
456  // the profiling statistics should be multi-versioned.
457  std::unique_ptr<std::vector<ProfilingStats>> profiles{nullptr};
458  std::unique_ptr<PlanNodeBranchInfo> branchInfo{nullptr};
459  std::unique_ptr<std::vector<int64_t>> dependencies{nullptr};
460 };
461 
462 struct PlanDescription {
463  void __clear() {
464  planNodeDescs.clear();
465  nodeIndexMap.clear();
466  format.clear();
467  optimize_time_in_us = 0;
468  }
469 
470  void clear() {
471  __clear();
472  }
473 
474  bool operator==(const PlanDescription &rhs) const {
475  return planNodeDescs == rhs.planNodeDescs && nodeIndexMap == rhs.nodeIndexMap &&
476  format == rhs.format;
477  }
478 
479  std::vector<PlanNodeDescription> planNodeDescs;
480  // map from node id to index of list
481  std::unordered_map<int64_t, int64_t> nodeIndexMap;
482  // the print format of exec plan, lowercase string like `dot'
483  std::string format;
484  // the optimization spent time
485  int32_t optimize_time_in_us{0};
486 };
487 
488 struct ExecutionResponse {
489  void __clear() {
490  errorCode = ErrorCode::SUCCEEDED;
491  latencyInUs = 0;
492  data.reset();
493  spaceName.reset();
494  errorMsg.reset();
495  planDesc.reset();
496  comment.reset();
497  }
498 
499  void clear() {
500  __clear();
501  }
502 
503  bool operator==(const ExecutionResponse &rhs) const {
504  if (errorCode != rhs.errorCode) {
505  return false;
506  }
507  if (latencyInUs != rhs.latencyInUs) {
508  return false;
509  }
510  if (!checkPointer(data.get(), rhs.data.get())) {
511  return false;
512  }
513  if (!checkPointer(spaceName.get(), rhs.spaceName.get())) {
514  return false;
515  }
516  if (!checkPointer(errorMsg.get(), rhs.errorMsg.get())) {
517  return false;
518  }
519  if (!checkPointer(planDesc.get(), rhs.planDesc.get())) {
520  return false;
521  }
522  if (!checkPointer(comment.get(), rhs.comment.get())) {
523  return false;
524  }
525  return true;
526  }
527 
528  ErrorCode errorCode{ErrorCode::SUCCEEDED};
529  int64_t latencyInUs{0};
530  std::unique_ptr<nebula::DataSet> data{nullptr};
531  std::unique_ptr<std::string> spaceName{nullptr};
532  std::unique_ptr<std::string> errorMsg{nullptr};
533  std::unique_ptr<PlanDescription> planDesc{nullptr};
534  std::unique_ptr<std::string> comment{nullptr};
535 };
536 
537 struct VerifyClientVersionResp {
538  ErrorCode errorCode{ErrorCode::SUCCEEDED};
539  std::unique_ptr<std::string> errorMsg{nullptr};
540 };
541 
542 struct VerifyClientVersionReq {
543  // TODO initialize when build
544  std::string version{"3.0.0"};
545 };
546 
547 } // namespace nebula