xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

support tsma catalog cache

This commit is contained in:
wangjiaming0909 2023-11-29 19:07:23 +08:00
parent f77cd43d26
commit ef47fd57d6
33 changed files with 7422 additions and 4393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
include/common/tmsg.h
View File

@ -110,6 +110,7 @@ enum {
HEARTBEAT_KEY_TMQ, HEARTBEAT_KEY_TMQ,
HEARTBEAT_KEY_DYN_VIEW, HEARTBEAT_KEY_DYN_VIEW,
HEARTBEAT_KEY_VIEWINFO, HEARTBEAT_KEY_VIEWINFO,
HEARTBEAT_KEY_TSMA,
}; };
typedef enum _mgmt_table { typedef enum _mgmt_table {
@ -4190,6 +4191,47 @@ typedef struct {
int32_t tSerializeSViewMetaRsp(void* buf, int32_t bufLen, const SViewMetaRsp* pRsp); int32_t tSerializeSViewMetaRsp(void* buf, int32_t bufLen, const SViewMetaRsp* pRsp);
int32_t tDeserializeSViewMetaRsp(void* buf, int32_t bufLen, SViewMetaRsp* pRsp); int32_t tDeserializeSViewMetaRsp(void* buf, int32_t bufLen, SViewMetaRsp* pRsp);
void tFreeSViewMetaRsp(SViewMetaRsp* pRsp); void tFreeSViewMetaRsp(SViewMetaRsp* pRsp);
typedef struct {
char name[TSDB_TABLE_FNAME_LEN];
}STableTSMAInfoReq;
int32_t tSerializeTableTSMAInfoReq(void* buf, int32_t bufLen, const STableTSMAInfoReq* pReq);
int32_t tDeserializeTableTSMAInfoReq(void* buf, int32_t bufLen, STableTSMAInfoReq* pReq);
typedef struct {
int32_t funcId;
col_id_t colId;
} STableTSMAFuncInfo;
typedef struct {
char name[TSDB_TABLE_NAME_LEN];
uint64_t tsmaId;
char targetTb[TSDB_TABLE_NAME_LEN];
char targetDbFName[TSDB_DB_FNAME_LEN];
char tb[TSDB_TABLE_NAME_LEN];
char dbFName[TSDB_DB_FNAME_LEN];
uint64_t suid;
uint64_t dbId;
int32_t version;
int64_t interval;
int8_t unit;
SArray* pFuncs; // SArray<STableTSMAFuncInfo>
} STableTSMAInfo;
typedef struct {
SArray* pTsmas; // SArray<STableTSMAInfo*>
} STableTSMAInfoRsp;
int32_t tSerializeTableTSMAInfoRsp(void* buf, int32_t bufLen, const STableTSMAInfoRsp* pRsp);
int32_t tDeserializeTableTSMAInfoRsp(void* buf, int32_t bufLen, STableTSMAInfoRsp* pReq);
void tFreeTableTSMAInfo(void* p);
void tFreeAndClearTableTSMAInfo(void* p);
void tFreeTableTSMAInfoRsp(STableTSMAInfoRsp* pRsp);
#define STSMAHbRsp STableTSMAInfoRsp
#define tSerializeTSMAHbRsp tSerializeTableTSMAInfoRsp
#define tDeserializeTSMAHbRsp tDeserializeTableTSMAInfoRsp
#define tFreeTSMAHbRsp tFreeTableTSMAInfoRsp
#pragma pack(pop) #pragma pack(pop)

1
include/common/tmsgdef.h
View File

@ -226,6 +226,7 @@
TD_DEF_MSG_TYPE(TDMT_MND_CREATE_TSMA, "create-tsma", NULL, NULL) TD_DEF_MSG_TYPE(TDMT_MND_CREATE_TSMA, "create-tsma", NULL, NULL)
TD_DEF_MSG_TYPE(TDMT_MND_DROP_TSMA, "drop-tsma", NULL, NULL) TD_DEF_MSG_TYPE(TDMT_MND_DROP_TSMA, "drop-tsma", NULL, NULL)
TD_DEF_MSG_TYPE(TDMT_MND_STB_DROP, "drop-stb", NULL, NULL) TD_DEF_MSG_TYPE(TDMT_MND_STB_DROP, "drop-stb", NULL, NULL)
TD_DEF_MSG_TYPE(TDMT_MND_GET_TABLE_TSMA, "get-table-tsma", NULL, NULL)
TD_CLOSE_MSG_SEG(TDMT_END_MND_MSG) TD_CLOSE_MSG_SEG(TDMT_END_MND_MSG)
TD_NEW_MSG_SEG(TDMT_VND_MSG) // 2<<8 TD_NEW_MSG_SEG(TDMT_VND_MSG) // 2<<8

554
include/common/ttokendef.h
View File

@ -16,105 +16,105 @@
#ifndef _TD_COMMON_TOKEN_H_ #ifndef _TD_COMMON_TOKEN_H_
#define _TD_COMMON_TOKEN_H_ #define _TD_COMMON_TOKEN_H_
#define TK_OR 1 #define TK_OR 1
#define TK_AND 2 #define TK_AND 2
#define TK_UNION 3 #define TK_UNION 3
#define TK_ALL 4 #define TK_ALL 4
#define TK_MINUS 5 #define TK_MINUS 5
#define TK_EXCEPT 6 #define TK_EXCEPT 6
#define TK_INTERSECT 7 #define TK_INTERSECT 7
#define TK_NK_BITAND 8 #define TK_NK_BITAND 8
#define TK_NK_BITOR 9 #define TK_NK_BITOR 9
#define TK_NK_LSHIFT 10 #define TK_NK_LSHIFT 10
#define TK_NK_RSHIFT 11 #define TK_NK_RSHIFT 11
#define TK_NK_PLUS 12 #define TK_NK_PLUS 12
#define TK_NK_MINUS 13 #define TK_NK_MINUS 13
#define TK_NK_STAR 14 #define TK_NK_STAR 14
#define TK_NK_SLASH 15 #define TK_NK_SLASH 15
#define TK_NK_REM 16 #define TK_NK_REM 16
#define TK_NK_CONCAT 17 #define TK_NK_CONCAT 17
#define TK_CREATE 18 #define TK_CREATE 18
#define TK_ACCOUNT 19 #define TK_ACCOUNT 19
#define TK_NK_ID 20 #define TK_NK_ID 20
#define TK_PASS 21 #define TK_PASS 21
#define TK_NK_STRING 22 #define TK_NK_STRING 22
#define TK_ALTER 23 #define TK_ALTER 23
#define TK_PPS 24 #define TK_PPS 24
#define TK_TSERIES 25 #define TK_TSERIES 25
#define TK_STORAGE 26 #define TK_STORAGE 26
#define TK_STREAMS 27 #define TK_STREAMS 27
#define TK_QTIME 28 #define TK_QTIME 28
#define TK_DBS 29 #define TK_DBS 29
#define TK_USERS 30 #define TK_USERS 30
#define TK_CONNS 31 #define TK_CONNS 31
#define TK_STATE 32 #define TK_STATE 32
#define TK_NK_COMMA 33 #define TK_NK_COMMA 33
#define TK_HOST 34 #define TK_HOST 34
#define TK_USER 35 #define TK_USER 35
#define TK_ENABLE 36 #define TK_ENABLE 36
#define TK_NK_INTEGER 37 #define TK_NK_INTEGER 37
#define TK_SYSINFO 38 #define TK_SYSINFO 38
#define TK_ADD 39 #define TK_ADD 39
#define TK_DROP 40 #define TK_DROP 40
#define TK_GRANT 41 #define TK_GRANT 41
#define TK_ON 42 #define TK_ON 42
#define TK_TO 43 #define TK_TO 43
#define TK_REVOKE 44 #define TK_REVOKE 44
#define TK_FROM 45 #define TK_FROM 45
#define TK_SUBSCRIBE 46 #define TK_SUBSCRIBE 46
#define TK_READ 47 #define TK_READ 47
#define TK_WRITE 48 #define TK_WRITE 48
#define TK_NK_DOT 49 #define TK_NK_DOT 49
#define TK_WITH 50 #define TK_WITH 50
#define TK_DNODE 51 #define TK_DNODE 51
#define TK_PORT 52 #define TK_PORT 52
#define TK_DNODES 53 #define TK_DNODES 53
#define TK_RESTORE 54 #define TK_RESTORE 54
#define TK_NK_IPTOKEN 55 #define TK_NK_IPTOKEN 55
#define TK_FORCE 56 #define TK_FORCE 56
#define TK_UNSAFE 57 #define TK_UNSAFE 57
#define TK_CLUSTER 58 #define TK_CLUSTER 58
#define TK_LOCAL 59 #define TK_LOCAL 59
#define TK_QNODE 60 #define TK_QNODE 60
#define TK_BNODE 61 #define TK_BNODE 61
#define TK_SNODE 62 #define TK_SNODE 62
#define TK_MNODE 63 #define TK_MNODE 63
#define TK_VNODE 64 #define TK_VNODE 64
#define TK_DATABASE 65 #define TK_DATABASE 65
#define TK_USE 66 #define TK_USE 66
#define TK_FLUSH 67 #define TK_FLUSH 67
#define TK_TRIM 68 #define TK_TRIM 68
#define TK_S3MIGRATE 69 #define TK_S3MIGRATE 69
#define TK_COMPACT 70 #define TK_COMPACT 70
#define TK_IF 71 #define TK_IF 71
#define TK_NOT 72 #define TK_NOT 72
#define TK_EXISTS 73 #define TK_EXISTS 73
#define TK_BUFFER 74 #define TK_BUFFER 74
#define TK_CACHEMODEL 75 #define TK_CACHEMODEL 75
#define TK_CACHESIZE 76 #define TK_CACHESIZE 76
#define TK_COMP 77 #define TK_COMP 77
#define TK_DURATION 78 #define TK_DURATION 78
#define TK_NK_VARIABLE 79 #define TK_NK_VARIABLE 79
#define TK_MAXROWS 80 #define TK_MAXROWS 80
#define TK_MINROWS 81 #define TK_MINROWS 81
#define TK_KEEP 82 #define TK_KEEP 82
#define TK_PAGES 83 #define TK_PAGES 83
#define TK_PAGESIZE 84 #define TK_PAGESIZE 84
#define TK_TSDB_PAGESIZE 85 #define TK_TSDB_PAGESIZE 85
#define TK_PRECISION 86 #define TK_PRECISION 86
#define TK_REPLICA 87 #define TK_REPLICA 87
#define TK_VGROUPS 88 #define TK_VGROUPS 88
#define TK_SINGLE_STABLE 89 #define TK_SINGLE_STABLE 89
#define TK_RETENTIONS 90 #define TK_RETENTIONS 90
#define TK_SCHEMALESS 91 #define TK_SCHEMALESS 91
#define TK_WAL_LEVEL 92 #define TK_WAL_LEVEL 92
#define TK_WAL_FSYNC_PERIOD 93 #define TK_WAL_FSYNC_PERIOD 93
#define TK_WAL_RETENTION_PERIOD 94 #define TK_WAL_RETENTION_PERIOD 94
#define TK_WAL_RETENTION_SIZE 95 #define TK_WAL_RETENTION_SIZE 95
#define TK_WAL_ROLL_PERIOD 96 #define TK_WAL_ROLL_PERIOD 96
#define TK_WAL_SEGMENT_SIZE 97 #define TK_WAL_SEGMENT_SIZE 97
#define TK_STT_TRIGGER 98 #define TK_STT_TRIGGER 98
#define TK_TABLE_PREFIX 99 #define TK_TABLE_PREFIX 99
#define TK_TABLE_SUFFIX 100 #define TK_TABLE_SUFFIX 100
#define TK_S3_CHUNKSIZE 101 #define TK_S3_CHUNKSIZE 101
#define TK_S3_KEEPLOCAL 102 #define TK_S3_KEEPLOCAL 102
@ -206,184 +206,184 @@
#define TK_QTAGS 188 #define TK_QTAGS 188
#define TK_AS 189 #define TK_AS 189
#define TK_SYSTEM 190 #define TK_SYSTEM 190
#define TK_INDEX 191 #define TK_TSMA 191
#define TK_FUNCTION 192 #define TK_INTERVAL 192
#define TK_INTERVAL 193 #define TK_TSMAS 193
#define TK_COUNT 194 #define TK_FUNCTION 194
#define TK_LAST_ROW 195 #define TK_INDEX 195
#define TK_META 196 #define TK_COUNT 196
#define TK_ONLY 197 #define TK_LAST_ROW 197
#define TK_TOPIC 198 #define TK_META 198
#define TK_CONSUMER 199 #define TK_ONLY 199
#define TK_GROUP 200 #define TK_TOPIC 200
#define TK_DESC 201 #define TK_CONSUMER 201
#define TK_DESCRIBE 202 #define TK_GROUP 202
#define TK_RESET 203 #define TK_DESC 203
#define TK_QUERY 204 #define TK_DESCRIBE 204
#define TK_CACHE 205 #define TK_RESET 205
#define TK_EXPLAIN 206 #define TK_QUERY 206
#define TK_ANALYZE 207 #define TK_CACHE 207
#define TK_VERBOSE 208 #define TK_EXPLAIN 208
#define TK_NK_BOOL 209 #define TK_ANALYZE 209
#define TK_RATIO 210 #define TK_VERBOSE 210
#define TK_NK_FLOAT 211 #define TK_NK_BOOL 211
#define TK_OUTPUTTYPE 212 #define TK_RATIO 212
#define TK_AGGREGATE 213 #define TK_NK_FLOAT 213
#define TK_BUFSIZE 214 #define TK_OUTPUTTYPE 214
#define TK_LANGUAGE 215 #define TK_AGGREGATE 215
#define TK_REPLACE 216 #define TK_BUFSIZE 216
#define TK_STREAM 217 #define TK_LANGUAGE 217
#define TK_INTO 218 #define TK_REPLACE 218
#define TK_PAUSE 219 #define TK_STREAM 219
#define TK_RESUME 220 #define TK_INTO 220
#define TK_TRIGGER 221 #define TK_PAUSE 221
#define TK_AT_ONCE 222 #define TK_RESUME 222
#define TK_WINDOW_CLOSE 223 #define TK_TRIGGER 223
#define TK_IGNORE 224 #define TK_AT_ONCE 224
#define TK_EXPIRED 225 #define TK_WINDOW_CLOSE 225
#define TK_FILL_HISTORY 226 #define TK_IGNORE 226
#define TK_UPDATE 227 #define TK_EXPIRED 227
#define TK_SUBTABLE 228 #define TK_FILL_HISTORY 228
#define TK_UNTREATED 229 #define TK_UPDATE 229
#define TK_KILL 230 #define TK_SUBTABLE 230
#define TK_CONNECTION 231 #define TK_UNTREATED 231
#define TK_TRANSACTION 232 #define TK_KILL 232
#define TK_BALANCE 233 #define TK_CONNECTION 233
#define TK_VGROUP 234 #define TK_TRANSACTION 234
#define TK_LEADER 235 #define TK_BALANCE 235
#define TK_MERGE 236 #define TK_VGROUP 236
#define TK_REDISTRIBUTE 237 #define TK_LEADER 237
#define TK_SPLIT 238 #define TK_MERGE 238
#define TK_DELETE 239 #define TK_REDISTRIBUTE 239
#define TK_INSERT 240 #define TK_SPLIT 240
#define TK_NK_BIN 241 #define TK_DELETE 241
#define TK_NK_HEX 242 #define TK_INSERT 242
#define TK_NULL 243 #define TK_NK_BIN 243
#define TK_NK_QUESTION 244 #define TK_NK_HEX 244
#define TK_NK_ALIAS 245 #define TK_NULL 245
#define TK_NK_ARROW 246 #define TK_NK_QUESTION 246
#define TK_ROWTS 247 #define TK_NK_ALIAS 247
#define TK_QSTART 248 #define TK_NK_ARROW 248
#define TK_QEND 249 #define TK_ROWTS 249
#define TK_QDURATION 250 #define TK_QSTART 250
#define TK_WSTART 251 #define TK_QEND 251
#define TK_WEND 252 #define TK_QDURATION 252
#define TK_WDURATION 253 #define TK_WSTART 253
#define TK_IROWTS 254 #define TK_WEND 254
#define TK_ISFILLED 255 #define TK_WDURATION 255
#define TK_CAST 256 #define TK_IROWTS 256
#define TK_NOW 257 #define TK_ISFILLED 257
#define TK_TODAY 258 #define TK_CAST 258
#define TK_TIMEZONE 259 #define TK_NOW 259
#define TK_CLIENT_VERSION 260 #define TK_TODAY 260
#define TK_SERVER_VERSION 261 #define TK_TIMEZONE 261
#define TK_SERVER_STATUS 262 #define TK_CLIENT_VERSION 262
#define TK_CURRENT_USER 263 #define TK_SERVER_VERSION 263
#define TK_CASE 264 #define TK_SERVER_STATUS 264
#define TK_WHEN 265 #define TK_CURRENT_USER 265
#define TK_THEN 266 #define TK_CASE 266
#define TK_ELSE 267 #define TK_WHEN 267
#define TK_BETWEEN 268 #define TK_THEN 268
#define TK_IS 269 #define TK_ELSE 269
#define TK_NK_LT 270 #define TK_BETWEEN 270
#define TK_NK_GT 271 #define TK_IS 271
#define TK_NK_LE 272 #define TK_NK_LT 272
#define TK_NK_GE 273 #define TK_NK_GT 273
#define TK_NK_NE 274 #define TK_NK_LE 274
#define TK_MATCH 275 #define TK_NK_GE 275
#define TK_NMATCH 276 #define TK_NK_NE 276
#define TK_CONTAINS 277 #define TK_MATCH 277
#define TK_IN 278 #define TK_NMATCH 278
#define TK_JOIN 279 #define TK_CONTAINS 279
#define TK_INNER 280 #define TK_IN 280
#define TK_LEFT 281 #define TK_JOIN 281
#define TK_RIGHT 282 #define TK_INNER 282
#define TK_OUTER 283 #define TK_LEFT 283
#define TK_SEMI 284 #define TK_RIGHT 284
#define TK_ANTI 285 #define TK_OUTER 285
#define TK_ASOF 286 #define TK_SEMI 286
#define TK_WINDOW 287 #define TK_ANTI 287
#define TK_WINDOW_OFFSET 288 #define TK_ASOF 288
#define TK_JLIMIT 289 #define TK_WINDOW 289
#define TK_SELECT 290 #define TK_WINDOW_OFFSET 290
#define TK_NK_HINT 291 #define TK_JLIMIT 291
#define TK_DISTINCT 292 #define TK_SELECT 292
#define TK_WHERE 293 #define TK_NK_HINT 293
#define TK_PARTITION 294 #define TK_DISTINCT 294
#define TK_BY 295 #define TK_WHERE 295
#define TK_SESSION 296 #define TK_PARTITION 296
#define TK_STATE_WINDOW 297 #define TK_BY 297
#define TK_EVENT_WINDOW 298 #define TK_SESSION 298
#define TK_COUNT_WINDOW 299 #define TK_STATE_WINDOW 299
#define TK_SLIDING 300 #define TK_EVENT_WINDOW 300
#define TK_FILL 301 #define TK_COUNT_WINDOW 301
#define TK_VALUE 302 #define TK_SLIDING 302
#define TK_VALUE_F 303 #define TK_FILL 303
#define TK_NONE 304 #define TK_VALUE 304
#define TK_PREV 305 #define TK_VALUE_F 305
#define TK_NULL_F 306 #define TK_NONE 306
#define TK_LINEAR 307 #define TK_PREV 307
#define TK_NEXT 308 #define TK_NULL_F 308
#define TK_HAVING 309 #define TK_LINEAR 309
#define TK_RANGE 310 #define TK_NEXT 310
#define TK_EVERY 311 #define TK_HAVING 311
#define TK_ORDER 312 #define TK_RANGE 312
#define TK_SLIMIT 313 #define TK_EVERY 313
#define TK_SOFFSET 314 #define TK_ORDER 314
#define TK_LIMIT 315 #define TK_SLIMIT 315
#define TK_OFFSET 316 #define TK_SOFFSET 316
#define TK_ASC 317 #define TK_LIMIT 317
#define TK_NULLS 318 #define TK_OFFSET 318
#define TK_ABORT 319 #define TK_ASC 319
#define TK_AFTER 320 #define TK_NULLS 320
#define TK_ATTACH 321 #define TK_ABORT 321
#define TK_BEFORE 322 #define TK_AFTER 322
#define TK_BEGIN 323 #define TK_ATTACH 323
#define TK_BITAND 324 #define TK_BEFORE 324
#define TK_BITNOT 325 #define TK_BEGIN 325
#define TK_BITOR 326 #define TK_BITAND 326
#define TK_BLOCKS 327 #define TK_BITNOT 327
#define TK_CHANGE 328 #define TK_BITOR 328
#define TK_COMMA 329 #define TK_BLOCKS 329
#define TK_CONCAT 330 #define TK_CHANGE 330
#define TK_CONFLICT 331 #define TK_COMMA 331
#define TK_COPY 332 #define TK_CONCAT 332
#define TK_DEFERRED 333 #define TK_CONFLICT 333
#define TK_DELIMITERS 334 #define TK_COPY 334
#define TK_DETACH 335 #define TK_DEFERRED 335
#define TK_DIVIDE 336 #define TK_DELIMITERS 336
#define TK_DOT 337 #define TK_DETACH 337
#define TK_EACH 338 #define TK_DIVIDE 338
#define TK_FAIL 339 #define TK_DOT 339
#define TK_FILE 340 #define TK_EACH 340
#define TK_FOR 341 #define TK_FAIL 341
#define TK_GLOB 342 #define TK_FILE 342
#define TK_ID 343 #define TK_FOR 343
#define TK_IMMEDIATE 344 #define TK_GLOB 344
#define TK_IMPORT 345 #define TK_ID 345
#define TK_INITIALLY 346 #define TK_IMMEDIATE 346
#define TK_INSTEAD 347 #define TK_IMPORT 347
#define TK_ISNULL 348 #define TK_INITIALLY 348
#define TK_MODULES 349 #define TK_INSTEAD 349
#define TK_NK_BITNOT 350 #define TK_ISNULL 350
#define TK_NK_SEMI 351 #define TK_MODULES 351
#define TK_NOTNULL 352 #define TK_NK_BITNOT 352
#define TK_OF 353 #define TK_NK_SEMI 353
#define TK_PLUS 354 #define TK_NOTNULL 354
#define TK_PRIVILEGE 355 #define TK_OF 355
#define TK_RAISE 356 #define TK_PLUS 356
#define TK_RESTRICT 357 #define TK_PRIVILEGE 357
#define TK_ROW 358 #define TK_RAISE 358
#define TK_STAR 359 #define TK_RESTRICT 359
#define TK_STATEMENT 360 #define TK_ROW 360
#define TK_STRICT 361 #define TK_STAR 361
#define TK_STRING 362 #define TK_STATEMENT 362
#define TK_TIMES 363 #define TK_STRICT 363
#define TK_VALUES 364 #define TK_STRING 364
#define TK_VARIABLE 365 #define TK_TIMES 365
#define TK_WAL 366 #define TK_VALUES 366
#define TK_VARIABLE 367
#define TK_WAL 368
#define TK_NK_SPACE 600 #define TK_NK_SPACE 600
#define TK_NK_COMMENT 601 #define TK_NK_COMMENT 601

22
include/libs/catalog/catalog.h
View File

@ -94,6 +94,7 @@ typedef struct SCatalogReq {
SArray* pTableCfg; // element is SNAME SArray* pTableCfg; // element is SNAME
SArray* pTableTag; // element is SNAME SArray* pTableTag; // element is SNAME
SArray* pView; // element is STablesReq SArray* pView; // element is STablesReq
SArray* pTableTSMAs; // element is STablesReq
bool qNodeRequired; // valid qnode bool qNodeRequired; // valid qnode
bool dNodeRequired; // valid dnode bool dNodeRequired; // valid dnode
bool svrVerRequired; bool svrVerRequired;
@ -122,6 +123,7 @@ typedef struct SMetaData {
SArray* pTableTag; // pRes = SArray<STagVal>* SArray* pTableTag; // pRes = SArray<STagVal>*
SArray* pDnodeList; // pRes = SArray<SEpSet>* SArray* pDnodeList; // pRes = SArray<SEpSet>*
SArray* pView; // pRes = SViewMeta* SArray* pView; // pRes = SViewMeta*
SArray* pTableTsmas; // pRes = SArray<STableTSMAInfo>*
SMetaRes* pSvrVer; // pRes = char* SMetaRes* pSvrVer; // pRes = char*
} SMetaData; } SMetaData;
@ -130,9 +132,11 @@ typedef struct SCatalogCfg {
uint32_t maxViewCacheNum; uint32_t maxViewCacheNum;
uint32_t maxDBCacheNum; uint32_t maxDBCacheNum;
uint32_t maxUserCacheNum; uint32_t maxUserCacheNum;
uint32_t maxTSMACacheNum;
uint32_t dbRentSec; uint32_t dbRentSec;
uint32_t stbRentSec; uint32_t stbRentSec;
uint32_t viewRentSec; uint32_t viewRentSec;
uint32_t tsmaRentSec;
} SCatalogCfg; } SCatalogCfg;
typedef struct SSTableVersion { typedef struct SSTableVersion {
@ -167,6 +171,14 @@ typedef struct SViewVersion {
int32_t version; int32_t version;
} SViewVersion; } SViewVersion;
typedef struct STSMAVersion {
char dbFName[TSDB_DB_FNAME_LEN];
char tbName[TSDB_TABLE_NAME_LEN];
char name[TSDB_TABLE_NAME_LEN];
uint64_t dbId;
uint64_t tsmaId;
int32_t version;
} STSMAVersion;
typedef struct STbSVersion { typedef struct STbSVersion {
char* tbFName; char* tbFName;
@ -179,6 +191,8 @@ typedef struct SUserAuthVersion {
int32_t version; int32_t version;
} SUserAuthVersion; } SUserAuthVersion;
typedef struct {} STableTSMAVersion;
typedef SUserIndexRsp SIndexInfo; typedef SUserIndexRsp SIndexInfo;
typedef void (*catalogCallback)(SMetaData* pResult, void* param, int32_t code); typedef void (*catalogCallback)(SMetaData* pResult, void* param, int32_t code);
@ -342,6 +356,8 @@ int32_t catalogGetExpiredDBs(SCatalog* pCatalog, SDbCacheInfo** dbs, uint32_t* n
int32_t catalogGetExpiredUsers(SCatalog* pCtg, SUserAuthVersion** users, uint32_t* num); int32_t catalogGetExpiredUsers(SCatalog* pCtg, SUserAuthVersion** users, uint32_t* num);
int32_t catalogGetExpiredTsmas(SCatalog* pCtg, STSMAVersion** tsmas, uint32_t* num);
int32_t catalogGetDBCfg(SCatalog* pCtg, SRequestConnInfo* pConn, const char* dbFName, SDbCfgInfo* pDbCfg); int32_t catalogGetDBCfg(SCatalog* pCtg, SRequestConnInfo* pConn, const char* dbFName, SDbCfgInfo* pDbCfg);
int32_t catalogGetIndexMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const char* indexName, SIndexInfo* pInfo); int32_t catalogGetIndexMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const char* indexName, SIndexInfo* pInfo);
@ -388,6 +404,12 @@ int32_t ctgdEnableDebug(char* option, bool enable);
int32_t ctgdHandleDbgCommand(char* command); int32_t ctgdHandleDbgCommand(char* command);
int32_t catalogAsyncUpdateTSMA(SCatalog* pCtg, STableTSMAInfo** pTsma);
int32_t catalogUpdateTSMA(SCatalog* pCtg, STableTSMAInfo** ppTsma);
int32_t catalogRemoveTSMA(SCatalog* pCtg, const STableTSMAInfo* pTsma);
/** /**
* Destroy catalog and relase all resources * Destroy catalog and relase all resources
*/ */

5
include/libs/function/functionMgt.h
View File

@ -164,6 +164,8 @@ typedef enum EFunctionType {
FUNCTION_TYPE_STDDEV_MERGE, FUNCTION_TYPE_STDDEV_MERGE,
FUNCTION_TYPE_IRATE_PARTIAL, FUNCTION_TYPE_IRATE_PARTIAL,
FUNCTION_TYPE_IRATE_MERGE, FUNCTION_TYPE_IRATE_MERGE,
FUNCTION_TYPE_AVG_STATE,
FUNCTION_TYPE_AVG_STATE_MERGE,
// geometry functions // geometry functions
FUNCTION_TYPE_GEOM_FROM_TEXT = 4250, FUNCTION_TYPE_GEOM_FROM_TEXT = 4250,
@ -271,6 +273,9 @@ bool fmIsInvertible(int32_t funcId);
char* fmGetFuncName(int32_t funcId); char* fmGetFuncName(int32_t funcId);
bool fmIsTSMASupportedFunc(func_id_t funcid);
int32_t rewriteFuncsForTSMA(SNodeList* pFuncs);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

3
include/libs/nodes/cmdnodes.h
View File

@ -605,7 +605,7 @@ typedef struct SCreateTSMAStmt {
char dbName[TSDB_DB_NAME_LEN]; char dbName[TSDB_DB_NAME_LEN];
char tableName[TSDB_TABLE_NAME_LEN]; char tableName[TSDB_TABLE_NAME_LEN];
STSMAOptions* pOptions; STSMAOptions* pOptions;
SMCreateSmaReq* pReq; //SMCreateSmaReq* pReq;
} SCreateTSMAStmt; } SCreateTSMAStmt;
typedef struct SShowCreateTSMAStmt { typedef struct SShowCreateTSMAStmt {
@ -619,7 +619,6 @@ typedef struct SDropTSMAStmt {
bool ignoreNotExists; bool ignoreNotExists;
char dbName[TSDB_DB_NAME_LEN]; char dbName[TSDB_DB_NAME_LEN];
char tsmaName[TSDB_INDEX_NAME_LEN]; char tsmaName[TSDB_INDEX_NAME_LEN];
SMDropSmaReq* pReq;
} SDropTSMAStmt; } SDropTSMAStmt;
#ifdef __cplusplus #ifdef __cplusplus

68
source/client/src/clientHb.c
View File

@ -327,6 +327,33 @@ static int32_t hbProcessViewInfoRsp(void *value, int32_t valueLen, struct SCatal
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
static int32_t hbprocessTSMARsp(void* value, int32_t valueLen, struct SCatalog* pCatalog) {
int32_t code = 0;
STSMAHbRsp hbRsp = {0};
if (tDeserializeTSMAHbRsp(value, valueLen, &hbRsp)) {
terrno = TSDB_CODE_INVALID_MSG;
return -1;
}
int32_t numOfTsma = taosArrayGetSize(hbRsp.pTsmas);
for (int32_t i = 0; i < numOfTsma; ++i) {
STableTSMAInfo* pTsmaInfo = taosArrayGetP(hbRsp.pTsmas, i);
if (!pTsmaInfo->pFuncs) {
tscDebug("hb to remote tsma: %s.%s", pTsmaInfo->dbFName, pTsmaInfo->name);
catalogRemoveTSMA(pCatalog, pTsmaInfo);
tFreeAndClearTableTSMAInfo(pTsmaInfo);
} else {
tscDebug("hb to update tsma: %s.%s", pTsmaInfo->dbFName, pTsmaInfo->name);
catalogUpdateTSMA(pCatalog, &pTsmaInfo);
tFreeAndClearTableTSMAInfo(pTsmaInfo);
}
}
taosArrayDestroy(hbRsp.pTsmas);
return TSDB_CODE_SUCCESS;
}
static void hbProcessQueryRspKvs(int32_t kvNum, SArray* pKvs, struct SCatalog *pCatalog, SAppHbMgr *pAppHbMgr) { static void hbProcessQueryRspKvs(int32_t kvNum, SArray* pKvs, struct SCatalog *pCatalog, SAppHbMgr *pAppHbMgr) {
for (int32_t i = 0; i < kvNum; ++i) { for (int32_t i = 0; i < kvNum; ++i) {
@ -379,6 +406,13 @@ static void hbProcessQueryRspKvs(int32_t kvNum, SArray* pKvs, struct SCatalog *p
break; break;
} }
#endif #endif
case HEARTBEAT_KEY_TSMA: {
if (kv->valueLen <= 0 || !kv->value) {
tscError("Invalid tsma info, len: %d, value: %p", kv->valueLen, kv->value);
}
hbprocessTSMARsp(kv->value, kv->valueLen, pCatalog);
break;
}
default: default:
tscError("invalid hb key type:%d", kv->key); tscError("invalid hb key type:%d", kv->key);
break; break;
@ -871,6 +905,39 @@ int32_t hbGetExpiredViewInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, S
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t hbGetExpiredTSMAInfo(SClientHbKey* connKey, struct SCatalog* pCatalog, SClientHbReq* pReq) {
int32_t code = 0;
uint32_t tsmaNum = 0;
STSMAVersion *tsmas = NULL;
code = catalogGetExpiredTsmas(pCatalog, &tsmas, &tsmaNum);
if (code) {
taosMemoryFree(tsmas);
return code;
}
if (tsmaNum <= 0) {
taosMemoryFree(tsmas);
return TSDB_CODE_SUCCESS;
}
for (int32_t i = 0; i < tsmaNum; ++i) {
STSMAVersion* tsma = &tsmas[i];
tsma->dbId = htobe64(tsma->dbId);
tsma->tsmaId = htobe64(tsma->tsmaId);
tsma->version = htonl(tsma->version);
}
tscDebug("hb got %d expred tsmas, valueLen: %lu", tsmaNum, sizeof(STSMAVersion) * tsmaNum);
if (!pReq->info) {
pReq->info = taosHashInit(64, hbKeyHashFunc, 1, HASH_ENTRY_LOCK);
}
SKv kv = {.key = HEARTBEAT_KEY_TSMA, .valueLen = sizeof(STSMAVersion) * tsmaNum, .value = tsmas};
taosHashPut(pReq->info, &kv.key, sizeof(kv.key), &kv, sizeof(kv));
return TSDB_CODE_SUCCESS;
}
int32_t hbGetAppInfo(int64_t clusterId, SClientHbReq *req) { int32_t hbGetAppInfo(int64_t clusterId, SClientHbReq *req) {
SAppHbReq *pApp = taosHashGet(clientHbMgr.appSummary, &clusterId, sizeof(clusterId)); SAppHbReq *pApp = taosHashGet(clientHbMgr.appSummary, &clusterId, sizeof(clusterId));
@ -935,6 +1002,7 @@ int32_t hbQueryHbReqHandle(SClientHbKey *connKey, void *param, SClientHbReq *req
return code; return code;
} }
#endif #endif
code = hbGetExpiredTSMAInfo(connKey, pCatalog, req);
} else { } else {
req->app.appId = 0; req->app.appId = 0;
} }

1
source/client/src/clientMain.c
View File

@ -936,6 +936,7 @@ int32_t cloneCatalogReq(SCatalogReq **ppTarget, SCatalogReq *pSrc) {
pTarget->pTableCfg = taosArrayDup(pSrc->pTableCfg, NULL); pTarget->pTableCfg = taosArrayDup(pSrc->pTableCfg, NULL);
pTarget->pTableTag = taosArrayDup(pSrc->pTableTag, NULL); pTarget->pTableTag = taosArrayDup(pSrc->pTableTag, NULL);
pTarget->pView = taosArrayDup(pSrc->pView, NULL); pTarget->pView = taosArrayDup(pSrc->pView, NULL);
pTarget->pTableTSMAs = taosArrayDup(pSrc->pTableTSMAs, NULL);
pTarget->qNodeRequired = pSrc->qNodeRequired; pTarget->qNodeRequired = pSrc->qNodeRequired;
pTarget->dNodeRequired = pSrc->dNodeRequired; pTarget->dNodeRequired = pSrc->dNodeRequired;
pTarget->svrVerRequired = pSrc->svrVerRequired; pTarget->svrVerRequired = pSrc->svrVerRequired;

150
source/common/src/tmsg.c
View File

@ -9936,3 +9936,153 @@ void tFreeSViewHbRsp(SViewHbRsp *pRsp) {
taosArrayDestroy(pRsp->pViewRsp); taosArrayDestroy(pRsp->pViewRsp);
} }
int32_t tSerializeTableTSMAInfoReq(void* buf, int32_t bufLen, const STableTSMAInfoReq* pReq) {
SEncoder encoder = {0};
tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeTableTSMAInfoReq(void* buf, int32_t bufLen, STableTSMAInfoReq* pReq) {
SDecoder decoder = {0};
tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
tEndDecode(&decoder);
tDecoderClear(&decoder);
return 0;
}
static int32_t tEncodeTableTSMAInfo(SEncoder* pEncoder, const STableTSMAInfo* pTsmaInfo) {
if (tEncodeCStr(pEncoder, pTsmaInfo->name) < 0) return -1;
if (tEncodeU64(pEncoder, pTsmaInfo->tsmaId) < 0) return -1;
if (tEncodeCStr(pEncoder, pTsmaInfo->tb) < 0) return -1;
if (tEncodeCStr(pEncoder, pTsmaInfo->dbFName) < 0) return -1;
if (tEncodeU64(pEncoder, pTsmaInfo->suid) < 0) return -1;
if (tEncodeU64(pEncoder, pTsmaInfo->dbId) < 0) return -1;
if (tEncodeI32(pEncoder, pTsmaInfo->version) < 0) return -1;
if (tEncodeCStr(pEncoder, pTsmaInfo->targetTb) < 0) return -1;
if (tEncodeCStr(pEncoder, pTsmaInfo->targetDbFName) < 0) return -1;
if (tEncodeI64(pEncoder, pTsmaInfo->interval) < 0) return -1;
if (tEncodeI8(pEncoder, pTsmaInfo->unit) < 0) return -1;
int32_t size = pTsmaInfo->pFuncs ? pTsmaInfo->pFuncs->size : 0;
if (tEncodeI32(pEncoder, size) < 0) return -1;
for (int32_t i = 0; i < size; ++i) {
STableTSMAFuncInfo* pFuncInfo = taosArrayGet(pTsmaInfo->pFuncs, i);
if (tEncodeI32(pEncoder, pFuncInfo->funcId) < 0) return -1;
if (tEncodeI16(pEncoder, pFuncInfo->colId) < 0) return -1;
}
return 0;
}
static int32_t tDecodeTableTSMAInfo(SDecoder* pDecoder, STableTSMAInfo* pTsmaInfo) {
if (tDecodeCStrTo(pDecoder, pTsmaInfo->name) < 0) return -1;
if (tDecodeU64(pDecoder, &pTsmaInfo->tsmaId) < 0) return -1;
if (tDecodeCStrTo(pDecoder, pTsmaInfo->tb) < 0) return -1;
if (tDecodeCStrTo(pDecoder, pTsmaInfo->dbFName) < 0) return -1;
if (tDecodeU64(pDecoder, &pTsmaInfo->suid) < 0) return -1;
if (tDecodeU64(pDecoder, &pTsmaInfo->dbId) < 0) return -1;
if (tDecodeI32(pDecoder, &pTsmaInfo->version) < 0) return -1;
if (tDecodeCStrTo(pDecoder, pTsmaInfo->targetTb) < 0) return -1;
if (tDecodeCStrTo(pDecoder, pTsmaInfo->targetDbFName) < 0) return -1;
if (tDecodeI64(pDecoder, &pTsmaInfo->interval) < 0) return -1;
if (tDecodeI8(pDecoder, &pTsmaInfo->unit) < 0) return -1;
int32_t size = 0;
if (tDecodeI32(pDecoder, &size) < 0) return -1;
if (size <= 0) return 0;
pTsmaInfo->pFuncs = taosArrayInit(size, sizeof(STableTSMAFuncInfo));
if (!pTsmaInfo->pFuncs) return -1;
for (int32_t i = 0; i < size; ++i) {
STableTSMAFuncInfo funcInfo = {0};
//TODO free the array when decode failed
if (tDecodeI32(pDecoder, &funcInfo.funcId) < 0) return -1;
if (tDecodeI16(pDecoder, &funcInfo.colId) < 0) return -1;
if (!taosArrayPush(pTsmaInfo->pFuncs, &funcInfo)) return -1;
}
return 0;
}
static int32_t tEncodeTableTSMAInfoRsp(SEncoder *pEncoder, const STableTSMAInfoRsp *pRsp) {
int32_t size = pRsp->pTsmas ? pRsp->pTsmas->size : 0;
if (tEncodeI32(pEncoder, size) < 0) return -1;
for (int32_t i = 0; i < size; ++i) {
STableTSMAInfo* pInfo = taosArrayGetP(pRsp->pTsmas, i);
if (tEncodeTableTSMAInfo(pEncoder, pInfo) < 0) return -1;
}
return 0;
}
static int32_t tDecodeTableTSMAInfoRsp(SDecoder* pDecoder, STableTSMAInfoRsp* pRsp) {
int32_t size = 0;
if (tDecodeI32(pDecoder, &size) < 0) return -1;
if (size <= 0) return 0;
pRsp->pTsmas = taosArrayInit(size, POINTER_BYTES);
if (!pRsp->pTsmas) return -1;
for (int32_t i = 0; i < size; ++i) {
// TODO add a test case when decode failed, to see if the array is freed
STableTSMAInfo *pTsma = taosMemoryCalloc(1, sizeof(STableTSMAInfo));
if (!pTsma) return -1;
taosArrayPush(pRsp->pTsmas, &pTsma);
if (tDecodeTableTSMAInfo(pDecoder, pTsma) < 0) return -1;
}
return 0;
}
int32_t tSerializeTableTSMAInfoRsp(void* buf, int32_t bufLen, const STableTSMAInfoRsp* pRsp) {
SEncoder encoder = {0};
tEncoderInit(&encoder, buf, bufLen);
if (tStartEncode(&encoder) < 0) return -1;
if (tEncodeTableTSMAInfoRsp(&encoder, pRsp) < 0) return -1;
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
tEncoderClear(&encoder);
return tlen;
}
int32_t tDeserializeTableTSMAInfoRsp(void* buf, int32_t bufLen, STableTSMAInfoRsp* pRsp) {
SDecoder decoder = {0};
tDecoderInit(&decoder, buf, bufLen);
if (tStartDecode(&decoder) < 0) return -1;
if (tDecodeTableTSMAInfoRsp(&decoder, pRsp) < 0) return -1;
tEndDecode(&decoder);
tDecoderClear(&decoder);
return 0;
}
void tFreeTableTSMAInfo(void* p) {
STableTSMAInfo *pTsmaInfo = p;
if (pTsmaInfo) taosArrayDestroy(pTsmaInfo->pFuncs);
}
void tFreeAndClearTableTSMAInfo(void* p) {
STableTSMAInfo* pTsmaInfo = (STableTSMAInfo*)p;
if (pTsmaInfo) {
tFreeTableTSMAInfo(pTsmaInfo);
taosMemoryFree(pTsmaInfo);
}
}
void tFreeTableTSMAInfoRsp(STableTSMAInfoRsp *pRsp) {
if (pRsp && pRsp->pTsmas) {
taosArrayDestroyP(pRsp->pTsmas, tFreeAndClearTableTSMAInfo);
}
}

1
source/dnode/mnode/impl/inc/mndDef.h
View File

@ -457,6 +457,7 @@ typedef struct {
int32_t tagsFilterLen; int32_t tagsFilterLen;
int32_t sqlLen; int32_t sqlLen;
int32_t astLen; int32_t astLen;
int32_t version;
char* expr; char* expr;
char* tagsFilter; char* tagsFilter;
char* sql; char* sql;

2
source/dnode/mnode/impl/inc/mndSma.h
View File

@ -29,6 +29,8 @@ void mndReleaseSma(SMnode *pMnode, SSmaObj *pSma);
int32_t mndDropSmasByStb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb); int32_t mndDropSmasByStb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb);
int32_t mndDropSmasByDb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb); int32_t mndDropSmasByDb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb);
int32_t mndGetTableSma(SMnode *pMnode, char *tbFName, STableIndexRsp *rsp, bool *exist); int32_t mndGetTableSma(SMnode *pMnode, char *tbFName, STableIndexRsp *rsp, bool *exist);
int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t numOfTsmas, void **ppRsp,
int32_t *pRspLen);
#ifdef __cplusplus #ifdef __cplusplus
} }

11
source/dnode/mnode/impl/src/mndProfile.c
View File

@ -25,6 +25,7 @@
#include "mndStb.h" #include "mndStb.h"
#include "mndUser.h" #include "mndUser.h"
#include "mndView.h" #include "mndView.h"
#include "mndSma.h"
#include "tglobal.h" #include "tglobal.h"
#include "tversion.h" #include "tversion.h"
@ -606,6 +607,16 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
break; break;
} }
#endif #endif
case HEARTBEAT_KEY_TSMA: {
void * rspMsg = NULL;
int32_t rspLen = 0;
mndValidateTSMAInfo(pMnode, kv->value, kv->valueLen / sizeof(STSMAVersion), &rspMsg, &rspLen);
if (rspMsg && rspLen > 0) {
SKv kv = {.key = HEARTBEAT_KEY_TSMA, .valueLen = rspLen, .value = rspMsg};
taosArrayPush(hbRsp.info, &kv);
}
break;
}
default: default:
mError("invalid kv key:%d", kv->key); mError("invalid kv key:%d", kv->key);
hbRsp.status = TSDB_CODE_APP_ERROR; hbRsp.status = TSDB_CODE_APP_ERROR;

272
source/dnode/mnode/impl/src/mndSma.c
View File

@ -58,16 +58,17 @@ static void mndCancelRetrieveIdx(SMnode *pMnode, void *pIter);
static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows); static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
static void mndCancelRetrieveTSMA(SMnode *pMnode, void *pIter); static void mndCancelRetrieveTSMA(SMnode *pMnode, void *pIter);
static int32_t mndProcessGetTbTSMAReq(SRpcMsg *pReq);
typedef struct SCreateTSMACxt { typedef struct SCreateTSMACxt {
SMnode * pMnode; SMnode * pMnode;
const SRpcMsg * pRpcReq; const SRpcMsg *pRpcReq;
union { union {
const SMCreateSmaReq *pCreateSmaReq; const SMCreateSmaReq *pCreateSmaReq;
const SMDropSmaReq * pDropSmaReq; const SMDropSmaReq * pDropSmaReq;
}; };
const SDbObj * pDb; const SDbObj *pDb;
const SStbObj * pSrcStb; SStbObj * pSrcStb;
// TODO normal table // TODO normal table
SSmaObj * pSma; SSmaObj * pSma;
SCMCreateStreamReq *pCreateStreamReq; SCMCreateStreamReq *pCreateStreamReq;
@ -99,6 +100,7 @@ int32_t mndInitSma(SMnode *pMnode) {
mndSetMsgHandle(pMnode, TDMT_MND_CREATE_TSMA, mndProcessCreateTSMAReq); mndSetMsgHandle(pMnode, TDMT_MND_CREATE_TSMA, mndProcessCreateTSMAReq);
mndSetMsgHandle(pMnode, TDMT_MND_DROP_TSMA, mndProcessDropTSMAReq); mndSetMsgHandle(pMnode, TDMT_MND_DROP_TSMA, mndProcessDropTSMAReq);
mndSetMsgHandle(pMnode, TDMT_MND_GET_TABLE_TSMA, mndProcessGetTbTSMAReq);
mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_TSMAS, mndRetrieveTSMA); mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_TSMAS, mndRetrieveTSMA);
mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_TSMAS, mndCancelRetrieveTSMA); mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_TSMAS, mndCancelRetrieveTSMA);
@ -136,6 +138,7 @@ static SSdbRaw *mndSmaActionEncode(SSmaObj *pSma) {
SDB_SET_INT32(pRaw, dataPos, pSma->tagsFilterLen, _OVER) SDB_SET_INT32(pRaw, dataPos, pSma->tagsFilterLen, _OVER)
SDB_SET_INT32(pRaw, dataPos, pSma->sqlLen, _OVER) SDB_SET_INT32(pRaw, dataPos, pSma->sqlLen, _OVER)
SDB_SET_INT32(pRaw, dataPos, pSma->astLen, _OVER) SDB_SET_INT32(pRaw, dataPos, pSma->astLen, _OVER)
SDB_SET_INT32(pRaw, dataPos, pSma->version, _OVER)
if (pSma->exprLen > 0) { if (pSma->exprLen > 0) {
SDB_SET_BINARY(pRaw, dataPos, pSma->expr, pSma->exprLen, _OVER) SDB_SET_BINARY(pRaw, dataPos, pSma->expr, pSma->exprLen, _OVER)
@ -207,6 +210,7 @@ static SSdbRow *mndSmaActionDecode(SSdbRaw *pRaw) {
SDB_GET_INT32(pRaw, dataPos, &pSma->tagsFilterLen, _OVER) SDB_GET_INT32(pRaw, dataPos, &pSma->tagsFilterLen, _OVER)
SDB_GET_INT32(pRaw, dataPos, &pSma->sqlLen, _OVER) SDB_GET_INT32(pRaw, dataPos, &pSma->sqlLen, _OVER)
SDB_GET_INT32(pRaw, dataPos, &pSma->astLen, _OVER) SDB_GET_INT32(pRaw, dataPos, &pSma->astLen, _OVER)
SDB_GET_INT32(pRaw, dataPos, &pSma->version, _OVER)
if (pSma->exprLen > 0) { if (pSma->exprLen > 0) {
pSma->expr = taosMemoryCalloc(pSma->exprLen, 1); pSma->expr = taosMemoryCalloc(pSma->exprLen, 1);
@ -1396,6 +1400,7 @@ static void initSMAObj(SCreateTSMACxt* pCxt) {
pCxt->pSma->interval = pCxt->pCreateSmaReq->interval; pCxt->pSma->interval = pCxt->pCreateSmaReq->interval;
pCxt->pSma->intervalUnit = pCxt->pCreateSmaReq->intervalUnit; pCxt->pSma->intervalUnit = pCxt->pCreateSmaReq->intervalUnit;
pCxt->pSma->timezone = tsTimezone; pCxt->pSma->timezone = tsTimezone;
pCxt->pSma->version = 1;
pCxt->pSma->exprLen = pCxt->pCreateSmaReq->exprLen; pCxt->pSma->exprLen = pCxt->pCreateSmaReq->exprLen;
pCxt->pSma->sqlLen = pCxt->pCreateSmaReq->sqlLen; pCxt->pSma->sqlLen = pCxt->pCreateSmaReq->sqlLen;
@ -1478,6 +1483,7 @@ static int32_t mndCreateTSMASetCreateStreamUndoAction(SMnode* pMnode) {
static int32_t mndCreateTSMATxnPrepare(SCreateTSMACxt* pCxt) { static int32_t mndCreateTSMATxnPrepare(SCreateTSMACxt* pCxt) {
int32_t code = -1; int32_t code = -1;
// TODO change the action name
STransAction redoAction = {0}; STransAction redoAction = {0};
STransAction undoAction = {0}; STransAction undoAction = {0};
// TODO trans conflicting setting, maybe conflict with myself // TODO trans conflicting setting, maybe conflict with myself
@ -1528,6 +1534,7 @@ static int32_t mndCreateTSMATxnPrepare(SCreateTSMACxt* pCxt) {
if (mndSetCreateSmaCommitLogs(pCxt->pMnode, pTrans, pCxt->pSma) != 0) goto _OVER; if (mndSetCreateSmaCommitLogs(pCxt->pMnode, pTrans, pCxt->pSma) != 0) goto _OVER;
if (mndTransAppendRedoAction(pTrans, &redoAction) != 0) goto _OVER; if (mndTransAppendRedoAction(pTrans, &redoAction) != 0) goto _OVER;
if (mndTransAppendUndoAction(pTrans, &undoAction) != 0) goto _OVER; if (mndTransAppendUndoAction(pTrans, &undoAction) != 0) goto _OVER;
//TODO add drop stable undo action
if (mndTransPrepare(pCxt->pMnode, pTrans) != 0) goto _OVER; if (mndTransPrepare(pCxt->pMnode, pTrans) != 0) goto _OVER;
code = TSDB_CODE_SUCCESS; code = TSDB_CODE_SUCCESS;
@ -1560,6 +1567,8 @@ static int32_t mndCreateTSMA(SCreateTSMACxt *pCxt) {
} }
_OVER: _OVER:
tFreeSCMCreateStreamReq(pCxt->pCreateStreamReq);
tFreeMDropStreamReq(pCxt->pDropStreamReq);
pCxt->pCreateStreamReq = NULL; pCxt->pCreateStreamReq = NULL;
return code; return code;
} }
@ -1731,6 +1740,7 @@ static int32_t mndDropTSMA(SCreateTSMACxt* pCxt) {
if (mndTransPrepare(pCxt->pMnode, pTrans) != 0) goto _OVER; if (mndTransPrepare(pCxt->pMnode, pTrans) != 0) goto _OVER;
code = TSDB_CODE_SUCCESS; code = TSDB_CODE_SUCCESS;
_OVER: _OVER:
tFreeMDropStreamReq(pCxt->pDropStreamReq);
mndTransDrop(pTrans); mndTransDrop(pTrans);
return code; return code;
} }
@ -1738,8 +1748,8 @@ _OVER:
static int32_t mndProcessDropTSMAReq(SRpcMsg* pReq) { static int32_t mndProcessDropTSMAReq(SRpcMsg* pReq) {
int32_t code = -1; int32_t code = -1;
SMDropSmaReq dropReq = {0}; SMDropSmaReq dropReq = {0};
SSmaObj * pSma; SSmaObj * pSma = NULL;
SDbObj * pDb; SDbObj * pDb = NULL;
SMnode * pMnode = pReq->info.node; SMnode * pMnode = pReq->info.node;
if (tDeserializeSMDropSmaReq(pReq->pCont, pReq->contLen, &dropReq) != TSDB_CODE_SUCCESS) { if (tDeserializeSMDropSmaReq(pReq->pCont, pReq->contLen, &dropReq) != TSDB_CODE_SUCCESS) {
terrno = TSDB_CODE_INVALID_MSG; terrno = TSDB_CODE_INVALID_MSG;
@ -1876,12 +1886,13 @@ static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo
FOREACH(pFunc, ((SSelectStmt *)pNode)->pProjectionList) { FOREACH(pFunc, ((SSelectStmt *)pNode)->pProjectionList) {
if (nodeType(pFunc) == QUERY_NODE_FUNCTION) { if (nodeType(pFunc) == QUERY_NODE_FUNCTION) {
SFunctionNode *pFuncNode = (SFunctionNode *)pFunc; SFunctionNode *pFuncNode = (SFunctionNode *)pFunc;
if (!fmIsAggFunc(pFuncNode->funcId)) continue; if (!fmIsTSMASupportedFunc(pFuncNode->funcId)) continue;
len += snprintf(start, TSDB_SHOW_SQL_LEN - len, "%s%s", start != buf + VARSTR_HEADER_SIZE ? "," : "", len += snprintf(start, TSDB_SHOW_SQL_LEN - len, "%s%s", start != buf + VARSTR_HEADER_SIZE ? "," : "",
((SExprNode *)pFunc)->userAlias); ((SExprNode *)pFunc)->userAlias);
start = buf + VARSTR_HEADER_SIZE + len; start = buf + VARSTR_HEADER_SIZE + len;
} }
} }
nodesDestroyNode(pNode);
} }
varDataSetLen(buf, len); varDataSetLen(buf, len);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
@ -1893,9 +1904,252 @@ static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo
} }
mndReleaseDb(pMnode, pDb); mndReleaseDb(pMnode, pDb);
pShow->numOfRows += numOfRows; pShow->numOfRows += numOfRows;
if (numOfRows < rows) pShow->pIter = NULL; if (numOfRows < rows) {
taosMemoryFree(pShow->pIter);
pShow->pIter = NULL;
}
return numOfRows; return numOfRows;
} }
static void mndCancelRetrieveTSMA(SMnode *pMnode, void *pIter) { static void mndCancelRetrieveTSMA(SMnode *pMnode, void *pIter) {
SSmaAndTagIter *p = pIter;
if (p != NULL) {
SSdb *pSdb = pMnode->pSdb;
sdbCancelFetch(pSdb, p->pSmaIter);
}
taosMemoryFree(p);
}
int32_t dumpTSMAInfoFromSmaObj(const SSmaObj* pSma, STableTSMAInfo* pInfo) {
int32_t code = 0;
pInfo->interval = pSma->interval;
pInfo->unit = pSma->intervalUnit;
pInfo->tsmaId = pSma->uid;
pInfo->version = pSma->version;
pInfo->tsmaId = pSma->uid;
SName sName = {0};
tNameFromString(&sName, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
tstrncpy(pInfo->name, sName.tname, TSDB_TABLE_NAME_LEN);
tstrncpy(pInfo->targetDbFName, pSma->db, TSDB_DB_FNAME_LEN);
tNameFromString(&sName, pSma->dstTbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
tstrncpy(pInfo->targetTb, sName.tname, TSDB_TABLE_NAME_LEN);
tstrncpy(pInfo->dbFName, pSma->db, TSDB_DB_FNAME_LEN);
tNameFromString(&sName, pSma->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
tstrncpy(pInfo->tb, sName.tname, TSDB_TABLE_NAME_LEN);
pInfo->pFuncs = taosArrayInit(8, sizeof(STableTSMAFuncInfo));
if (!pInfo->pFuncs) return TSDB_CODE_OUT_OF_MEMORY;
SNode *pNode, *pFunc;
if (TSDB_CODE_SUCCESS != nodesStringToNode(pSma->ast, &pNode)) {
taosArrayDestroy(pInfo->pFuncs);
pInfo->pFuncs = NULL;
return TSDB_CODE_TSMA_INVALID_STAT;
}
if (pNode) {
SSelectStmt *pSelect = (SSelectStmt *)pNode;
FOREACH(pFunc, pSelect->pProjectionList) {
STableTSMAFuncInfo funcInfo = {0};
SFunctionNode * pFuncNode = (SFunctionNode *)pFunc;
if (!fmIsTSMASupportedFunc(pFuncNode->funcId)) continue;
funcInfo.funcId = pFuncNode->funcId;
funcInfo.colId = ((SColumnNode *)pFuncNode->pParameterList->pHead->pNode)->colId;
if (!taosArrayPush(pInfo->pFuncs, &funcInfo)) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
taosArrayDestroy(pInfo->pFuncs);
nodesDestroyNode(pNode);
return code;
}
}
nodesDestroyNode(pNode);
}
return code;
}
static int32_t mndGetTableTSMA(SMnode *pMnode, char *tbFName, STableTSMAInfoRsp *rsp, bool *exist) {
int32_t code = -1;
SSmaObj * pSma = NULL;
SSdb * pSdb = pMnode->pSdb;
void * pIter = NULL;
SStbObj *pStb = mndAcquireStb(pMnode, tbFName);
if (NULL == pStb) {
*exist = false;
return TSDB_CODE_SUCCESS;
}
mndReleaseStb(pMnode, pStb);
while (1) {
pIter = sdbFetch(pSdb, SDB_SMA, pIter, (void **)&pSma);
if (pIter == NULL) break;
if (pSma->stb[0] != tbFName[0] || strcmp(pSma->stb, tbFName)) {
continue;
}
STableTSMAInfo *pTsma = taosMemoryCalloc(1, sizeof(STableTSMAInfo));
if (!pTsma) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
sdbRelease(pSdb, pSma);
return code;
}
terrno = dumpTSMAInfoFromSmaObj(pSma, pTsma);
if (terrno) {
sdbRelease(pSdb, pSma);
return code;
}
if (NULL == taosArrayPush(rsp->pTsmas, &pTsma)) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
tFreeTableTSMAInfo(pTsma);
sdbRelease(pSdb, pSma);
return code;
}
*exist = true;
sdbRelease(pSdb, pSma);
}
return TSDB_CODE_SUCCESS;
}
static int32_t mndProcessGetTbTSMAReq(SRpcMsg *pReq) {
STableTSMAInfoRsp rsp = {0};
int32_t code = -1;
STableTSMAInfoReq tsmaReq = {0};
bool exist = false;
SMnode * pMnode = pReq->info.node;
if (tDeserializeTableTSMAInfoReq(pReq->pCont, pReq->contLen, &tsmaReq) != 0) {
terrno = TSDB_CODE_INVALID_MSG;
goto _OVER;
}
rsp.pTsmas = taosArrayInit(4, POINTER_BYTES);
if (NULL == rsp.pTsmas) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
code = -1;
goto _OVER;
}
code = mndGetTableTSMA(pMnode, tsmaReq.name, &rsp, &exist);
if (code) {
goto _OVER;
}
if (!exist) {
code = -1;
terrno = TSDB_CODE_MND_SMA_NOT_EXIST;
} else {
int32_t contLen = tSerializeTableTSMAInfoRsp(NULL, 0, &rsp);
void *pRsp = rpcMallocCont(contLen);
if (pRsp == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
code = -1;
goto _OVER;
}
tSerializeTableTSMAInfoRsp(pRsp, contLen, &rsp);
pReq->info.rsp = pRsp;
pReq->info.rspLen = contLen;
code = 0;
}
_OVER:
if (code != 0) {
mError("failed to get table tsma %s since %s", tsmaReq.name, terrstr());
}
tFreeTableTSMAInfoRsp(&rsp);
return code;
}
static int32_t mkNonExistTSMAInfo(const STSMAVersion *pTsmaVer, STableTSMAInfo **ppTsma) {
STableTSMAInfo *pInfo = taosMemoryCalloc(1, sizeof(STableTSMAInfo));
if (!pInfo) {
return TSDB_CODE_OUT_OF_MEMORY;
}
pInfo->pFuncs = NULL;
pInfo->tsmaId = pTsmaVer->tsmaId;
tstrncpy(pInfo->dbFName, pTsmaVer->dbFName, TSDB_DB_FNAME_LEN);
tstrncpy(pInfo->tb, pTsmaVer->tbName, TSDB_TABLE_NAME_LEN);
tstrncpy(pInfo->name, pTsmaVer->name, TSDB_TABLE_NAME_LEN);
pInfo->dbId = pTsmaVer->dbId;
*ppTsma = pInfo;
return TSDB_CODE_SUCCESS;
}
int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t numOfTsmas, void **ppRsp,
int32_t *pRspLen) {
int32_t code = -1;
STSMAHbRsp hbRsp = {0};
int32_t rspLen = 0;
void * pRsp = NULL;
char tsmaFName[TSDB_TABLE_FNAME_LEN] = {0};
STableTSMAInfo * pTsmaInfo = NULL;
hbRsp.pTsmas = taosArrayInit(numOfTsmas, POINTER_BYTES);
if (!hbRsp.pTsmas) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return -1;
}
for (int32_t i = 0; i < numOfTsmas; ++i) {
STSMAVersion* pTsmaVer = &pTsmaVersions[i];
pTsmaVer->dbId = be64toh(pTsmaVer->dbId);
pTsmaVer->tsmaId = be64toh(pTsmaVer->tsmaId);
pTsmaVer->version = ntohl(pTsmaVer->version);
snprintf(tsmaFName, sizeof(tsmaFName), "%s.%s", pTsmaVer->dbFName, pTsmaVer->name);
SSmaObj* pSma = mndAcquireSma(pMnode, tsmaFName);
if (!pSma) {
terrno = mkNonExistTSMAInfo(pTsmaVer, &pTsmaInfo);
if (terrno) goto _OVER;
taosArrayPush(hbRsp.pTsmas, &pTsmaInfo);
continue;
}
if (pSma->uid != pTsmaVer->tsmaId) {
mDebug("tsma: %s.%" PRIx64 " tsmaId mismatch with current %" PRIx64, tsmaFName, pTsmaVer->tsmaId, pSma->uid);
terrno = mkNonExistTSMAInfo(pTsmaVer, &pTsmaInfo);
if (terrno) goto _OVER;
taosArrayPush(hbRsp.pTsmas, &pTsmaInfo);
continue;
} else if (pSma->version == pTsmaVer->version) {
mndReleaseSma(pMnode, pSma);
continue;
}
// dump smaObj into rsp
STableTSMAInfo * pInfo = NULL;
pInfo = taosMemoryCalloc(1, sizeof(STableTSMAInfo));
if (!pInfo || (terrno = dumpTSMAInfoFromSmaObj(pSma, pInfo))) {
mndReleaseSma(pMnode, pSma);
taosMemoryFreeClear(pInfo);
goto _OVER;
}
taosArrayPush(hbRsp.pTsmas, pInfo);
mndReleaseSma(pMnode, pSma);
}
rspLen = tSerializeTSMAHbRsp(NULL, 0, &hbRsp);
if (rspLen < 0) {
terrno = TSDB_CODE_INVALID_MSG;
goto _OVER;
}
pRsp = taosMemoryMalloc(rspLen);
if (!pRsp) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
rspLen = 0;
goto _OVER;
}
tSerializeTSMAHbRsp(pRsp, rspLen, &hbRsp);
code = 0;
_OVER:
tFreeTSMAHbRsp(&hbRsp);
*ppRsp = pRsp;
*pRspLen = rspLen;
return code;
} }

61
source/libs/catalog/inc/catalogInt.h
View File

@ -31,6 +31,7 @@ extern "C" {
#define CTG_DEFAULT_CACHE_DB_NUMBER 20 #define CTG_DEFAULT_CACHE_DB_NUMBER 20
#define CTG_DEFAULT_CACHE_TBLMETA_NUMBER 1000 #define CTG_DEFAULT_CACHE_TBLMETA_NUMBER 1000
#define CTG_DEFAULT_CACHE_VIEW_NUMBER 256 #define CTG_DEFAULT_CACHE_VIEW_NUMBER 256
#define CTG_DEFAULT_CACHE_TSMA_NUMBER 10
#define CTG_DEFAULT_RENT_SECOND 10 #define CTG_DEFAULT_RENT_SECOND 10
#define CTG_DEFAULT_RENT_SLOT_SIZE 10 #define CTG_DEFAULT_RENT_SLOT_SIZE 10
#define CTG_DEFAULT_MAX_RETRY_TIMES 3 #define CTG_DEFAULT_MAX_RETRY_TIMES 3
@ -69,6 +70,7 @@ typedef enum {
CTG_CI_UDF, CTG_CI_UDF,
CTG_CI_SVR_VER, CTG_CI_SVR_VER,
CTG_CI_VIEW, CTG_CI_VIEW,
CTG_CI_TBL_TSMA,
CTG_CI_MAX_VALUE, CTG_CI_MAX_VALUE,
} CTG_CACHE_ITEM; } CTG_CACHE_ITEM;
@ -85,6 +87,7 @@ enum {
CTG_RENT_DB = 1, CTG_RENT_DB = 1,
CTG_RENT_STABLE, CTG_RENT_STABLE,
CTG_RENT_VIEW, CTG_RENT_VIEW,
CTG_RENT_TSMA,
}; };
enum { enum {
@ -101,6 +104,8 @@ enum {
CTG_OP_DROP_TB_INDEX, CTG_OP_DROP_TB_INDEX,
CTG_OP_UPDATE_VIEW_META, CTG_OP_UPDATE_VIEW_META,
CTG_OP_DROP_VIEW_META, CTG_OP_DROP_VIEW_META,
CTG_OP_UPDATE_TB_TSMA,
CTG_OP_DROP_TB_TSMA,
CTG_OP_CLEAR_CACHE, CTG_OP_CLEAR_CACHE,
CTG_OP_MAX CTG_OP_MAX
}; };
@ -123,6 +128,7 @@ typedef enum {
CTG_TASK_GET_TB_HASH_BATCH, CTG_TASK_GET_TB_HASH_BATCH,
CTG_TASK_GET_TB_TAG, CTG_TASK_GET_TB_TAG,
CTG_TASK_GET_VIEW, CTG_TASK_GET_VIEW,
CTG_TASK_GET_TB_TSMA,
} CTG_TASK_TYPE; } CTG_TASK_TYPE;
typedef enum { typedef enum {
@ -255,14 +261,22 @@ typedef struct SCtgViewsCtx {
SArray* pFetchs; SArray* pFetchs;
} SCtgViewsCtx; } SCtgViewsCtx;
typedef struct SCtgTbTSMACtx {
int32_t fetchNum;
SArray* pNames;
SArray* pResList;
SArray* pFetches;
} SCtgTbTSMACtx;
typedef STableIndexRsp STableIndex; typedef STableIndexRsp STableIndex;
typedef STableTSMAInfo STSMACache;
typedef struct SCtgTbCache { typedef struct SCtgTbCache {
SRWLatch metaLock; SRWLatch metaLock;
SRWLatch indexLock; SRWLatch indexLock;
STableMeta* pMeta; SRWLatch tsmaLock;
STableIndex* pIndex; STableMeta* pMeta;
STableIndex* pIndex;
} SCtgTbCache; } SCtgTbCache;
typedef struct SCtgVgCache { typedef struct SCtgVgCache {
@ -280,6 +294,10 @@ typedef struct SCtgViewCache {
SViewMeta* pMeta; SViewMeta* pMeta;
} SCtgViewCache; } SCtgViewCache;
typedef struct SCtgTSMACache {
SRWLatch tsmaLock;
SArray* pTsmas; // SArray<STSMACache*>
} SCtgTSMACache;
typedef struct SCtgDBCache { typedef struct SCtgDBCache {
SRWLatch dbLock; // RC between destroy tbCache/stbCache and all reads SRWLatch dbLock; // RC between destroy tbCache/stbCache and all reads
@ -290,6 +308,7 @@ typedef struct SCtgDBCache {
SHashObj* viewCache; // key:viewname, value:SCtgViewCache SHashObj* viewCache; // key:viewname, value:SCtgViewCache
SHashObj* tbCache; // key:tbname, value:SCtgTbCache SHashObj* tbCache; // key:tbname, value:SCtgTbCache
SHashObj* stbCache; // key:suid, value:char* SHashObj* stbCache; // key:suid, value:char*
SHashObj* tsmaCache; // key:tbname, value: SCtgTSMACache
uint64_t dbCacheNum[CTG_CI_MAX_VALUE]; uint64_t dbCacheNum[CTG_CI_MAX_VALUE];
uint64_t dbCacheSize; uint64_t dbCacheSize;
} SCtgDBCache; } SCtgDBCache;
@ -325,6 +344,7 @@ typedef struct SCatalog {
SCtgRentMgmt dbRent; SCtgRentMgmt dbRent;
SCtgRentMgmt stbRent; SCtgRentMgmt stbRent;
SCtgRentMgmt viewRent; SCtgRentMgmt viewRent;
SCtgRentMgmt tsmaRent;
SCtgCacheStat cacheStat; SCtgCacheStat cacheStat;
} SCatalog; } SCatalog;
@ -370,6 +390,7 @@ typedef struct SCtgJob {
int32_t tbCfgNum; int32_t tbCfgNum;
int32_t svrVerNum; int32_t svrVerNum;
int32_t viewNum; int32_t viewNum;
int32_t tbTsmaNum;
} SCtgJob; } SCtgJob;
typedef struct SCtgMsgCtx { typedef struct SCtgMsgCtx {
@ -548,6 +569,21 @@ typedef struct SCtgDropViewMetaMsg {
uint64_t viewId; uint64_t viewId;
} SCtgDropViewMetaMsg; } SCtgDropViewMetaMsg;
typedef struct SCtgUpdateTbTSMAMsg {
SCatalog* pCtg;
STableTSMAInfo* pTsma;
} SCtgUpdateTbTSMAMsg;
typedef struct SCtgDropTbTSMAMsg {
SCatalog* pCtg;
char dbFName[TSDB_DB_FNAME_LEN];
char tbName[TSDB_TABLE_NAME_LEN];
char tsmaName[TSDB_TABLE_NAME_LEN];
uint64_t tsmaId;
uint64_t dbId;
uint64_t tbId;
} SCtgDropTbTSMAMsg;
typedef struct SCtgCacheOperation { typedef struct SCtgCacheOperation {
int32_t opId; int32_t opId;
@ -943,10 +979,12 @@ int32_t ctgMetaRentGet(SCtgRentMgmt* mgmt, void** res, uint32_t* num, int32_t si
int32_t ctgMetaRentRemove(SCtgRentMgmt *mgmt, int64_t id, __compar_fn_t sortCompare, __compar_fn_t searchCompare); int32_t ctgMetaRentRemove(SCtgRentMgmt *mgmt, int64_t id, __compar_fn_t sortCompare, __compar_fn_t searchCompare);
void ctgRemoveStbRent(SCatalog *pCtg, SCtgDBCache *dbCache); void ctgRemoveStbRent(SCatalog *pCtg, SCtgDBCache *dbCache);
void ctgRemoveViewRent(SCatalog *pCtg, SCtgDBCache *dbCache); void ctgRemoveViewRent(SCatalog *pCtg, SCtgDBCache *dbCache);
void ctgRemoveTSMARent(SCatalog* pCtg, SCtgDBCache* dbCache);
int32_t ctgUpdateRentStbVersion(SCatalog *pCtg, char *dbFName, char *tbName, uint64_t dbId, uint64_t suid, int32_t ctgUpdateRentStbVersion(SCatalog *pCtg, char *dbFName, char *tbName, uint64_t dbId, uint64_t suid,
SCtgTbCache *pCache); SCtgTbCache *pCache);
int32_t ctgUpdateRentViewVersion(SCatalog *pCtg, char *dbFName, char *viewName, uint64_t dbId, uint64_t viewId, int32_t ctgUpdateRentViewVersion(SCatalog *pCtg, char *dbFName, char *viewName, uint64_t dbId, uint64_t viewId,
SCtgViewCache *pCache); SCtgViewCache *pCache);
int32_t ctgUpdateRentTSMAVersion(SCatalog* pCtg, char* dbFName, const STSMACache* pCache);
int32_t ctgUpdateTbMetaToCache(SCatalog* pCtg, STableMetaOutput* pOut, bool syncReq); int32_t ctgUpdateTbMetaToCache(SCatalog* pCtg, STableMetaOutput* pOut, bool syncReq);
int32_t ctgUpdateViewMetaToCache(SCatalog *pCtg, SViewMetaRsp *pRsp, bool syncReq); int32_t ctgUpdateViewMetaToCache(SCatalog *pCtg, SViewMetaRsp *pRsp, bool syncReq);
int32_t ctgStartUpdateThread(); int32_t ctgStartUpdateThread();
@ -1018,9 +1056,11 @@ void ctgFreeDbCache(SCtgDBCache* dbCache);
int32_t ctgStbVersionSortCompare(const void* key1, const void* key2); int32_t ctgStbVersionSortCompare(const void* key1, const void* key2);
int32_t ctgViewVersionSortCompare(const void* key1, const void* key2); int32_t ctgViewVersionSortCompare(const void* key1, const void* key2);
int32_t ctgDbCacheInfoSortCompare(const void* key1, const void* key2); int32_t ctgDbCacheInfoSortCompare(const void* key1, const void* key2);
int32_t ctgTSMAVersionSortCompare(const void* key1, const void* key2);
int32_t ctgStbVersionSearchCompare(const void* key1, const void* key2); int32_t ctgStbVersionSearchCompare(const void* key1, const void* key2);
int32_t ctgDbCacheInfoSearchCompare(const void* key1, const void* key2); int32_t ctgDbCacheInfoSearchCompare(const void* key1, const void* key2);
int32_t ctgViewVersionSearchCompare(const void* key1, const void* key2); int32_t ctgViewVersionSearchCompare(const void* key1, const void* key2);
int32_t ctgTSMAVersionSearchCompare(const void* key1, const void* key2);
void ctgFreeSTableMetaOutput(STableMetaOutput* pOutput); void ctgFreeSTableMetaOutput(STableMetaOutput* pOutput);
int32_t ctgUpdateMsgCtx(SCtgMsgCtx* pCtx, int32_t reqType, void* out, char* target); int32_t ctgUpdateMsgCtx(SCtgMsgCtx* pCtx, int32_t reqType, void* out, char* target);
int32_t ctgAddMsgCtx(SArray* pCtxs, int32_t reqType, void* out, char* target); int32_t ctgAddMsgCtx(SArray* pCtxs, int32_t reqType, void* out, char* target);
@ -1073,6 +1113,19 @@ int32_t ctgGetCachedStbNameFromSuid(SCatalog* pCtg, char* dbFName, uint64_t suid
int32_t ctgGetTbTagCb(SCtgTask* pTask); int32_t ctgGetTbTagCb(SCtgTask* pTask);
int32_t ctgGetUserCb(SCtgTask* pTask); int32_t ctgGetUserCb(SCtgTask* pTask);
int32_t ctgGetTbTSMAFromCache(SCatalog* pCtg, SCtgTbTSMACtx* pCtx, int32_t dbIdx, int32_t* fetchIdx, int32_t baseResIdx,
SArray* pList);
int32_t ctgGetTbTSMAFromMnode(SCatalog* pCtg, SRequestConnInfo* pConn, SName* name, STableTSMAInfoRsp* out,
SCtgTaskReq* tReq);
int32_t ctgUpdateTbTSMAEnqueue(SCatalog* pCtg, STSMACache** pTsma, bool syncOp);
int32_t ctgDropTSMAForTbEnqueue(SCatalog* pCtg, SName* pName, bool syncOp);
int32_t ctgDropTbTSMAEnqueue(SCatalog* pCtg, const STSMACache* pTsma, bool syncOp);
int32_t ctgCloneTbTSMA(STSMACache* pTsmas, STSMACache** pRes);
int32_t ctgOpDropTbTSMA(SCtgCacheOperation* operation);
int32_t ctgOpUpdateTbTSMA(SCtgCacheOperation* operation);
uint64_t ctgGetTbTSMACacheSize(STSMACache* pTsmaInfo);
void ctgFreeTbTSMAInfo(void* p);
extern SCatalogMgmt gCtgMgmt; extern SCatalogMgmt gCtgMgmt;
extern SCtgDebug gCTGDebug; extern SCtgDebug gCTGDebug;
extern SCtgAsyncFps gCtgAsyncFps[]; extern SCtgAsyncFps gCtgAsyncFps[];

61
source/libs/catalog/src/catalog.c
View File

@ -759,6 +759,10 @@ int32_t catalogInit(SCatalogCfg* cfg) {
gCtgMgmt.cfg.maxViewCacheNum = CTG_DEFAULT_CACHE_VIEW_NUMBER; gCtgMgmt.cfg.maxViewCacheNum = CTG_DEFAULT_CACHE_VIEW_NUMBER;
} }
if (gCtgMgmt.cfg.maxTSMACacheNum == 0) {
gCtgMgmt.cfg.maxTSMACacheNum = CTG_DEFAULT_CACHE_TSMA_NUMBER;
}
if (gCtgMgmt.cfg.dbRentSec == 0) { if (gCtgMgmt.cfg.dbRentSec == 0) {
gCtgMgmt.cfg.dbRentSec = CTG_DEFAULT_RENT_SECOND; gCtgMgmt.cfg.dbRentSec = CTG_DEFAULT_RENT_SECOND;
} }
@ -770,13 +774,19 @@ int32_t catalogInit(SCatalogCfg* cfg) {
if (gCtgMgmt.cfg.viewRentSec == 0) { if (gCtgMgmt.cfg.viewRentSec == 0) {
gCtgMgmt.cfg.viewRentSec = CTG_DEFAULT_RENT_SECOND; gCtgMgmt.cfg.viewRentSec = CTG_DEFAULT_RENT_SECOND;
} }
if (gCtgMgmt.cfg.tsmaRentSec == 0) {
gCtgMgmt.cfg.tsmaRentSec = CTG_DEFAULT_RENT_SECOND;
}
} else { } else {
gCtgMgmt.cfg.maxDBCacheNum = CTG_DEFAULT_CACHE_DB_NUMBER; gCtgMgmt.cfg.maxDBCacheNum = CTG_DEFAULT_CACHE_DB_NUMBER;
gCtgMgmt.cfg.maxTblCacheNum = CTG_DEFAULT_CACHE_TBLMETA_NUMBER; gCtgMgmt.cfg.maxTblCacheNum = CTG_DEFAULT_CACHE_TBLMETA_NUMBER;
gCtgMgmt.cfg.maxViewCacheNum = CTG_DEFAULT_CACHE_VIEW_NUMBER; gCtgMgmt.cfg.maxViewCacheNum = CTG_DEFAULT_CACHE_VIEW_NUMBER;
gCtgMgmt.cfg.maxTSMACacheNum = CTG_DEFAULT_CACHE_TSMA_NUMBER;
gCtgMgmt.cfg.dbRentSec = CTG_DEFAULT_RENT_SECOND; gCtgMgmt.cfg.dbRentSec = CTG_DEFAULT_RENT_SECOND;
gCtgMgmt.cfg.stbRentSec = CTG_DEFAULT_RENT_SECOND; gCtgMgmt.cfg.stbRentSec = CTG_DEFAULT_RENT_SECOND;
gCtgMgmt.cfg.viewRentSec = CTG_DEFAULT_RENT_SECOND; gCtgMgmt.cfg.viewRentSec = CTG_DEFAULT_RENT_SECOND;
gCtgMgmt.cfg.tsmaRentSec = CTG_DEFAULT_RENT_SECOND;
} }
gCtgMgmt.pCluster = taosHashInit(CTG_DEFAULT_CACHE_CLUSTER_NUMBER, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), gCtgMgmt.pCluster = taosHashInit(CTG_DEFAULT_CACHE_CLUSTER_NUMBER, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT),
@ -862,6 +872,7 @@ int32_t catalogGetHandle(uint64_t clusterId, SCatalog** catalogHandle) {
CTG_ERR_JRET(ctgMetaRentInit(&clusterCtg->dbRent, gCtgMgmt.cfg.dbRentSec, CTG_RENT_DB, sizeof(SDbCacheInfo))); CTG_ERR_JRET(ctgMetaRentInit(&clusterCtg->dbRent, gCtgMgmt.cfg.dbRentSec, CTG_RENT_DB, sizeof(SDbCacheInfo)));
CTG_ERR_JRET(ctgMetaRentInit(&clusterCtg->stbRent, gCtgMgmt.cfg.stbRentSec, CTG_RENT_STABLE, sizeof(SSTableVersion))); CTG_ERR_JRET(ctgMetaRentInit(&clusterCtg->stbRent, gCtgMgmt.cfg.stbRentSec, CTG_RENT_STABLE, sizeof(SSTableVersion)));
CTG_ERR_JRET(ctgMetaRentInit(&clusterCtg->viewRent, gCtgMgmt.cfg.viewRentSec, CTG_RENT_VIEW, sizeof(SViewVersion))); CTG_ERR_JRET(ctgMetaRentInit(&clusterCtg->viewRent, gCtgMgmt.cfg.viewRentSec, CTG_RENT_VIEW, sizeof(SViewVersion)));
CTG_ERR_JRET(ctgMetaRentInit(&clusterCtg->tsmaRent, gCtgMgmt.cfg.tsmaRentSec, CTG_RENT_TSMA, sizeof(STSMAVersion)));
clusterCtg->dbCache = taosHashInit(gCtgMgmt.cfg.maxDBCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), clusterCtg->dbCache = taosHashInit(gCtgMgmt.cfg.maxDBCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY),
false, HASH_ENTRY_LOCK); false, HASH_ENTRY_LOCK);
@ -1562,6 +1573,16 @@ int32_t catalogGetExpiredUsers(SCatalog* pCtg, SUserAuthVersion** users, uint32_
CTG_API_LEAVE(TSDB_CODE_SUCCESS); CTG_API_LEAVE(TSDB_CODE_SUCCESS);
} }
int32_t catalogGetExpiredTsmas(SCatalog* pCtg, STSMAVersion** tsmas, uint32_t* num) {
CTG_API_ENTER();
if (!pCtg || !tsmas || !num) {
CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
}
CTG_API_LEAVE(ctgMetaRentGet(&pCtg->tsmaRent, (void**)tsmas, num, sizeof(STSMAVersion)));
}
int32_t catalogGetDBCfg(SCatalog* pCtg, SRequestConnInfo* pConn, const char* dbFName, SDbCfgInfo* pDbCfg) { int32_t catalogGetDBCfg(SCatalog* pCtg, SRequestConnInfo* pConn, const char* dbFName, SDbCfgInfo* pDbCfg) {
CTG_API_ENTER(); CTG_API_ENTER();
@ -1769,6 +1790,46 @@ int32_t catalogGetViewMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const SName*
CTG_API_LEAVE(TSDB_CODE_OPS_NOT_SUPPORT); CTG_API_LEAVE(TSDB_CODE_OPS_NOT_SUPPORT);
} }
int32_t catalogAsyncUpdateTSMA(SCatalog* pCtg, STableTSMAInfo** ppTsma) {
CTG_API_ENTER();
if (!pCtg || !ppTsma) {
CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
}
int32_t code = 0;
CTG_ERR_JRET(ctgUpdateTbTSMAEnqueue(pCtg, ppTsma, false));
_return:
CTG_API_LEAVE(code);
}
int32_t catalogUpdateTSMA(SCatalog* pCtg, STableTSMAInfo** pTsma) {
CTG_API_ENTER();
if (!pCtg || !pTsma) {
CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
}
int32_t code = 0;
CTG_ERR_JRET(ctgUpdateTbTSMAEnqueue(pCtg, pTsma, true));
_return:
CTG_API_LEAVE(code);
}
int32_t catalogRemoveTSMA(SCatalog* pCtg, const STableTSMAInfo* pTsma) {
CTG_API_ENTER();
int32_t code = 0;
if (!pCtg || !pTsma) {
CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
}
if (!pCtg->dbCache) {
return TSDB_CODE_SUCCESS;
}
CTG_ERR_JRET(ctgDropTbTSMAEnqueue(pCtg, pTsma, true));
_return:
CTG_API_LEAVE(code);
}
int32_t catalogClearCache(void) { int32_t catalogClearCache(void) {
CTG_API_ENTER_NOLOCK(); CTG_API_ENTER_NOLOCK();

136
source/libs/catalog/src/ctgAsync.c
View File

@ -476,6 +476,21 @@ int32_t ctgHandleForceUpdateView(SCatalog* pCtg, const SCatalogReq* pReq) {
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t ctgInitGetTbTSMATask(SCtgJob* pJob, int32_t taskId, void* param) {
SCtgTask task = {0};
task.type = CTG_TASK_GET_TB_TSMA;
task.taskId = taskId;
task.pJob = pJob;
SCtgTbTSMACtx* pTaskCtx = taosMemoryCalloc(1, sizeof(SCtgTbTSMACtx));
if (!pTaskCtx) CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
task.taskCtx = pTaskCtx;
pTaskCtx->pNames = param;
pTaskCtx->pResList = taosArrayInit(pJob->tbTsmaNum, sizeof(SMetaRes));
taosArrayPush(pJob->pTasks, &task);
return TSDB_CODE_SUCCESS;
}
int32_t ctgHandleForceUpdate(SCatalog* pCtg, int32_t taskNum, SCtgJob* pJob, const SCatalogReq* pReq) { int32_t ctgHandleForceUpdate(SCatalog* pCtg, int32_t taskNum, SCtgJob* pJob, const SCatalogReq* pReq) {
SHashObj* pDb = taosHashInit(taskNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK); SHashObj* pDb = taosHashInit(taskNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
@ -573,6 +588,11 @@ int32_t ctgHandleForceUpdate(SCatalog* pCtg, int32_t taskNum, SCtgJob* pJob, con
ctgDropTbIndexEnqueue(pCtg, name, true); ctgDropTbIndexEnqueue(pCtg, name, true);
} }
for (int32_t i = 0; i < pJob->tbTsmaNum; ++i) {
SName* name = taosArrayGet(pReq->pTableTSMAs, i);
ctgDropTSMAForTbEnqueue(pCtg, name, true);
}
// REFRESH VIEW META // REFRESH VIEW META
return ctgHandleForceUpdateView(pCtg, pReq); return ctgHandleForceUpdateView(pCtg, pReq);
} }
@ -614,9 +634,10 @@ int32_t ctgInitJob(SCatalog* pCtg, SRequestConnInfo* pConn, SCtgJob** job, const
int32_t tbCfgNum = (int32_t)taosArrayGetSize(pReq->pTableCfg); int32_t tbCfgNum = (int32_t)taosArrayGetSize(pReq->pTableCfg);
int32_t tbTagNum = (int32_t)taosArrayGetSize(pReq->pTableTag); int32_t tbTagNum = (int32_t)taosArrayGetSize(pReq->pTableTag);
int32_t viewNum = (int32_t)ctgGetTablesReqNum(pReq->pView); int32_t viewNum = (int32_t)ctgGetTablesReqNum(pReq->pView);
int32_t tbTsmaNum = (int32_t)taosArrayGetSize(pReq->pTableTSMAs);
int32_t taskNum = tbMetaNum + dbVgNum + udfNum + tbHashNum + qnodeNum + dnodeNum + svrVerNum + dbCfgNum + indexNum + int32_t taskNum = tbMetaNum + dbVgNum + udfNum + tbHashNum + qnodeNum + dnodeNum + svrVerNum + dbCfgNum + indexNum +
userNum + dbInfoNum + tbIndexNum + tbCfgNum + tbTagNum + viewNum; userNum + dbInfoNum + tbIndexNum + tbCfgNum + tbTagNum + viewNum + tbTsmaNum;
*job = taosMemoryCalloc(1, sizeof(SCtgJob)); *job = taosMemoryCalloc(1, sizeof(SCtgJob));
if (NULL == *job) { if (NULL == *job) {
@ -649,6 +670,7 @@ int32_t ctgInitJob(SCatalog* pCtg, SRequestConnInfo* pConn, SCtgJob** job, const
pJob->svrVerNum = svrVerNum; pJob->svrVerNum = svrVerNum;
pJob->tbTagNum = tbTagNum; pJob->tbTagNum = tbTagNum;
pJob->viewNum = viewNum; pJob->viewNum = viewNum;
pJob->tbTsmaNum = tbTsmaNum;
#if CTG_BATCH_FETCH #if CTG_BATCH_FETCH
pJob->pBatchs = pJob->pBatchs =
@ -741,6 +763,10 @@ int32_t ctgInitJob(SCatalog* pCtg, SRequestConnInfo* pConn, SCtgJob** job, const
CTG_ERR_JRET(ctgInitTask(pJob, CTG_TASK_GET_VIEW, pReq->pView, NULL)); CTG_ERR_JRET(ctgInitTask(pJob, CTG_TASK_GET_VIEW, pReq->pView, NULL));
} }
if (tbTsmaNum > 0) {
CTG_ERR_JRET(ctgInitTask(pJob, CTG_TASK_GET_TB_TSMA, pReq->pTableTSMAs, NULL));
}
if (qnodeNum) { if (qnodeNum) {
CTG_ERR_JRET(ctgInitTask(pJob, CTG_TASK_GET_QNODE, NULL, NULL)); CTG_ERR_JRET(ctgInitTask(pJob, CTG_TASK_GET_QNODE, NULL, NULL));
} }
@ -2574,6 +2600,113 @@ int32_t ctgLaunchGetViewsTask(SCtgTask* pTask) {
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t ctgLaunchGetTbTSMATask(SCtgTask* pTask) {
SCatalog* pCtg = pTask->pJob->pCtg;
SCtgTbTSMACtx* pCtx = (SCtgTbTSMACtx*)pTask->taskCtx;
SRequestConnInfo* pConn = &pTask->pJob->conn;
SArray* pRes = NULL;
SCtgJob* pJob = pTask->pJob;
int32_t dbNum = taosArrayGetSize(pCtx->pNames);
int32_t fetchIdx = 0, baseResIdx = 0;
for (int32_t idx = 0; idx < dbNum; ++idx) {
STablesReq* pReq = taosArrayGet(pCtx->pNames, idx);
ctgGetTbTSMAFromCache(pCtg, pCtx, idx, &fetchIdx, baseResIdx, pReq->pTables);
baseResIdx += taosArrayGetSize(pReq->pTables);
}
pCtx->fetchNum = taosArrayGetSize(pCtx->pFetches);
if (pCtx->fetchNum <= 0) {
TSWAP(pTask->res, pCtx->pResList);
CTG_ERR_RET(ctgHandleTaskEnd(pTask, 0));
return TSDB_CODE_SUCCESS;
}
pTask->msgCtxs = taosArrayInit_s(sizeof(SCtgMsgCtx), pCtx->fetchNum);
for (int32_t i = 0; i < pCtx->fetchNum; ++i) {
SCtgFetch* pFetch = taosArrayGet(pCtx->pFetches, i);
SName* pName = ctgGetFetchName(pCtx->pNames, pFetch);
SCtgMsgCtx* pMsgCtx = CTG_GET_TASK_MSGCTX(pTask, i);
if (!pMsgCtx->pBatchs) pMsgCtx->pBatchs = pJob->pBatchs;
SCtgTaskReq tReq;
tReq.pTask = pTask;
tReq.msgIdx = pFetch->fetchIdx;
CTG_ERR_RET(ctgGetTbTSMAFromMnode(pCtg, pConn, pName, NULL, &tReq));
}
return TSDB_CODE_SUCCESS;
}
int32_t ctgHandleGetTbTSMARsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf* pMsg, int32_t rspCode) {
int32_t code = 0;
SCtgTask* pTask = tReq->pTask;
SCatalog* pCtg = pTask->pJob->pCtg;
SCtgMsgCtx* pMsgCtx = CTG_GET_TASK_MSGCTX(pTask, tReq->msgIdx);
SCtgTbTSMACtx* pCtx = pTask->taskCtx;
SCtgFetch* pFetch = taosArrayGet(pCtx->pFetches, tReq->msgIdx);
SMetaRes* pRes = taosArrayGet(pCtx->pResList, pFetch->resIdx);
SName* pName = ctgGetFetchName(pCtx->pNames, pFetch);
SArray* pTsmas = NULL;
bool taskDone = false;
STableTSMAInfo* pTsma = NULL;
CTG_ERR_JRET(ctgProcessRspMsg(pMsgCtx->out, reqType, pMsg->pData, pMsg->len, rspCode, pMsgCtx->target));
STableTSMAInfoRsp* pOut = pMsgCtx->out;
if (pOut->pTsmas && taosArrayGetSize(pOut->pTsmas) > 0) {
for (int32_t i = 0; i < taosArrayGetSize(pOut->pTsmas); ++i) {
STableTSMAInfo* pInfo = taosArrayGetP(pOut->pTsmas, i);
CTG_ERR_JRET(ctgCloneTbTSMA(pInfo, &pTsma));
CTG_ERR_JRET(ctgUpdateTbTSMAEnqueue(pTask->pJob->pCtg, &pTsma, false));
}
}
pRes->code = 0;
pRes->pRes = pOut;
pMsgCtx->out = NULL;
if (atomic_sub_fetch_32(&pCtx->fetchNum, 1) == 0) {
TSWAP(pTask->res, pCtx->pResList);
taskDone = true;
}
_return:
if (pTsma) {
tFreeTableTSMAInfo(pTsma);
pTsma = NULL;
}
if (code) {
SMetaRes* pRes = taosArrayGet(pCtx->pResList, pFetch->resIdx);
pRes->code = code;
pRes->pRes = NULL;
if (TSDB_CODE_MND_SMA_NOT_EXIST == code) {
code = TSDB_CODE_SUCCESS;
} else {
ctgTaskError("Get tsma for %d.%s.%s faield with err: %s", pName->acctId, pName->dbname, pName->tname,
tstrerror(code));
}
if (0 == atomic_sub_fetch_32(&pCtx->fetchNum, 1)) {
TSWAP(pTask->res, pCtx->pResList);
taskDone = true;
}
}
if (pTask->res && taskDone) {
ctgHandleTaskEnd(pTask, code);
}
CTG_RET(code);
}
int32_t ctgDumpTbTSMARes(SCtgTask* pTask) {
if (pTask->subTask) {
return TSDB_CODE_SUCCESS;
}
SCtgJob* pJob = pTask->pJob;
pJob->jobRes.pTableTsmas = pTask->res;
return TSDB_CODE_SUCCESS;
}
int32_t ctgRelaunchGetTbMetaTask(SCtgTask* pTask) { int32_t ctgRelaunchGetTbMetaTask(SCtgTask* pTask) {
ctgResetTbMetaTask(pTask); ctgResetTbMetaTask(pTask);
@ -2692,6 +2825,7 @@ SCtgAsyncFps gCtgAsyncFps[] = {
{ctgInitGetTbHashsTask, ctgLaunchGetTbHashsTask, ctgHandleGetTbHashsRsp, ctgDumpTbHashsRes, NULL, NULL}, {ctgInitGetTbHashsTask, ctgLaunchGetTbHashsTask, ctgHandleGetTbHashsRsp, ctgDumpTbHashsRes, NULL, NULL},
{ctgInitGetTbTagTask, ctgLaunchGetTbTagTask, ctgHandleGetTbTagRsp, ctgDumpTbTagRes, NULL, NULL}, {ctgInitGetTbTagTask, ctgLaunchGetTbTagTask, ctgHandleGetTbTagRsp, ctgDumpTbTagRes, NULL, NULL},
{ctgInitGetViewsTask, ctgLaunchGetViewsTask, ctgHandleGetViewsRsp, ctgDumpViewsRes, NULL, NULL}, {ctgInitGetViewsTask, ctgLaunchGetViewsTask, ctgHandleGetViewsRsp, ctgDumpViewsRes, NULL, NULL},
{ctgInitGetTbTSMATask, ctgLaunchGetTbTSMATask, ctgHandleGetTbTSMARsp, ctgDumpTbTSMARes, NULL, NULL},
}; };
int32_t ctgMakeAsyncRes(SCtgJob* pJob) { int32_t ctgMakeAsyncRes(SCtgJob* pJob) {

393
source/libs/catalog/src/ctgCache.c
View File

@ -32,6 +32,8 @@ SCtgOperation gCtgCacheOperation[CTG_OP_MAX] = {{CTG_OP_UPDATE_VGROUP, "update v
{CTG_OP_DROP_TB_INDEX, "drop tbIndex", ctgOpDropTbIndex}, {CTG_OP_DROP_TB_INDEX, "drop tbIndex", ctgOpDropTbIndex},
{CTG_OP_UPDATE_VIEW_META, "update viewMeta", ctgOpUpdateViewMeta}, {CTG_OP_UPDATE_VIEW_META, "update viewMeta", ctgOpUpdateViewMeta},
{CTG_OP_DROP_VIEW_META, "drop viewMeta", ctgOpDropViewMeta}, {CTG_OP_DROP_VIEW_META, "drop viewMeta", ctgOpDropViewMeta},
{CTG_OP_UPDATE_TB_TSMA, "update tbTSMA", ctgOpUpdateTbTSMA},
{CTG_OP_DROP_TB_TSMA, "drop tbTSMA", ctgOpDropTbTSMA},
{CTG_OP_CLEAR_CACHE, "clear cache", ctgOpClearCache}}; {CTG_OP_CLEAR_CACHE, "clear cache", ctgOpClearCache}};
SCtgCacheItemInfo gCtgStatItem[CTG_CI_MAX_VALUE] = { SCtgCacheItemInfo gCtgStatItem[CTG_CI_MAX_VALUE] = {
@ -52,6 +54,7 @@ SCtgCacheItemInfo gCtgStatItem[CTG_CI_MAX_VALUE] = {
{"TblTag ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_TBL_TAG, {"TblTag ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_TBL_TAG,
{"IndexInfo ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_INDEX_INFO, {"IndexInfo ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_INDEX_INFO,
{"viewMeta ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_VIEW, {"viewMeta ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_VIEW,
{"TblTSMA ", CTG_CI_FLAG_LEVEL_DB}, //CTG_CI_TBL_TSMA
{"User ", CTG_CI_FLAG_LEVEL_CLUSTER}, //CTG_CI_USER, {"User ", CTG_CI_FLAG_LEVEL_CLUSTER}, //CTG_CI_USER,
{"UDF ", CTG_CI_FLAG_LEVEL_CLUSTER}, //CTG_CI_UDF, {"UDF ", CTG_CI_FLAG_LEVEL_CLUSTER}, //CTG_CI_UDF,
{"SvrVer ", CTG_CI_FLAG_LEVEL_CLUSTER} //CTG_CI_SVR_VER, {"SvrVer ", CTG_CI_FLAG_LEVEL_CLUSTER} //CTG_CI_SVR_VER,
@ -209,6 +212,17 @@ void ctgReleaseVgMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *
} }
} }
void ctgReleaseTSMAToCache(SCatalog* pCtg, SCtgDBCache* dbCache, SCtgTSMACache* pCache) {
if (pCache && dbCache) {
CTG_UNLOCK(CTG_READ, &pCache->tsmaLock);
taosHashRelease(dbCache->tsmaCache, pCache);
}
if (dbCache) {
ctgReleaseDBCache(pCtg, dbCache);
}
}
int32_t ctgAcquireVgInfoFromCache(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache) { int32_t ctgAcquireVgInfoFromCache(SCatalog *pCtg, const char *dbFName, SCtgDBCache **pCache) {
SCtgDBCache *dbCache = NULL; SCtgDBCache *dbCache = NULL;
ctgAcquireDBCache(pCtg, dbFName, &dbCache); ctgAcquireDBCache(pCtg, dbFName, &dbCache);
@ -1381,6 +1395,13 @@ int32_t ctgAddNewDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId) {
CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
} }
newDBCache.tsmaCache = taosHashInit(gCtgMgmt.cfg.maxTSMACacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY),
true, HASH_ENTRY_LOCK);
if (!newDBCache.tsmaCache) {
ctgError("taosHashInit %d tsmaCache failed", gCtgMgmt.cfg.maxTSMACacheNum);
CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
code = taosHashPut(pCtg->dbCache, dbFName, strlen(dbFName), &newDBCache, sizeof(SCtgDBCache)); code = taosHashPut(pCtg->dbCache, dbFName, strlen(dbFName), &newDBCache, sizeof(SCtgDBCache));
if (code) { if (code) {
if (HASH_NODE_EXIST(code)) { if (HASH_NODE_EXIST(code)) {
@ -1424,6 +1445,7 @@ int32_t ctgRemoveDBFromCache(SCatalog *pCtg, SCtgDBCache *dbCache, const char *d
atomic_store_8(&dbCache->deleted, 1); atomic_store_8(&dbCache->deleted, 1);
ctgRemoveStbRent(pCtg, dbCache); ctgRemoveStbRent(pCtg, dbCache);
ctgRemoveViewRent(pCtg, dbCache); ctgRemoveViewRent(pCtg, dbCache);
ctgRemoveTSMARent(pCtg, dbCache);
ctgFreeDbCache(dbCache); ctgFreeDbCache(dbCache);
CTG_UNLOCK(CTG_WRITE, &dbCache->dbLock); CTG_UNLOCK(CTG_WRITE, &dbCache->dbLock);
@ -2074,7 +2096,8 @@ int32_t ctgOpDropStbMeta(SCtgCacheOperation *operation) {
} }
tblType = pTbCache->pMeta->tableType; tblType = pTbCache->pMeta->tableType;
atomic_sub_fetch_64(&dbCache->dbCacheSize, ctgGetTbMetaCacheSize(pTbCache->pMeta) + ctgGetTbIndexCacheSize(pTbCache->pIndex)); atomic_sub_fetch_64(&dbCache->dbCacheSize,
ctgGetTbMetaCacheSize(pTbCache->pMeta) + ctgGetTbIndexCacheSize(pTbCache->pIndex));
ctgFreeTbCacheImpl(pTbCache, true); ctgFreeTbCacheImpl(pTbCache, true);
if (taosHashRemove(dbCache->tbCache, msg->stbName, strlen(msg->stbName))) { if (taosHashRemove(dbCache->tbCache, msg->stbName, strlen(msg->stbName))) {
@ -2126,7 +2149,8 @@ int32_t ctgOpDropTbMeta(SCtgCacheOperation *operation) {
} }
tblType = pTbCache->pMeta->tableType; tblType = pTbCache->pMeta->tableType;
atomic_sub_fetch_64(&dbCache->dbCacheSize, ctgGetTbMetaCacheSize(pTbCache->pMeta) + ctgGetTbIndexCacheSize(pTbCache->pIndex)); atomic_sub_fetch_64(&dbCache->dbCacheSize, ctgGetTbMetaCacheSize(pTbCache->pMeta) +
ctgGetTbIndexCacheSize(pTbCache->pIndex));
ctgFreeTbCacheImpl(pTbCache, true); ctgFreeTbCacheImpl(pTbCache, true);
if (taosHashRemove(dbCache->tbCache, msg->tbName, strlen(msg->tbName))) { if (taosHashRemove(dbCache->tbCache, msg->tbName, strlen(msg->tbName))) {
@ -2554,6 +2578,7 @@ void ctgFreeCacheOperationData(SCtgCacheOperation *op) {
case CTG_OP_UPDATE_VG_EPSET: case CTG_OP_UPDATE_VG_EPSET:
case CTG_OP_DROP_TB_INDEX: case CTG_OP_DROP_TB_INDEX:
case CTG_OP_DROP_VIEW_META: case CTG_OP_DROP_VIEW_META:
case CTG_OP_DROP_TB_TSMA:
case CTG_OP_CLEAR_CACHE: { case CTG_OP_CLEAR_CACHE: {
taosMemoryFreeClear(op->data); taosMemoryFreeClear(op->data);
break; break;
@ -2582,6 +2607,14 @@ void ctgFreeCacheOperationData(SCtgCacheOperation *op) {
taosMemoryFreeClear(op->data); taosMemoryFreeClear(op->data);
break; break;
} }
case CTG_OP_UPDATE_TB_TSMA: {
SCtgUpdateTbTSMAMsg *msg = op->data;
if (msg->pTsma) {
tFreeTableTSMAInfo(msg->pTsma);
taosMemoryFreeClear(msg->pTsma);
}
break;
}
default: { default: {
qError("invalid cache op id:%d", op->opId); qError("invalid cache op id:%d", op->opId);
break; break;
@ -3136,5 +3169,361 @@ int32_t ctgGetViewsFromCache(SCatalog *pCtg, SRequestConnInfo *pConn, SCtgViewsC
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
void ctgReleaseTbTSMAToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *pCache) {
if (pCache) {
CTG_UNLOCK(CTG_READ, &pCache->tsmaLock);
taosHashRelease(dbCache->tbCache, pCache);
}
if (dbCache) {
ctgReleaseDBCache(pCtg, dbCache);
}
}
#if 0
int32_t ctgAcquireTbTSMAFromCache(SCatalog *pCtg, char *dbFName, char *tbName, SCtgDBCache **pDb, SCtgTbCache **pTb) {
SCtgDBCache *dbCache = NULL;
SCtgTbCache *pCache = NULL;
ctgAcquireDBCache(pCtg, dbFName, &dbCache);
if (NULL == dbCache) {
ctgDebug("db %s not in cache", dbFName);
goto _return;
}
int32_t sz = 0;
pCache = taosHashAcquire(dbCache->tbCache, tbName, strlen(tbName));
if (NULL == pCache) {
ctgDebug("tb %s not in cache, dbFName:%s", tbName, dbFName);
goto _return;
}
CTG_LOCK(CTG_READ, &pCache->tsmaLock);
if (NULL == pCache->pTsmas) {
ctgDebug("tb %s tsma not in cache, dbFName:%s", tbName, dbFName);
goto _return;
}
*pDb = dbCache;
*pTb = pCache;
ctgDebug("tb %s tsma got in cache, dbFName:%s", tbName, dbFName);
CTG_CACHE_HIT_INC(CTG_CI_TBL_TSMA, 1);
return TSDB_CODE_SUCCESS;
_return:
ctgReleaseTbTSMAToCache(pCtg, dbCache, pCache);
CTG_CACHE_NHIT_INC(CTG_CI_TBL_TSMA, 1);
return TSDB_CODE_SUCCESS;
}
#endif
int32_t ctgGetTbTSMAFromCache(SCatalog* pCtg, SCtgTbTSMACtx* pCtx, int32_t dbIdx, int32_t* fetchIdx, int32_t baseResIdx,
SArray* pList) {
int32_t code = 0;
SCtgDBCache * dbCache = NULL;
SCtgTSMACache *pCache = NULL;
char dbFName[TSDB_DB_FNAME_LEN] = {0};
int32_t flag = CTG_FLAG_UNKNOWN_STB;
uint64_t lastSuid = 0;
STableMeta * lastTableMeta = NULL;
SName * pName = taosArrayGet(pList, 0);
int32_t tbNum = taosArrayGetSize(pList);
// TODO test sys db
if (IS_SYS_DBNAME(pName->dbname)) {
return TSDB_CODE_SUCCESS;
}
tNameGetFullDbName(pName, dbFName);
ctgAcquireDBCache(pCtg, dbFName, &dbCache);
if (!dbCache) {
ctgDebug("DB %s not in cache", dbFName);
for (int32_t i = 0; i < tbNum; ++i) {
ctgAddFetch(&pCtx->pFetches, dbIdx, i, fetchIdx, baseResIdx + i, flag);
taosArrayPush(pCtx->pResList, &(SMetaData){0});
}
return TSDB_CODE_SUCCESS;
}
for (int32_t i = 0; i < tbNum; ++i) {
pName = taosArrayGet(pList, i);
pCache = taosHashAcquire(dbCache->tsmaCache, pName->tname, strlen(pName->tname));
if (!pCache) {
ctgDebug("tsma for tb: %s.%s not in cache", dbFName, pName->tname);
ctgAddFetch(&pCtx->pFetches, dbIdx, i, fetchIdx, baseResIdx + i, flag);
taosArrayPush(pCtx->pResList, &(SMetaRes){0});
CTG_CACHE_NHIT_INC(CTG_CI_TBL_SMA, 1);
continue;
}
CTG_LOCK(CTG_READ, &pCache->tsmaLock);
if (!pCache->pTsmas) {
CTG_UNLOCK(CTG_READ, &pCache->tsmaLock);
taosHashRelease(dbCache->tsmaCache, pCache);
ctgDebug("tsma for tb: %s.%s not in cache", pName->tname, dbFName);
ctgAddFetch(&pCtx->pFetches, dbIdx, i, fetchIdx, baseResIdx + i, flag);
taosArrayPush(pCtx->pResList, &(SMetaRes){0});
CTG_CACHE_NHIT_INC(CTG_CI_TBL_TSMA, 1);
continue;
}
CTG_CACHE_HIT_INC(CTG_CI_TBL_TSMA, 1);
STableTSMAInfoRsp rsp;
rsp.pTsmas = taosArrayInit(pCache->pTsmas->size, POINTER_BYTES);
if (!rsp.pTsmas) {
ctgReleaseTSMAToCache(pCtg, dbCache, pCache);
CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
SMetaRes res = {0};
for (int32_t i = 0; i < pCache->pTsmas->size; ++i) {
STSMACache *pTsmaOut = NULL;
STSMACache *pTsmaCache = taosArrayGetP(pCache->pTsmas, i);
code = ctgCloneTbTSMA(pTsmaCache, &pTsmaOut);
if (code) {
ctgReleaseTSMAToCache(pCtg, dbCache, pCache);
tFreeTableTSMAInfoRsp(&rsp);
CTG_ERR_RET(code);
}
taosArrayPush(rsp.pTsmas, &pTsmaOut);
}
res.pRes = rsp.pTsmas;
taosArrayPush(pCtx->pResList, &res);
taosHashRelease(dbCache->tsmaCache, pCache);
}
ctgReleaseDBCache(pCtg, dbCache);
CTG_RET(code);
}
int32_t ctgUpdateTbTSMAEnqueue(SCatalog *pCtg, STSMACache **pTsma, bool syncOp) {
int32_t code = 0;
SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
op->opId = CTG_OP_UPDATE_TB_TSMA;
op->syncOp = syncOp;
SCtgUpdateTbTSMAMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateTbTSMAMsg));
if (NULL == msg) {
ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateTbTSMAMsg));
taosMemoryFree(op);
CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
}
msg->pCtg = pCtg;
msg->pTsma = *pTsma;
op->data = msg;
CTG_ERR_JRET(ctgEnqueue(pCtg, op));
*pTsma = NULL;
return TSDB_CODE_SUCCESS;
_return:
CTG_RET(code);
}
int32_t ctgDropTbTSMAEnqueue(SCatalog* pCtg, const STSMACache* pTsma, bool syncOp) {
int32_t code = 0;
SCtgCacheOperation* op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
if (!op) CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
op->opId = CTG_OP_DROP_TB_TSMA;
op->syncOp = syncOp;
SCtgDropTbTSMAMsg* msg = taosMemoryMalloc(sizeof(SCtgDropTbTSMAMsg));
if (!msg) {
ctgError("malloc %d failed", (int32_t)sizeof(SCtgDropTbTSMAMsg));
taosMemoryFree(op);
CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
}
msg->pCtg = pCtg;
msg->dbId = pTsma->dbId;
msg->tbId = pTsma->suid;
msg->tsmaId = pTsma->tsmaId;
tstrncpy(msg->dbFName, pTsma->dbFName, TSDB_DB_FNAME_LEN);
// TODO use table name len, instead of TSDB_TABLE_FNAME_LEN
tstrncpy(msg->tbName, pTsma->tb, TSDB_TABLE_NAME_LEN);
tstrncpy(msg->tsmaName, pTsma->name, TSDB_TABLE_NAME_LEN);
op->data = msg;
CTG_ERR_JRET(ctgEnqueue(pCtg, op));
return TSDB_CODE_SUCCESS;
_return:
CTG_RET(code);
}
int32_t ctgDropTSMAForTbEnqueue(SCatalog *pCtg, SName *pName, bool syncOp) {
int32_t code = 0;
SCtgCacheOperation* op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
if (!op) CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
op->opId = CTG_OP_DROP_TB_TSMA;
op->syncOp = syncOp;
SCtgDropTbTSMAMsg* msg = taosMemoryMalloc(sizeof(SCtgDropTbTSMAMsg));
if (!msg) {
ctgError("malloc %d failed", (int32_t)sizeof(SCtgDropTbTSMAMsg));
taosMemoryFree(op);
CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
}
msg->pCtg = pCtg;
msg->dbId = 0;
msg->tbId = 0;
msg->tsmaId = 0;
msg->tsmaName[0] = '\0';
tNameGetFullDbName(pName, msg->dbFName);
tstrncpy(msg->tbName, pName->tname, TSDB_TABLE_NAME_LEN);
op->data = msg;
CTG_ERR_JRET(ctgEnqueue(pCtg, op));
return TSDB_CODE_SUCCESS;
_return:
CTG_RET(code);
}
int32_t ctgWriteTbTSMAToCache(SCatalog *pCtg, SCtgDBCache *dbCache, char *dbFName, char *tbName,
STSMACache **ppTsmaCache) {
if (NULL == dbCache->tsmaCache) {
ctgError("db is dropping, dbId:0x%" PRIx64, dbCache->dbId);
CTG_ERR_RET(TSDB_CODE_CTG_DB_DROPPED);
}
STSMACache *pTsmaCache = *ppTsmaCache;
int32_t code = TSDB_CODE_SUCCESS;
SCtgTSMACache* pCache = taosHashGet(dbCache->tsmaCache, tbName, strlen(tbName));
if (!pCache) {
SCtgTSMACache cache = {0};
cache.pTsmas = taosArrayInit(4, sizeof(POINTER_BYTES));
if (!cache.pTsmas) CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
taosArrayPush(cache.pTsmas, &pTsmaCache);
if (taosHashPut(dbCache->tsmaCache, tbName, strlen(tbName), &cache, sizeof(cache))) {
ctgError("taosHashPut new tsmacache for tb: %s.%s failed", dbFName, tbName);
CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
}
atomic_add_fetch_64(&dbCache->dbCacheSize, strlen(tbName) + sizeof(STSMACache) + ctgGetTbTSMACacheSize(pTsmaCache));
CTG_DB_NUM_INC(CTG_CI_TBL_TSMA);
ctgDebug("tb %s tsma updated to cache, name: %s", tbName, pTsmaCache->name);
CTG_ERR_JRET(ctgUpdateRentTSMAVersion(pCtg, dbFName, pTsmaCache));
*ppTsmaCache = NULL;
goto _return;
}
CTG_LOCK(CTG_WRITE, &pCache->tsmaLock);
if (pCache->pTsmas) {
uint64_t cacheSize = 0;
for (int32_t i = 0; i < pCache->pTsmas->size; ++i) {
STableTSMAInfo* pInfo = taosArrayGetP(pCache->pTsmas, i);
if (pInfo->tsmaId == pTsmaCache->tsmaId) {
cacheSize = ctgGetTbTSMACacheSize(pInfo);
taosArrayRemove(pCache->pTsmas, i);
atomic_sub_fetch_64(&dbCache->dbCacheSize, cacheSize);
tFreeTableTSMAInfo(pInfo);
taosMemoryFreeClear(pInfo);
break;
}
}
} else {
pCache->pTsmas = taosArrayInit(4, sizeof(POINTER_BYTES));
if (!pCache->pTsmas) {
CTG_UNLOCK(CTG_WRITE, &pCache->tsmaLock);
CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
}
}
// push the new cache
taosArrayPush(pCache->pTsmas, &pTsmaCache);
*ppTsmaCache = NULL;
atomic_add_fetch_64(&dbCache->dbCacheSize, ctgGetTbTSMACacheSize(pTsmaCache));
CTG_ERR_RET(ctgUpdateRentTSMAVersion(pCtg, dbFName, pTsmaCache));
CTG_UNLOCK(CTG_WRITE, &pCache->tsmaLock);
ctgDebug("table %s tsma updated to cache, tsma: %s", tbName, pTsmaCache->name);
_return:
CTG_RET(code);
}
int32_t ctgOpDropTbTSMA(SCtgCacheOperation *operation) {
int32_t code = 0;
SCtgDropTbTSMAMsg * msg = operation->data;
SCatalog *pCtg = msg->pCtg;
SCtgDBCache *dbCache = NULL;
if (pCtg->stopUpdate) {
goto _return;
}
CTG_ERR_JRET(ctgGetDBCache(pCtg, msg->dbFName, &dbCache));
if (NULL == dbCache || !dbCache->tsmaCache || (msg->dbId != dbCache->dbId && msg->dbId != 0)) {
goto _return;
}
SCtgTSMACache* pCtgCache = taosHashGet(dbCache->tsmaCache, msg->tbName, strlen(msg->tbName));
if (!pCtgCache || !pCtgCache->pTsmas || pCtgCache->pTsmas->size == 0) {
goto _return;
}
CTG_LOCK(CTG_READ, &pCtgCache->tsmaLock);
STSMACache *pCache = taosArrayGetP(pCtgCache->pTsmas, 0);
uint64_t cacheSize = 0;
if (msg->tbId != 0 && pCache->suid != msg->tbId) {
// table id mismatch, skip drops
CTG_UNLOCK(CTG_READ, &pCtgCache->tsmaLock);
goto _return;
}
for (int32_t i = 0; i < pCtgCache->pTsmas->size; ++i) {
pCache = taosArrayGetP(pCtgCache->pTsmas, i);
if (pCache->tsmaId != msg->tsmaId) {
continue;
}
cacheSize = ctgGetTbTSMACacheSize(pCache);
CTG_ERR_JRET(ctgMetaRentRemove(&msg->pCtg->tsmaRent, pCache->tsmaId, ctgTSMAVersionSearchCompare,
ctgTSMAVersionSearchCompare));
taosArrayRemove(pCtgCache->pTsmas, i);
tFreeAndClearTableTSMAInfo(pCache);
CTG_DB_NUM_DEC(CTG_CI_TBL_TSMA);
break;
}
CTG_UNLOCK(CTG_READ, &pCtgCache->tsmaLock);
//taosHashRemove(dbCache->tsmaCache, msg->tbName, strlen(msg->tbName));
atomic_sub_fetch_64(&dbCache->dbCacheSize, cacheSize);
_return:
taosMemoryFreeClear(msg);
CTG_RET(code);
}
int32_t ctgOpUpdateTbTSMA(SCtgCacheOperation *operation) {
int32_t code = 0;
SCtgUpdateTbTSMAMsg *msg = operation->data;
SCatalog * pCtg = msg->pCtg;
STableTSMAInfo * pTsmaInfo = msg->pTsma;
SCtgDBCache * dbCache = NULL;
if (pCtg->stopUpdate) {
goto _return;
}
CTG_ERR_JRET(ctgGetAddDBCache(pCtg, pTsmaInfo->dbFName, pTsmaInfo->dbId, &dbCache));
CTG_ERR_JRET(ctgWriteTbTSMAToCache(pCtg, dbCache, pTsmaInfo->dbFName, pTsmaInfo->tb, &pTsmaInfo));
_return:
if (pTsmaInfo) {
tFreeTableTSMAInfo(pTsmaInfo);
taosMemoryFreeClear(pTsmaInfo);
}
taosMemoryFreeClear(msg);
CTG_RET(code);
}

71
source/libs/catalog/src/ctgRemote.c
View File

@ -337,6 +337,23 @@ int32_t ctgProcessRspMsg(void* out, int32_t reqType, char* msg, int32_t msgSize,
qDebug("Got view-meta from mnode, viewFName:%s", target); qDebug("Got view-meta from mnode, viewFName:%s", target);
break; break;
} }
case TDMT_MND_GET_TABLE_TSMA: {
if (TSDB_CODE_SUCCESS != rspCode) {
if (TSDB_CODE_MND_SMA_NOT_EXIST != rspCode) {
qError("error rsp for get table tsma, error:%s, tbFName:%s", tstrerror(rspCode), target);
}
CTG_ERR_RET(rspCode);
}
code = queryProcessMsgRsp[TMSG_INDEX(reqType)](out, msg, msgSize);
if (code) {
qError("Process get table tsma rsp failed, error:%s, tbFName:%s", tstrerror(code), target);
CTG_ERR_RET(code);
}
qDebug("Got table tsma from mnode, tbFName:%s", target);
break;
}
default: default:
if (TSDB_CODE_SUCCESS != rspCode) { if (TSDB_CODE_SUCCESS != rspCode) {
qError("Got error rsp, error:%s", tstrerror(rspCode)); qError("Got error rsp, error:%s", tstrerror(rspCode));
@ -1463,4 +1480,58 @@ int32_t ctgGetViewInfoFromMnode(SCatalog* pCtg, SRequestConnInfo* pConn, SName*
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t ctgGetTbTSMAFromMnode(SCatalog* pCtg, SRequestConnInfo* pConn, SName* name, STableTSMAInfoRsp* out,
SCtgTaskReq* tReq) {
char* msg = NULL;
int32_t msgLen = 0;
int32_t reqType = TDMT_MND_GET_TABLE_TSMA;
SCtgTask* pTask = tReq->pTask;
void* (*mallocFp)(int64_t) = pTask ? (MallocType)taosMemoryMalloc : (MallocType)rpcMallocCont;
char tbFName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(name, tbFName);
ctgDebug("try to get tb index from mnode, tbFName:%s", tbFName);
int32_t code = queryBuildMsg[TMSG_INDEX(reqType)]((void*)tbFName, &msg, 0, &msgLen, mallocFp);
if (code) {
ctgError("Build get index msg failed, code:%s, tbFName:%s", tstrerror(code), tbFName);
CTG_ERR_RET(code);
}
if (pTask) {
void* pOut = taosMemoryCalloc(1, sizeof(STableTSMAInfoRsp));
if (NULL == pOut) {
CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
CTG_ERR_RET(ctgUpdateMsgCtx(CTG_GET_TASK_MSGCTX(pTask, -1), reqType, pOut, (char*)tbFName));
#if CTG_BATCH_FETCH
CTG_RET(ctgAddBatch(pCtg, 0, pConn, tReq, reqType, msg, msgLen));
#else
SArray* pTaskId = taosArrayInit(1, sizeof(int32_t));
if (NULL == pTaskId) {
CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
taosArrayPush(pTaskId, &pTask->taskId);
CTG_RET(ctgAsyncSendMsg(pCtg, pConn, pTask->pJob, pTaskId, -1, NULL, NULL, 0, reqType, msg, msgLen));
#endif
}
SRpcMsg rpcMsg = {
.msgType = reqType,
.pCont = msg,
.contLen = msgLen,
};
SRpcMsg rpcRsp = {0};
rpcSendRecv(pConn->pTrans, &pConn->mgmtEps, &rpcMsg, &rpcRsp);
CTG_ERR_RET(ctgProcessRspMsg(out, reqType, rpcRsp.pCont, rpcRsp.contLen, rpcRsp.code, (char*)tbFName));
rpcFreeCont(rpcRsp.pCont);
return TSDB_CODE_SUCCESS;
}

32
source/libs/catalog/src/ctgRent.c
View File

@ -259,6 +259,24 @@ void ctgRemoveViewRent(SCatalog *pCtg, SCtgDBCache *dbCache) {
} }
} }
void ctgRemoveTSMARent(SCatalog *pCtg, SCtgDBCache *dbCache) {
if (!dbCache->tsmaCache) return;
void* pIter = taosHashIterate(dbCache->tsmaCache, NULL);
while (pIter) {
SCtgTSMACache* pCtgCache = pIter;
CTG_LOCK(CTG_READ, &pCtgCache->tsmaLock);
int32_t size = pCtgCache ? pCtgCache->pTsmas->size : 0;
for (int32_t i = 0; i < size; ++i) {
STSMACache* pCache = taosArrayGet(pCtgCache->pTsmas, i);
if (TSDB_CODE_SUCCESS == ctgMetaRentRemove(&pCtg->tsmaRent, pCache->tsmaId, ctgTSMAVersionSortCompare, ctgTSMAVersionSearchCompare)) {
ctgDebug("tsma removed from rent, viewId: %" PRIx64 " name: %s.%s.%s", pCache->tsmaId, pCache->dbFName, pCache->tb, pCache->name);
}
}
CTG_UNLOCK(CTG_READ, &pCtgCache->tsmaLock);
pIter = taosHashIterate(dbCache->tsmaCache, pIter);
}
}
int32_t ctgUpdateRentStbVersion(SCatalog *pCtg, char *dbFName, char *tbName, uint64_t dbId, uint64_t suid, int32_t ctgUpdateRentStbVersion(SCatalog *pCtg, char *dbFName, char *tbName, uint64_t dbId, uint64_t suid,
SCtgTbCache *pCache) { SCtgTbCache *pCache) {
@ -300,3 +318,17 @@ int32_t ctgUpdateRentViewVersion(SCatalog *pCtg, char *dbFName, char *viewName,
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t ctgUpdateRentTSMAVersion(SCatalog *pCtg, char *dbFName, const STSMACache *pCache) {
const STableTSMAInfo *pTsmaInfo = pCache;
STSMAVersion tsmaRent = {.dbId = pTsmaInfo->dbId, .tsmaId = pTsmaInfo->tsmaId, .version = pTsmaInfo->version};
tstrncpy(tsmaRent.name, pTsmaInfo->name, TSDB_TABLE_NAME_LEN);
tstrncpy(tsmaRent.dbFName, dbFName, TSDB_DB_FNAME_LEN);
tstrncpy(tsmaRent.tbName, pTsmaInfo->tb, TSDB_TABLE_NAME_LEN);
CTG_ERR_RET(ctgMetaRentUpdate(&pCtg->tsmaRent, &tsmaRent, tsmaRent.tsmaId, sizeof(STSMAVersion),
ctgTSMAVersionSortCompare, ctgTSMAVersionSearchCompare));
ctgDebug("db %s, 0x%" PRIx64 " tsma %s, 0x%" PRIx64 "version %d updated to tsmaRent", dbFName, tsmaRent.dbId,
pTsmaInfo->name, pTsmaInfo->tsmaId, pTsmaInfo->version);
return TSDB_CODE_SUCCESS;
}

113
source/libs/catalog/src/ctgUtil.c
View File

@ -190,6 +190,9 @@ void ctgFreeSMetaData(SMetaData* pData) {
taosArrayDestroy(pData->pView); taosArrayDestroy(pData->pView);
pData->pView = NULL; pData->pView = NULL;
taosArrayDestroy(pData->pTableTsmas);
pData->pTableTsmas = NULL;
taosMemoryFreeClear(pData->pSvrVer); taosMemoryFreeClear(pData->pSvrVer);
} }
@ -297,6 +300,31 @@ void ctgFreeTbCache(SCtgDBCache* dbCache) {
dbCache->tbCache = NULL; dbCache->tbCache = NULL;
} }
void ctgFreeTSMACacheImpl(SCtgTSMACache* pCache, bool lock) {
if (lock) {
CTG_LOCK(CTG_WRITE, &pCache->tsmaLock);
}
if (pCache->pTsmas) {
taosArrayDestroyP(pCache->pTsmas, tFreeAndClearTableTSMAInfo);
pCache->pTsmas = NULL;
}
if (lock) {
CTG_UNLOCK(CTG_WRITE, &pCache->tsmaLock);
}
}
void ctgFreeTSMACache(SCtgDBCache* dbCache) {
if (!dbCache) return;
SCtgTSMACache* pCache = taosHashIterate(dbCache->tsmaCache, NULL);
while (pCache) {
ctgFreeTSMACacheImpl(pCache, false);
pCache = taosHashIterate(dbCache->tsmaCache, pCache);
}
taosHashCleanup(dbCache->tsmaCache);
dbCache->tsmaCache = NULL;
}
void ctgFreeVgInfoCache(SCtgDBCache* dbCache) { freeVgInfo(dbCache->vgCache.vgInfo); } void ctgFreeVgInfoCache(SCtgDBCache* dbCache) { freeVgInfo(dbCache->vgCache.vgInfo); }
void ctgFreeCfgInfoCache(SCtgDBCache* dbCache) { freeDbCfgInfo(dbCache->cfgCache.cfgInfo); } void ctgFreeCfgInfoCache(SCtgDBCache* dbCache) { freeDbCfgInfo(dbCache->cfgCache.cfgInfo); }
@ -310,6 +338,7 @@ void ctgFreeDbCache(SCtgDBCache* dbCache) {
ctgFreeStbMetaCache(dbCache); ctgFreeStbMetaCache(dbCache);
ctgFreeTbCache(dbCache); ctgFreeTbCache(dbCache);
ctgFreeViewCache(dbCache); ctgFreeViewCache(dbCache);
ctgFreeTSMACache(dbCache);
} }
void ctgFreeInstDbCache(SHashObj* pDbCache) { void ctgFreeInstDbCache(SHashObj* pDbCache) {
@ -353,6 +382,7 @@ void ctgFreeHandleImpl(SCatalog* pCtg) {
ctgFreeMetaRent(&pCtg->dbRent); ctgFreeMetaRent(&pCtg->dbRent);
ctgFreeMetaRent(&pCtg->stbRent); ctgFreeMetaRent(&pCtg->stbRent);
ctgFreeMetaRent(&pCtg->viewRent); ctgFreeMetaRent(&pCtg->viewRent);
ctgFreeMetaRent(&pCtg->tsmaRent);
ctgFreeInstDbCache(pCtg->dbCache); ctgFreeInstDbCache(pCtg->dbCache);
ctgFreeInstUserCache(pCtg->userCache); ctgFreeInstUserCache(pCtg->userCache);
@ -382,6 +412,7 @@ void ctgFreeHandle(SCatalog* pCtg) {
ctgFreeMetaRent(&pCtg->dbRent); ctgFreeMetaRent(&pCtg->dbRent);
ctgFreeMetaRent(&pCtg->stbRent); ctgFreeMetaRent(&pCtg->stbRent);
ctgFreeMetaRent(&pCtg->viewRent); ctgFreeMetaRent(&pCtg->viewRent);
ctgFreeMetaRent(&pCtg->tsmaRent);
ctgFreeInstDbCache(pCtg->dbCache); ctgFreeInstDbCache(pCtg->dbCache);
ctgFreeInstUserCache(pCtg->userCache); ctgFreeInstUserCache(pCtg->userCache);
@ -410,7 +441,8 @@ void ctgClearHandleMeta(SCatalog* pCtg, int64_t *pClearedSize, int64_t *pCleardN
} }
taosHashRemove(dbCache->tbCache, key, len); taosHashRemove(dbCache->tbCache, key, len);
cacheSize = len + sizeof(SCtgTbCache) + ctgGetTbMetaCacheSize(pCache->pMeta) + ctgGetTbIndexCacheSize(pCache->pIndex); cacheSize =
len + sizeof(SCtgTbCache) + ctgGetTbMetaCacheSize(pCache->pMeta) + ctgGetTbIndexCacheSize(pCache->pIndex);
atomic_sub_fetch_64(&dbCache->dbCacheSize, cacheSize); atomic_sub_fetch_64(&dbCache->dbCacheSize, cacheSize);
*pClearedSize += cacheSize; *pClearedSize += cacheSize;
(*pCleardNum)++; (*pCleardNum)++;
@ -468,6 +500,7 @@ void ctgClearHandle(SCatalog* pCtg) {
ctgFreeMetaRent(&pCtg->dbRent); ctgFreeMetaRent(&pCtg->dbRent);
ctgFreeMetaRent(&pCtg->stbRent); ctgFreeMetaRent(&pCtg->stbRent);
ctgFreeMetaRent(&pCtg->viewRent); ctgFreeMetaRent(&pCtg->viewRent);
ctgFreeMetaRent(&pCtg->tsmaRent);
ctgFreeInstDbCache(pCtg->dbCache); ctgFreeInstDbCache(pCtg->dbCache);
ctgFreeInstUserCache(pCtg->userCache); ctgFreeInstUserCache(pCtg->userCache);
@ -592,6 +625,13 @@ void ctgFreeMsgCtx(SCtgMsgCtx* pCtx) {
} }
break; break;
} }
case TDMT_MND_GET_TABLE_TSMA: {
if (pCtx->out) {
tFreeTableTSMAInfoRsp(pCtx->out);
taosMemoryFreeClear(pCtx->out);
}
break;
}
default: default:
qError("invalid reqType %d", pCtx->reqType); qError("invalid reqType %d", pCtx->reqType);
break; break;
@ -663,6 +703,20 @@ void ctgFreeViewMetaRes(void* res) {
} }
} }
void ctgFreeTbTSMARes(void* res) {
if (!res) {
return;
}
SMetaRes* pRes = res;
if (pRes->pRes) {
STableTSMAInfoRsp * pTsmaRsp = pRes->pRes;
tFreeTableTSMAInfoRsp(pTsmaRsp);
taosMemoryFree(pTsmaRsp);
pRes->pRes = NULL;
}
}
void ctgFreeJsonTagVal(void* val) { void ctgFreeJsonTagVal(void* val) {
if (NULL == val) { if (NULL == val) {
return; return;
@ -760,6 +814,15 @@ void ctgFreeTaskRes(CTG_TASK_TYPE type, void** pRes) {
*pRes = NULL; // no need to free it *pRes = NULL; // no need to free it
break; break;
} }
case CTG_TASK_GET_TB_TSMA: {
SArray* pArr = (SArray*)*pRes;
int32_t num = taosArrayGetSize(pArr);
for (int32_t i = 0; i < num; ++i) {
ctgFreeTbTSMARes(taosArrayGet(pArr, i));
}
*pRes = NULL;
break;
}
default: default:
qError("invalid task type %d", type); qError("invalid task type %d", type);
break; break;
@ -923,6 +986,14 @@ void ctgFreeTaskCtx(SCtgTask* pTask) {
taosMemoryFreeClear(pTask->taskCtx); taosMemoryFreeClear(pTask->taskCtx);
break; break;
} }
case CTG_TASK_GET_TB_TSMA: {
SCtgTbTSMACtx* pTsmaCtx = pTask->taskCtx;
taosArrayDestroyEx(pTsmaCtx->pResList, ctgFreeTbTSMARes);
taosArrayDestroy(pTsmaCtx->pFetches);
taosArrayDestroyEx(pTask->msgCtxs, (FDelete)ctgFreeMsgCtx);
taosMemoryFreeClear(pTask->taskCtx);
break;
}
default: default:
qError("invalid task type %d", pTask->type); qError("invalid task type %d", pTask->type);
break; break;
@ -1328,6 +1399,15 @@ int32_t ctgViewVersionSearchCompare(const void* key1, const void* key2) {
} }
} }
int32_t ctgTSMAVersionSearchCompare(const void* key1, const void* key2) {
if (*(uint64_t*)key1 < ((STSMAVersion*)key2)->tsmaId) {
return -1;
} else if (*(uint64_t*)key1 > ((STSMAVersion*)key2)->tsmaId) {
return 1;
} else {
return 0;
}
}
int32_t ctgStbVersionSortCompare(const void* key1, const void* key2) { int32_t ctgStbVersionSortCompare(const void* key1, const void* key2) {
if (((SSTableVersion*)key1)->suid < ((SSTableVersion*)key2)->suid) { if (((SSTableVersion*)key1)->suid < ((SSTableVersion*)key2)->suid) {
@ -1359,6 +1439,15 @@ int32_t ctgViewVersionSortCompare(const void* key1, const void* key2) {
} }
} }
int32_t ctgTSMAVersionSortCompare(const void* key1, const void* key2) {
if (((STSMAVersion*)key1)->tsmaId < ((STSMAVersion*)key2)->tsmaId) {
return -1;
} else if (((STSMAVersion*)key1)->tsmaId > ((STSMAVersion*)key2)->tsmaId) {
return 1;
} else {
return 0;
}
}
int32_t ctgMakeVgArray(SDBVgInfo* dbInfo) { int32_t ctgMakeVgArray(SDBVgInfo* dbInfo) {
if (NULL == dbInfo) { if (NULL == dbInfo) {
@ -1657,6 +1746,10 @@ static void ctgFreeViewMeta(void* p) {
taosMemoryFree(pMeta); taosMemoryFree(pMeta);
} }
void ctgFreeTbTSMAInfo(void* p) {
tFreeTableTSMAInfoRsp(((SMetaRes*)p)->pRes);
taosMemoryFree(((SMetaRes*)p)->pRes);
}
int32_t ctgChkSetTbAuthRes(SCatalog* pCtg, SCtgAuthReq* req, SCtgAuthRsp* res) { int32_t ctgChkSetTbAuthRes(SCatalog* pCtg, SCtgAuthReq* req, SCtgAuthRsp* res) {
int32_t code = 0; int32_t code = 0;
@ -1990,6 +2083,7 @@ void ctgDestroySMetaData(SMetaData* pData) {
taosArrayDestroyEx(pData->pTableCfg, ctgFreeTableCfg); taosArrayDestroyEx(pData->pTableCfg, ctgFreeTableCfg);
taosArrayDestroyEx(pData->pDnodeList, ctgFreeDnodeList); taosArrayDestroyEx(pData->pDnodeList, ctgFreeDnodeList);
taosArrayDestroyEx(pData->pView, ctgFreeViewMeta); taosArrayDestroyEx(pData->pView, ctgFreeViewMeta);
taosArrayDestroyEx(pData->pTableTsmas, ctgFreeTbTSMAInfo);
taosMemoryFreeClear(pData->pSvrVer); taosMemoryFreeClear(pData->pSvrVer);
} }
@ -2287,5 +2381,22 @@ int32_t dupViewMetaFromRsp(SViewMetaRsp* pRsp, SViewMeta* pViewMeta) {
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
uint64_t ctgGetTbTSMACacheSize(STableTSMAInfo* pTsmaInfo) {
return 0;
}
int32_t ctgCloneTbTSMA(STSMACache* pInfo, STSMACache** pRes) {
int32_t code = TSDB_CODE_SUCCESS;
if (NULL == pInfo) {
return TSDB_CODE_SUCCESS;
}
STSMACache* pCache = taosMemoryCalloc(1, sizeof(STSMACache));
if (!pCache) return TSDB_CODE_OUT_OF_MEMORY;
*pCache = *pInfo;
if (pInfo->pFuncs) {
pCache->pFuncs = taosArrayDup(pInfo->pFuncs, NULL);
}
*pRes = pCache;
return code;
}

1
source/libs/function/inc/builtins.h
View File

@ -47,6 +47,7 @@ typedef struct SBuiltinFuncDefinition {
const char* pPartialFunc; const char* pPartialFunc;
const char* pMiddleFunc; const char* pMiddleFunc;
const char* pMergeFunc; const char* pMergeFunc;
const char* pStateFunc;
FCreateMergeFuncParameters createMergeParaFuc; FCreateMergeFuncParameters createMergeParaFuc;
FEstimateReturnRows estimateReturnRowsFunc; FEstimateReturnRows estimateReturnRowsFunc;
} SBuiltinFuncDefinition; } SBuiltinFuncDefinition;

44
source/libs/function/src/builtins.c
View File

@ -460,6 +460,18 @@ static int32_t translateAvgMerge(SFunctionNode* pFunc, char* pErrBuf, int32_t le
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
static int32_t translateAvgState(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
// TODO check params
pFunc->node.resType = (SDataType){.bytes = getAvgInfoSize() + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY};
return TSDB_CODE_SUCCESS;
}
static int32_t translateAvgStateMerge(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
// TODO check params
pFunc->node.resType = (SDataType){.bytes = getAvgInfoSize() + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY};
return TSDB_CODE_SUCCESS;
}
static int32_t translateStddevPartial(SFunctionNode* pFunc, char* pErrBuf, int32_t len) { static int32_t translateStddevPartial(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
if (1 != LIST_LENGTH(pFunc->pParameterList)) { if (1 != LIST_LENGTH(pFunc->pParameterList)) {
return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName); return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
@ -2540,7 +2552,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
.combineFunc = avgCombine, .combineFunc = avgCombine,
.pPartialFunc = "_avg_partial", .pPartialFunc = "_avg_partial",
.pMiddleFunc = "_avg_middle", .pMiddleFunc = "_avg_middle",
.pMergeFunc = "_avg_merge" .pMergeFunc = "_avg_merge",
.pStateFunc = "_avg_state",
}, },
{ {
.name = "_avg_partial", .name = "_avg_partial",
@ -3824,7 +3837,34 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
.initFunc = NULL, .initFunc = NULL,
.sprocessFunc = qPseudoTagFunction, .sprocessFunc = qPseudoTagFunction,
.finalizeFunc = NULL .finalizeFunc = NULL
} },
{
//TODO test for child table
//TODO for outer use not only internal
.name = "_avg_state",
.type = FUNCTION_TYPE_AVG_STATE,
.classification = FUNC_MGT_AGG_FUNC,
.translateFunc = translateAvgState,
//.dataRequiredFunc = statisDataRequired,
.getEnvFunc = getAvgFuncEnv,
.initFunc = avgFunctionSetup,
.processFunc = avgFunction,
.finalizeFunc = avgPartialFinalize,
//.combineFunc = avgCombine,
.pPartialFunc = "_avg_partial",
.pMergeFunc = "_avg_state_merge"
},
{
.name = "_avg_state_merge",
.type = FUNCTION_TYPE_AVG_STATE_MERGE,
.classification = FUNC_MGT_AGG_FUNC,
.translateFunc = translateAvgStateMerge,
.getEnvFunc = getAvgFuncEnv,
.initFunc = avgFunctionSetup,
.processFunc = avgFunctionMerge,
.finalizeFunc = avgPartialFinalize,
},
}; };
// clang-format on // clang-format on

47
source/libs/function/src/functionMgt.c
View File

@ -520,3 +520,50 @@ char* fmGetFuncName(int32_t funcId) {
} }
return taosStrdup(funcMgtBuiltins[funcId].name); return taosStrdup(funcMgtBuiltins[funcId].name);
} }
/// @param [out] pStateFunc, not changed if error occured or no need to create state func
/// @retval 0 for succ, otherwise err occured
static int32_t fmCreateStateFunc(const SFunctionNode* pFunc, SFunctionNode** pStateFunc) {
if (funcMgtBuiltins[pFunc->funcId].pStateFunc) {
SNodeList* pParams = nodesCloneList(pFunc->pParameterList);
if (!pParams) return TSDB_CODE_OUT_OF_MEMORY;
*pStateFunc = createFunction(funcMgtBuiltins[pFunc->funcId].pStateFunc, pParams);
if (!pStateFunc) {
nodesDestroyList(pParams);
return TSDB_CODE_FUNC_FUNTION_ERROR;
}
strcpy((*pStateFunc)->node.aliasName, pFunc->node.aliasName);
strcpy((*pStateFunc)->node.userAlias, pFunc->node.userAlias);
}
return TSDB_CODE_SUCCESS;
}
bool fmIsTSMASupportedFunc(func_id_t funcid) {
return fmIsAggFunc(funcid) && !fmIsForbidStreamFunc(funcid);
}
int32_t rewriteFuncsForTSMA(SNodeList* pFuncs) {
int32_t code;
SNode* pNode;
char buf[128] = {0};
FOREACH(pNode, pFuncs) {
SFunctionNode* pFunc = (SFunctionNode*)pNode;
code = fmGetFuncInfo(pFunc, buf, 128);
if (code) break;
if (fmIsTSMASupportedFunc(pFunc->funcId)) {
SFunctionNode* pNewFunc = NULL;
code = fmCreateStateFunc(pFunc, &pNewFunc);
if (code) {
// error
break;
} else if (!pNewFunc) {
// no need state func
continue;
} else {
REPLACE_NODE(pNewFunc);
nodesDestroyNode(pNode);
}
}
}
return code;
}

3
source/libs/nodes/src/nodesCodeFuncs.c
View File

@ -7367,6 +7367,7 @@ static int32_t createTSMAStmtToJson(const void* pObj, SJson* pJson) {
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = tjsonAddObject(pJson, jkCreateTSMAStmtpOptions, nodeToJson, pNode->pOptions); code = tjsonAddObject(pJson, jkCreateTSMAStmtpOptions, nodeToJson, pNode->pOptions);
} }
return code;
} }
static int32_t jsonToCreateTSMAStmt(const SJson* pJson, void* pObj) { static int32_t jsonToCreateTSMAStmt(const SJson* pJson, void* pObj) {
@ -7382,7 +7383,7 @@ static int32_t jsonToCreateTSMAStmt(const SJson* pJson, void* pObj) {
code = tjsonGetStringValue(pJson, jkCreateTSMAStmtTableName, pNode->tableName); code = tjsonGetStringValue(pJson, jkCreateTSMAStmtTableName, pNode->tableName);
} }
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = jsonToNodeObject(pJson, jkCreateTSMAStmtpOptions, &pNode->pOptions); code = jsonToNodeObject(pJson, jkCreateTSMAStmtpOptions, (SNode**)&pNode->pOptions);
} }
return code; return code;
} }

22
source/libs/nodes/src/nodesUtilFuncs.c
View File

@ -519,6 +519,7 @@ SNode* nodesMakeNode(ENodeType type) {
case QUERY_NODE_SHOW_GRANTS_FULL_STMT: case QUERY_NODE_SHOW_GRANTS_FULL_STMT:
case QUERY_NODE_SHOW_GRANTS_LOGS_STMT: case QUERY_NODE_SHOW_GRANTS_LOGS_STMT:
case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT: case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT:
case QUERY_NODE_SHOW_TSMAS_STMT:
return makeNode(type, sizeof(SShowStmt)); return makeNode(type, sizeof(SShowStmt));
case QUERY_NODE_SHOW_TABLE_TAGS_STMT: case QUERY_NODE_SHOW_TABLE_TAGS_STMT:
return makeNode(type, sizeof(SShowTableTagsStmt)); return makeNode(type, sizeof(SShowTableTagsStmt));
@ -561,6 +562,12 @@ SNode* nodesMakeNode(ENodeType type) {
return makeNode(type, sizeof(SCreateViewStmt)); return makeNode(type, sizeof(SCreateViewStmt));
case QUERY_NODE_DROP_VIEW_STMT: case QUERY_NODE_DROP_VIEW_STMT:
return makeNode(type, sizeof(SDropViewStmt)); return makeNode(type, sizeof(SDropViewStmt));
case QUERY_NODE_CREATE_TSMA_STMT:
return makeNode(type, sizeof(SCreateTSMAStmt));
case QUERY_NODE_DROP_TSMA_STMT:
return makeNode(type, sizeof(SDropTSMAStmt));
case QUERY_NODE_TSMA_OPTIONS:
return makeNode(type, sizeof(STSMAOptions));
case QUERY_NODE_LOGIC_PLAN_SCAN: case QUERY_NODE_LOGIC_PLAN_SCAN:
return makeNode(type, sizeof(SScanLogicNode)); return makeNode(type, sizeof(SScanLogicNode));
case QUERY_NODE_LOGIC_PLAN_JOIN: case QUERY_NODE_LOGIC_PLAN_JOIN:
@ -910,6 +917,13 @@ void nodesDestroyNode(SNode* pNode) {
nodesDestroyNode(pOptions->pDeleteMark); nodesDestroyNode(pOptions->pDeleteMark);
break; break;
} }
case QUERY_NODE_TSMA_OPTIONS: {
STSMAOptions* pOptions = (STSMAOptions*)pNode;
nodesDestroyList(pOptions->pCols);
nodesDestroyList(pOptions->pFuncs);
nodesDestroyNode(pOptions->pInterval);
break;
}
case QUERY_NODE_LEFT_VALUE: // no pointer field case QUERY_NODE_LEFT_VALUE: // no pointer field
case QUERY_NODE_COLUMN_REF: // no pointer field case QUERY_NODE_COLUMN_REF: // no pointer field
break; break;
@ -1184,7 +1198,8 @@ void nodesDestroyNode(SNode* pNode) {
case QUERY_NODE_SHOW_VIEWS_STMT: case QUERY_NODE_SHOW_VIEWS_STMT:
case QUERY_NODE_SHOW_GRANTS_FULL_STMT: case QUERY_NODE_SHOW_GRANTS_FULL_STMT:
case QUERY_NODE_SHOW_GRANTS_LOGS_STMT: case QUERY_NODE_SHOW_GRANTS_LOGS_STMT:
case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT: { case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT:
case QUERY_NODE_SHOW_TSMAS_STMT: {
SShowStmt* pStmt = (SShowStmt*)pNode; SShowStmt* pStmt = (SShowStmt*)pNode;
nodesDestroyNode(pStmt->pDbName); nodesDestroyNode(pStmt->pDbName);
nodesDestroyNode(pStmt->pTbName); nodesDestroyNode(pStmt->pTbName);
@ -1271,6 +1286,11 @@ void nodesDestroyNode(SNode* pNode) {
} }
case QUERY_NODE_DROP_VIEW_STMT: case QUERY_NODE_DROP_VIEW_STMT:
break; break;
case QUERY_NODE_CREATE_TSMA_STMT: {
SCreateTSMAStmt* pStmt = (SCreateTSMAStmt*)pNode;
nodesDestroyNode((SNode*)pStmt->pOptions);
break;
}
case QUERY_NODE_LOGIC_PLAN_SCAN: { case QUERY_NODE_LOGIC_PLAN_SCAN: {
SScanLogicNode* pLogicNode = (SScanLogicNode*)pNode; SScanLogicNode* pLogicNode = (SScanLogicNode*)pNode;
destroyLogicNode((SLogicNode*)pLogicNode); destroyLogicNode((SLogicNode*)pLogicNode);

2
source/libs/parser/inc/parUtil.h
View File

@ -110,6 +110,7 @@ typedef struct SParseMetaCache {
SHashObj* pTableIndex; // key is tbFName, element is SArray<STableIndexInfo>* SHashObj* pTableIndex; // key is tbFName, element is SArray<STableIndexInfo>*
SHashObj* pTableCfg; // key is tbFName, element is STableCfg* SHashObj* pTableCfg; // key is tbFName, element is STableCfg*
SHashObj* pViews; // key is viewFName, element is SViewMeta* SHashObj* pViews; // key is viewFName, element is SViewMeta*
SHashObj* pTableTSMAs; // key is tbFName, elements are SArray<STableTSMAInfo>*
SArray* pDnodes; // element is SEpSet SArray* pDnodes; // element is SEpSet
bool dnodeRequired; bool dnodeRequired;
} SParseMetaCache; } SParseMetaCache;
@ -153,6 +154,7 @@ int32_t reserveUdfInCache(const char* pFunc, SParseMetaCache* pMetaCache);
int32_t reserveTableIndexInCache(int32_t acctId, const char* pDb, const char* pTable, SParseMetaCache* pMetaCache); int32_t reserveTableIndexInCache(int32_t acctId, const char* pDb, const char* pTable, SParseMetaCache* pMetaCache);
int32_t reserveTableCfgInCache(int32_t acctId, const char* pDb, const char* pTable, SParseMetaCache* pMetaCache); int32_t reserveTableCfgInCache(int32_t acctId, const char* pDb, const char* pTable, SParseMetaCache* pMetaCache);
int32_t reserveDnodeRequiredInCache(SParseMetaCache* pMetaCache); int32_t reserveDnodeRequiredInCache(SParseMetaCache* pMetaCache);
int32_t reserveTableTSMAInfoInCache(int32_t acctId, const char* pDb, const char* pTable, SParseMetaCache* pMetaCache);
int32_t getTableMetaFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableMeta** pMeta); int32_t getTableMetaFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableMeta** pMeta);
int32_t getViewMetaFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableMeta** pMeta); int32_t getViewMetaFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableMeta** pMeta);
int32_t buildTableMetaFromViewMeta(STableMeta** pMeta, SViewMeta* pViewMeta); int32_t buildTableMetaFromViewMeta(STableMeta** pMeta, SViewMeta* pViewMeta);

4
source/libs/parser/src/parAstParser.c
View File

@ -186,6 +186,10 @@ static int32_t collectMetaKeyFromRealTableImpl(SCollectMetaKeyCxt* pCxt, const c
QUERY_NODE_SELECT_STMT == nodeType(pCxt->pStmt)) { QUERY_NODE_SELECT_STMT == nodeType(pCxt->pStmt)) {
code = collectMetaKeyFromInsTags(pCxt); code = collectMetaKeyFromInsTags(pCxt);
} }
if (TSDB_CODE_SUCCESS == code && QUERY_SMA_OPTIMIZE_ENABLE == tsQuerySmaOptimize &&
QUERY_NODE_SELECT_STMT == nodeType(pCxt->pStmt)) {
code = reserveTableTSMAInfoInCache(pCxt->pParseCxt->acctId, pDb, pTable, pCxt->pMetaCache);
}
return code; return code;
} }

25
source/libs/parser/src/parTranslater.c
View File

@ -10406,6 +10406,9 @@ static int32_t buildTSMAAst(STranslateContext* pCxt, SCreateTSMAStmt* pStmt, SMC
} }
} }
if (code == TSDB_CODE_SUCCESS)
code = rewriteFuncsForTSMA(info.pFuncs);
if (code == TSDB_CODE_SUCCESS) { if (code == TSDB_CODE_SUCCESS) {
code = buildSampleAst(pCxt, &info, &pReq->ast, &pReq->astLen, &pReq->expr, &pReq->exprLen); code = buildSampleAst(pCxt, &info, &pReq->ast, &pReq->astLen, &pReq->expr, &pReq->exprLen);
} }
@ -10522,30 +10525,26 @@ static int32_t buildCreateTSMAReq(STranslateContext* pCxt, SCreateTSMAStmt* pStm
static int32_t translateCreateTSMA(STranslateContext* pCxt, SCreateTSMAStmt* pStmt) { static int32_t translateCreateTSMA(STranslateContext* pCxt, SCreateTSMAStmt* pStmt) {
int32_t code = doTranslateValue(pCxt, (SValueNode*)pStmt->pOptions->pInterval); int32_t code = doTranslateValue(pCxt, (SValueNode*)pStmt->pOptions->pInterval);
pStmt->pReq = taosMemoryCalloc(1, sizeof(SMCreateSmaReq)); SMCreateSmaReq smaReq = {0};
if (pStmt->pReq == NULL) code = TSDB_CODE_OUT_OF_MEMORY;
if (code == TSDB_CODE_SUCCESS) { if (code == TSDB_CODE_SUCCESS) {
code = buildCreateTSMAReq(pCxt, pStmt, pStmt->pReq); code = buildCreateTSMAReq(pCxt, pStmt, &smaReq);
} }
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
// TODO replace with tsma serialization func // TODO replace with tsma serialization func
code = buildCmdMsg(pCxt, TDMT_MND_CREATE_TSMA, (FSerializeFunc)tSerializeSMCreateSmaReq, pStmt->pReq); code = buildCmdMsg(pCxt, TDMT_MND_CREATE_TSMA, (FSerializeFunc)tSerializeSMCreateSmaReq, &smaReq);
} }
tFreeSMCreateSmaReq(pStmt->pReq); tFreeSMCreateSmaReq(&smaReq);
return code; return code;
} }
static int32_t translateDropTSMA(STranslateContext* pCxt, SDropTSMAStmt* pStmt) { static int32_t translateDropTSMA(STranslateContext* pCxt, SDropTSMAStmt* pStmt) {
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
pStmt->pReq = taosMemoryCalloc(1, sizeof(SMDropSmaReq)); SMDropSmaReq dropReq = {0};
if (!pStmt->pReq) code = TSDB_CODE_OUT_OF_MEMORY; SName name;
if (code == TSDB_CODE_SUCCESS) { tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tsmaName, &name), dropReq.name);
SName name; dropReq.igNotExists = pStmt->ignoreNotExists;
tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tsmaName, &name), pStmt->pReq->name);
pStmt->pReq->igNotExists = pStmt->ignoreNotExists;
}
if (TSDB_CODE_SUCCESS == code) if (TSDB_CODE_SUCCESS == code)
code = buildCmdMsg(pCxt, TDMT_MND_DROP_TSMA, (FSerializeFunc)tSerializeSMDropSmaReq, pStmt->pReq); code = buildCmdMsg(pCxt, TDMT_MND_DROP_TSMA, (FSerializeFunc)tSerializeSMDropSmaReq, &dropReq);
return code; return code;
} }

11
source/libs/parser/src/parUtil.c
View File

@ -723,6 +723,9 @@ int32_t buildCatalogReq(const SParseMetaCache* pMetaCache, SCatalogReq* pCatalog
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = buildTableReq(pMetaCache->pTableCfg, &pCatalogReq->pTableCfg); code = buildTableReq(pMetaCache->pTableCfg, &pCatalogReq->pTableCfg);
} }
if (TSDB_CODE_SUCCESS == code) {
code = buildTableReqFromDb(pMetaCache->pTableMeta, &pCatalogReq->pTableTSMAs);
}
#ifdef TD_ENTERPRISE #ifdef TD_ENTERPRISE
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = buildTableReqFromDb(pMetaCache->pTableMeta, &pCatalogReq->pView); code = buildTableReqFromDb(pMetaCache->pTableMeta, &pCatalogReq->pView);
@ -864,6 +867,9 @@ int32_t putMetaDataToCache(const SCatalogReq* pCatalogReq, const SMetaData* pMet
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = putTableDataToCache(pCatalogReq->pTableCfg, pMetaData->pTableCfg, &pMetaCache->pTableCfg); code = putTableDataToCache(pCatalogReq->pTableCfg, pMetaData->pTableCfg, &pMetaCache->pTableCfg);
} }
if (TSDB_CODE_SUCCESS == code) {
code = putDbTableDataToCache(pCatalogReq->pTableTSMAs, pMetaData->pTableTsmas, &pMetaCache->pTableTSMAs);
}
#ifdef TD_ENTERPRISE #ifdef TD_ENTERPRISE
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = putDbTableDataToCache(pCatalogReq->pView, pMetaData->pView, &pMetaCache->pViews); code = putDbTableDataToCache(pCatalogReq->pView, pMetaData->pView, &pMetaCache->pViews);
@ -1134,6 +1140,10 @@ int32_t reserveTableCfgInCache(int32_t acctId, const char* pDb, const char* pTab
return reserveTableReqInCache(acctId, pDb, pTable, &pMetaCache->pTableCfg); return reserveTableReqInCache(acctId, pDb, pTable, &pMetaCache->pTableCfg);
} }
int32_t reserveTableTSMAInfoInCache(int32_t acctId, const char *pDb, const char *pTable, SParseMetaCache *pMetaCache) {
return reserveTableReqInCache(acctId, pDb, pTable, &pMetaCache->pTableTSMAs);
}
int32_t getTableIndexFromCache(SParseMetaCache* pMetaCache, const SName* pName, SArray** pIndexes) { int32_t getTableIndexFromCache(SParseMetaCache* pMetaCache, const SName* pName, SArray** pIndexes) {
char fullName[TSDB_TABLE_FNAME_LEN]; char fullName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(pName, fullName); tNameExtractFullName(pName, fullName);
@ -1232,6 +1242,7 @@ void destoryParseMetaCache(SParseMetaCache* pMetaCache, bool request) {
taosHashCleanup(pMetaCache->pUdf); taosHashCleanup(pMetaCache->pUdf);
taosHashCleanup(pMetaCache->pTableIndex); taosHashCleanup(pMetaCache->pTableIndex);
taosHashCleanup(pMetaCache->pTableCfg); taosHashCleanup(pMetaCache->pTableCfg);
taosHashCleanup(pMetaCache->pTableTSMAs);
} }
int64_t int64SafeSub(int64_t a, int64_t b) { int64_t int64SafeSub(int64_t a, int64_t b) {

2
source/libs/parser/src/parser.c
View File

@ -270,12 +270,14 @@ void destoryCatalogReq(SCatalogReq *pCatalogReq) {
#ifdef TD_ENTERPRISE #ifdef TD_ENTERPRISE
taosArrayDestroy(pCatalogReq->pView); taosArrayDestroy(pCatalogReq->pView);
#endif #endif
taosArrayDestroy(pCatalogReq->pTableTSMAs);
} else { } else {
taosArrayDestroyEx(pCatalogReq->pTableMeta, destoryTablesReq); taosArrayDestroyEx(pCatalogReq->pTableMeta, destoryTablesReq);
taosArrayDestroyEx(pCatalogReq->pTableHash, destoryTablesReq); taosArrayDestroyEx(pCatalogReq->pTableHash, destoryTablesReq);
#ifdef TD_ENTERPRISE #ifdef TD_ENTERPRISE
taosArrayDestroyEx(pCatalogReq->pView, destoryTablesReq); taosArrayDestroyEx(pCatalogReq->pView, destoryTablesReq);
#endif #endif
taosArrayDestroyEx(pCatalogReq->pTableTSMAs, destoryTablesReq);
} }
taosArrayDestroy(pCatalogReq->pUdf); taosArrayDestroy(pCatalogReq->pUdf);
taosArrayDestroy(pCatalogReq->pIndex); taosArrayDestroy(pCatalogReq->pIndex);

9614
source/libs/parser/src/sql.c
View File

File diff suppressed because it is too large Load Diff

33
source/libs/qcom/src/querymsg.c
View File

@ -304,6 +304,24 @@ int32_t queryBuildGetViewMetaMsg(void *input, char **msg, int32_t msgSize, int32
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t queryBuildGetTableTSMAMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen,
void *(*mallcFp)(int64_t)) {
if (NULL == msg || NULL == msgLen) {
return TSDB_CODE_TSC_INVALID_INPUT;
}
STableTSMAInfoReq req = {0};
strncpy(req.name, input, sizeof(req.name) - 1);
int32_t bufLen = tSerializeTableTSMAInfoReq(NULL, 0, &req);
void * pBuf = (*mallcFp)(bufLen);
tSerializeTableTSMAInfoReq(pBuf, bufLen, &req);
*msg = pBuf;
*msgLen = bufLen;
return TSDB_CODE_SUCCESS;
}
int32_t queryProcessUseDBRsp(void *output, char *msg, int32_t msgSize) { int32_t queryProcessUseDBRsp(void *output, char *msg, int32_t msgSize) {
SUseDbOutput *pOut = output; SUseDbOutput *pOut = output;
SUseDbRsp usedbRsp = {0}; SUseDbRsp usedbRsp = {0};
@ -683,6 +701,19 @@ int32_t queryProcessGetViewMetaRsp(void *output, char *msg, int32_t msgSize) {
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t queryProcessGetTbTSMARsp(void* output, char* msg, int32_t msgSize) {
if (NULL == output || NULL == msg || msgSize <= 0) {
return TSDB_CODE_TSC_INVALID_INPUT;
}
if (tDeserializeTableTSMAInfoRsp(msg, msgSize, output) != 0) {
qError("tDeserializeSViewMetaRsp failed, msgSize:%d", msgSize);
return TSDB_CODE_INVALID_MSG;
}
return TSDB_CODE_SUCCESS;
}
void initQueryModuleMsgHandle() { void initQueryModuleMsgHandle() {
queryBuildMsg[TMSG_INDEX(TDMT_VND_TABLE_META)] = queryBuildTableMetaReqMsg; queryBuildMsg[TMSG_INDEX(TDMT_VND_TABLE_META)] = queryBuildTableMetaReqMsg;
@ -699,6 +730,7 @@ void initQueryModuleMsgHandle() {
queryBuildMsg[TMSG_INDEX(TDMT_MND_TABLE_CFG)] = queryBuildGetTbCfgMsg; queryBuildMsg[TMSG_INDEX(TDMT_MND_TABLE_CFG)] = queryBuildGetTbCfgMsg;
queryBuildMsg[TMSG_INDEX(TDMT_MND_SERVER_VERSION)] = queryBuildGetSerVerMsg; queryBuildMsg[TMSG_INDEX(TDMT_MND_SERVER_VERSION)] = queryBuildGetSerVerMsg;
queryBuildMsg[TMSG_INDEX(TDMT_MND_VIEW_META)] = queryBuildGetViewMetaMsg; queryBuildMsg[TMSG_INDEX(TDMT_MND_VIEW_META)] = queryBuildGetViewMetaMsg;
queryBuildMsg[TMSG_INDEX(TDMT_MND_GET_TABLE_TSMA)] = queryBuildGetTableTSMAMsg;
queryProcessMsgRsp[TMSG_INDEX(TDMT_VND_TABLE_META)] = queryProcessTableMetaRsp; queryProcessMsgRsp[TMSG_INDEX(TDMT_VND_TABLE_META)] = queryProcessTableMetaRsp;
queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_TABLE_META)] = queryProcessTableMetaRsp; queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_TABLE_META)] = queryProcessTableMetaRsp;
@ -714,6 +746,7 @@ void initQueryModuleMsgHandle() {
queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_TABLE_CFG)] = queryProcessGetTbCfgRsp; queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_TABLE_CFG)] = queryProcessGetTbCfgRsp;
queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_SERVER_VERSION)] = queryProcessGetSerVerRsp; queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_SERVER_VERSION)] = queryProcessGetSerVerRsp;
queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_VIEW_META)] = queryProcessGetViewMetaRsp; queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_VIEW_META)] = queryProcessGetViewMetaRsp;
queryProcessMsgRsp[TMSG_INDEX(TDMT_MND_GET_TABLE_TSMA)] = queryProcessGetTbTSMARsp;
} }
#pragma GCC diagnostic pop #pragma GCC diagnostic pop

4
source/util/src/terror.c
View File

@ -323,8 +323,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TARGET_TABLE, "Cannot write the same
// mnode-sma // mnode-sma
TAOS_DEFINE_ERROR(TSDB_CODE_MND_SMA_ALREADY_EXIST, "SMA already exists in db") TAOS_DEFINE_ERROR(TSDB_CODE_MND_SMA_ALREADY_EXIST, "SMA already exists in db")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_SMA_NOT_EXIST, "index not exist") TAOS_DEFINE_ERROR(TSDB_CODE_MND_SMA_NOT_EXIST, "sma not exist")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_SMA_OPTION, "Invalid sma index option") TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_SMA_OPTION, "Invalid sma option")
// mnode-view // mnode-view
TAOS_DEFINE_ERROR(TSDB_CODE_MND_VIEW_ALREADY_EXIST, "view already exists in db") TAOS_DEFINE_ERROR(TSDB_CODE_MND_VIEW_ALREADY_EXIST, "view already exists in db")