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

Merge pull request #26275 from taosdata/feat/TS-4917-3.0 

feat: 'create table' from csv file
This commit is contained in:
Hongze Cheng 2024-06-25 17:56:23 +08:00 committed by GitHub
parent 60974ecb58 b55337ec42
commit 59c8656e61
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
16 changed files with 6549 additions and 5037 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/common/tmsg.h
View File

@ -344,6 +344,7 @@ typedef enum ENodeType {
QUERY_NODE_RESUME_STREAM_STMT, QUERY_NODE_RESUME_STREAM_STMT,
QUERY_NODE_CREATE_VIEW_STMT, QUERY_NODE_CREATE_VIEW_STMT,
QUERY_NODE_DROP_VIEW_STMT, QUERY_NODE_DROP_VIEW_STMT,
QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE,
// show statement nodes // show statement nodes
// see 'sysTableShowAdapter', 'SYSTABLE_SHOW_TYPE_OFFSET' // see 'sysTableShowAdapter', 'SYSTABLE_SHOW_TYPE_OFFSET'

446
include/common/ttokendef.h
View File

@ -141,229 +141,229 @@
#define TK_NK_EQ 123 #define TK_NK_EQ 123
#define TK_USING 124 #define TK_USING 124
#define TK_TAGS 125 #define TK_TAGS 125
#define TK_BOOL 126 #define TK_FILE 126
#define TK_TINYINT 127 #define TK_BOOL 127
#define TK_SMALLINT 128 #define TK_TINYINT 128
#define TK_INT 129 #define TK_SMALLINT 129
#define TK_INTEGER 130 #define TK_INT 130
#define TK_BIGINT 131 #define TK_INTEGER 131
#define TK_FLOAT 132 #define TK_BIGINT 132
#define TK_DOUBLE 133 #define TK_FLOAT 133
#define TK_BINARY 134 #define TK_DOUBLE 134
#define TK_NCHAR 135 #define TK_BINARY 135
#define TK_UNSIGNED 136 #define TK_NCHAR 136
#define TK_JSON 137 #define TK_UNSIGNED 137
#define TK_VARCHAR 138 #define TK_JSON 138
#define TK_MEDIUMBLOB 139 #define TK_VARCHAR 139
#define TK_BLOB 140 #define TK_MEDIUMBLOB 140
#define TK_VARBINARY 141 #define TK_BLOB 141
#define TK_GEOMETRY 142 #define TK_VARBINARY 142
#define TK_DECIMAL 143 #define TK_GEOMETRY 143
#define TK_COMMENT 144 #define TK_DECIMAL 144
#define TK_MAX_DELAY 145 #define TK_COMMENT 145
#define TK_WATERMARK 146 #define TK_MAX_DELAY 146
#define TK_ROLLUP 147 #define TK_WATERMARK 147
#define TK_TTL 148 #define TK_ROLLUP 148
#define TK_SMA 149 #define TK_TTL 149
#define TK_DELETE_MARK 150 #define TK_SMA 150
#define TK_FIRST 151 #define TK_DELETE_MARK 151
#define TK_LAST 152 #define TK_FIRST 152
#define TK_SHOW 153 #define TK_LAST 153
#define TK_FULL 154 #define TK_SHOW 154
#define TK_PRIVILEGES 155 #define TK_FULL 155
#define TK_DATABASES 156 #define TK_PRIVILEGES 156
#define TK_TABLES 157 #define TK_DATABASES 157
#define TK_STABLES 158 #define TK_TABLES 158
#define TK_MNODES 159 #define TK_STABLES 159
#define TK_QNODES 160 #define TK_MNODES 160
#define TK_ARBGROUPS 161 #define TK_QNODES 161
#define TK_FUNCTIONS 162 #define TK_ARBGROUPS 162
#define TK_INDEXES 163 #define TK_FUNCTIONS 163
#define TK_ACCOUNTS 164 #define TK_INDEXES 164
#define TK_APPS 165 #define TK_ACCOUNTS 165
#define TK_CONNECTIONS 166 #define TK_APPS 166
#define TK_LICENCES 167 #define TK_CONNECTIONS 167
#define TK_GRANTS 168 #define TK_LICENCES 168
#define TK_LOGS 169 #define TK_GRANTS 169
#define TK_MACHINES 170 #define TK_LOGS 170
#define TK_ENCRYPTIONS 171 #define TK_MACHINES 171
#define TK_QUERIES 172 #define TK_ENCRYPTIONS 172
#define TK_SCORES 173 #define TK_QUERIES 173
#define TK_TOPICS 174 #define TK_SCORES 174
#define TK_VARIABLES 175 #define TK_TOPICS 175
#define TK_BNODES 176 #define TK_VARIABLES 176
#define TK_SNODES 177 #define TK_BNODES 177
#define TK_TRANSACTIONS 178 #define TK_SNODES 178
#define TK_DISTRIBUTED 179 #define TK_TRANSACTIONS 179
#define TK_CONSUMERS 180 #define TK_DISTRIBUTED 180
#define TK_SUBSCRIPTIONS 181 #define TK_CONSUMERS 181
#define TK_VNODES 182 #define TK_SUBSCRIPTIONS 182
#define TK_ALIVE 183 #define TK_VNODES 183
#define TK_VIEWS 184 #define TK_ALIVE 184
#define TK_VIEW 185 #define TK_VIEWS 185
#define TK_COMPACTS 186 #define TK_VIEW 186
#define TK_NORMAL 187 #define TK_COMPACTS 187
#define TK_CHILD 188 #define TK_NORMAL 188
#define TK_LIKE 189 #define TK_CHILD 189
#define TK_TBNAME 190 #define TK_LIKE 190
#define TK_QTAGS 191 #define TK_TBNAME 191
#define TK_AS 192 #define TK_QTAGS 192
#define TK_SYSTEM 193 #define TK_AS 193
#define TK_TSMA 194 #define TK_SYSTEM 194
#define TK_INTERVAL 195 #define TK_TSMA 195
#define TK_RECURSIVE 196 #define TK_INTERVAL 196
#define TK_TSMAS 197 #define TK_RECURSIVE 197
#define TK_FUNCTION 198 #define TK_TSMAS 198
#define TK_INDEX 199 #define TK_FUNCTION 199
#define TK_COUNT 200 #define TK_INDEX 200
#define TK_LAST_ROW 201 #define TK_COUNT 201
#define TK_META 202 #define TK_LAST_ROW 202
#define TK_ONLY 203 #define TK_META 203
#define TK_TOPIC 204 #define TK_ONLY 204
#define TK_CONSUMER 205 #define TK_TOPIC 205
#define TK_GROUP 206 #define TK_CONSUMER 206
#define TK_DESC 207 #define TK_GROUP 207
#define TK_DESCRIBE 208 #define TK_DESC 208
#define TK_RESET 209 #define TK_DESCRIBE 209
#define TK_QUERY 210 #define TK_RESET 210
#define TK_CACHE 211 #define TK_QUERY 211
#define TK_EXPLAIN 212 #define TK_CACHE 212
#define TK_ANALYZE 213 #define TK_EXPLAIN 213
#define TK_VERBOSE 214 #define TK_ANALYZE 214
#define TK_NK_BOOL 215 #define TK_VERBOSE 215
#define TK_RATIO 216 #define TK_NK_BOOL 216
#define TK_NK_FLOAT 217 #define TK_RATIO 217
#define TK_OUTPUTTYPE 218 #define TK_NK_FLOAT 218
#define TK_AGGREGATE 219 #define TK_OUTPUTTYPE 219
#define TK_BUFSIZE 220 #define TK_AGGREGATE 220
#define TK_LANGUAGE 221 #define TK_BUFSIZE 221
#define TK_REPLACE 222 #define TK_LANGUAGE 222
#define TK_STREAM 223 #define TK_REPLACE 223
#define TK_INTO 224 #define TK_STREAM 224
#define TK_PAUSE 225 #define TK_INTO 225
#define TK_RESUME 226 #define TK_PAUSE 226
#define TK_PRIMARY 227 #define TK_RESUME 227
#define TK_KEY 228 #define TK_PRIMARY 228
#define TK_TRIGGER 229 #define TK_KEY 229
#define TK_AT_ONCE 230 #define TK_TRIGGER 230
#define TK_WINDOW_CLOSE 231 #define TK_AT_ONCE 231
#define TK_IGNORE 232 #define TK_WINDOW_CLOSE 232
#define TK_EXPIRED 233 #define TK_IGNORE 233
#define TK_FILL_HISTORY 234 #define TK_EXPIRED 234
#define TK_UPDATE 235 #define TK_FILL_HISTORY 235
#define TK_SUBTABLE 236 #define TK_UPDATE 236
#define TK_UNTREATED 237 #define TK_SUBTABLE 237
#define TK_KILL 238 #define TK_UNTREATED 238
#define TK_CONNECTION 239 #define TK_KILL 239
#define TK_TRANSACTION 240 #define TK_CONNECTION 240
#define TK_BALANCE 241 #define TK_TRANSACTION 241
#define TK_VGROUP 242 #define TK_BALANCE 242
#define TK_LEADER 243 #define TK_VGROUP 243
#define TK_MERGE 244 #define TK_LEADER 244
#define TK_REDISTRIBUTE 245 #define TK_MERGE 245
#define TK_SPLIT 246 #define TK_REDISTRIBUTE 246
#define TK_DELETE 247 #define TK_SPLIT 247
#define TK_INSERT 248 #define TK_DELETE 248
#define TK_NK_BIN 249 #define TK_INSERT 249
#define TK_NK_HEX 250 #define TK_NK_BIN 250
#define TK_NULL 251 #define TK_NK_HEX 251
#define TK_NK_QUESTION 252 #define TK_NULL 252
#define TK_NK_ALIAS 253 #define TK_NK_QUESTION 253
#define TK_NK_ARROW 254 #define TK_NK_ALIAS 254
#define TK_ROWTS 255 #define TK_NK_ARROW 255
#define TK_QSTART 256 #define TK_ROWTS 256
#define TK_QEND 257 #define TK_QSTART 257
#define TK_QDURATION 258 #define TK_QEND 258
#define TK_WSTART 259 #define TK_QDURATION 259
#define TK_WEND 260 #define TK_WSTART 260
#define TK_WDURATION 261 #define TK_WEND 261
#define TK_IROWTS 262 #define TK_WDURATION 262
#define TK_ISFILLED 263 #define TK_IROWTS 263
#define TK_CAST 264 #define TK_ISFILLED 264
#define TK_NOW 265 #define TK_CAST 265
#define TK_TODAY 266 #define TK_NOW 266
#define TK_TIMEZONE 267 #define TK_TODAY 267
#define TK_CLIENT_VERSION 268 #define TK_TIMEZONE 268
#define TK_SERVER_VERSION 269 #define TK_CLIENT_VERSION 269
#define TK_SERVER_STATUS 270 #define TK_SERVER_VERSION 270
#define TK_CURRENT_USER 271 #define TK_SERVER_STATUS 271
#define TK_CASE 272 #define TK_CURRENT_USER 272
#define TK_WHEN 273 #define TK_CASE 273
#define TK_THEN 274 #define TK_WHEN 274
#define TK_ELSE 275 #define TK_THEN 275
#define TK_BETWEEN 276 #define TK_ELSE 276
#define TK_IS 277 #define TK_BETWEEN 277
#define TK_NK_LT 278 #define TK_IS 278
#define TK_NK_GT 279 #define TK_NK_LT 279
#define TK_NK_LE 280 #define TK_NK_GT 280
#define TK_NK_GE 281 #define TK_NK_LE 281
#define TK_NK_NE 282 #define TK_NK_GE 282
#define TK_MATCH 283 #define TK_NK_NE 283
#define TK_NMATCH 284 #define TK_MATCH 284
#define TK_CONTAINS 285 #define TK_NMATCH 285
#define TK_IN 286 #define TK_CONTAINS 286
#define TK_JOIN 287 #define TK_IN 287
#define TK_INNER 288 #define TK_JOIN 288
#define TK_LEFT 289 #define TK_INNER 289
#define TK_RIGHT 290 #define TK_LEFT 290
#define TK_OUTER 291 #define TK_RIGHT 291
#define TK_SEMI 292 #define TK_OUTER 292
#define TK_ANTI 293 #define TK_SEMI 293
#define TK_ASOF 294 #define TK_ANTI 294
#define TK_WINDOW 295 #define TK_ASOF 295
#define TK_WINDOW_OFFSET 296 #define TK_WINDOW 296
#define TK_JLIMIT 297 #define TK_WINDOW_OFFSET 297
#define TK_SELECT 298 #define TK_JLIMIT 298
#define TK_NK_HINT 299 #define TK_SELECT 299
#define TK_DISTINCT 300 #define TK_NK_HINT 300
#define TK_WHERE 301 #define TK_DISTINCT 301
#define TK_PARTITION 302 #define TK_WHERE 302
#define TK_BY 303 #define TK_PARTITION 303
#define TK_SESSION 304 #define TK_BY 304
#define TK_STATE_WINDOW 305 #define TK_SESSION 305
#define TK_EVENT_WINDOW 306 #define TK_STATE_WINDOW 306
#define TK_COUNT_WINDOW 307 #define TK_EVENT_WINDOW 307
#define TK_SLIDING 308 #define TK_COUNT_WINDOW 308
#define TK_FILL 309 #define TK_SLIDING 309
#define TK_VALUE 310 #define TK_FILL 310
#define TK_VALUE_F 311 #define TK_VALUE 311
#define TK_NONE 312 #define TK_VALUE_F 312
#define TK_PREV 313 #define TK_NONE 313
#define TK_NULL_F 314 #define TK_PREV 314
#define TK_LINEAR 315 #define TK_NULL_F 315
#define TK_NEXT 316 #define TK_LINEAR 316
#define TK_HAVING 317 #define TK_NEXT 317
#define TK_RANGE 318 #define TK_HAVING 318
#define TK_EVERY 319 #define TK_RANGE 319
#define TK_ORDER 320 #define TK_EVERY 320
#define TK_SLIMIT 321 #define TK_ORDER 321
#define TK_SOFFSET 322 #define TK_SLIMIT 322
#define TK_LIMIT 323 #define TK_SOFFSET 323
#define TK_OFFSET 324 #define TK_LIMIT 324
#define TK_ASC 325 #define TK_OFFSET 325
#define TK_NULLS 326 #define TK_ASC 326
#define TK_ABORT 327 #define TK_NULLS 327
#define TK_AFTER 328 #define TK_ABORT 328
#define TK_ATTACH 329 #define TK_AFTER 329
#define TK_BEFORE 330 #define TK_ATTACH 330
#define TK_BEGIN 331 #define TK_BEFORE 331
#define TK_BITAND 332 #define TK_BEGIN 332
#define TK_BITNOT 333 #define TK_BITAND 333
#define TK_BITOR 334 #define TK_BITNOT 334
#define TK_BLOCKS 335 #define TK_BITOR 335
#define TK_CHANGE 336 #define TK_BLOCKS 336
#define TK_COMMA 337 #define TK_CHANGE 337
#define TK_CONCAT 338 #define TK_COMMA 338
#define TK_CONFLICT 339 #define TK_CONCAT 339
#define TK_COPY 340 #define TK_CONFLICT 340
#define TK_DEFERRED 341 #define TK_COPY 341
#define TK_DELIMITERS 342 #define TK_DEFERRED 342
#define TK_DETACH 343 #define TK_DELIMITERS 343
#define TK_DIVIDE 344 #define TK_DETACH 344
#define TK_DOT 345 #define TK_DIVIDE 345
#define TK_EACH 346 #define TK_DOT 346
#define TK_FAIL 347 #define TK_EACH 347
#define TK_FILE 348 #define TK_FAIL 348
#define TK_FOR 349 #define TK_FOR 349
#define TK_GLOB 350 #define TK_GLOB 350
#define TK_ID 351 #define TK_ID 351

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

@ -214,6 +214,18 @@ typedef struct SCreateSubTableClause {
STableOptions* pOptions; STableOptions* pOptions;
} SCreateSubTableClause; } SCreateSubTableClause;
typedef struct SCreateSubTableFromFileClause {
ENodeType type;
char useDbName[TSDB_DB_NAME_LEN];
char useTableName[TSDB_TABLE_NAME_LEN];
bool ignoreExists;
SNodeList* pSpecificTags;
char filePath[PATH_MAX];
TdFilePtr fp;
SArray* aCreateTbData;
SArray* aTagIndexs;
} SCreateSubTableFromFileClause;
typedef struct SCreateMultiTablesStmt { typedef struct SCreateMultiTablesStmt {
ENodeType type; ENodeType type;
SNodeList* pSubTables; SNodeList* pSubTables;

3
include/util/taoserror.h
View File

@ -827,6 +827,9 @@ int32_t taosGetErrSize();
#define TSDB_CODE_PAR_INVALID_PK_OP TAOS_DEF_ERROR_CODE(0, 0x267A) #define TSDB_CODE_PAR_INVALID_PK_OP TAOS_DEF_ERROR_CODE(0, 0x267A)
#define TSDB_CODE_PAR_PRIMARY_KEY_IS_NULL TAOS_DEF_ERROR_CODE(0, 0x267B) #define TSDB_CODE_PAR_PRIMARY_KEY_IS_NULL TAOS_DEF_ERROR_CODE(0, 0x267B)
#define TSDB_CODE_PAR_PRIMARY_KEY_IS_NONE TAOS_DEF_ERROR_CODE(0, 0x267C) #define TSDB_CODE_PAR_PRIMARY_KEY_IS_NONE TAOS_DEF_ERROR_CODE(0, 0x267C)
#define TSDB_CODE_PAR_TBNAME_ERROR TAOS_DEF_ERROR_CODE(0, 0x267D)
#define TSDB_CODE_PAR_TBNAME_DUPLICATED TAOS_DEF_ERROR_CODE(0, 0x267E)
#define TSDB_CODE_PAR_TAG_NAME_DUPLICATED TAOS_DEF_ERROR_CODE(0, 0x267F)
#define TSDB_CODE_PAR_INTERNAL_ERROR TAOS_DEF_ERROR_CODE(0, 0x26FF) #define TSDB_CODE_PAR_INTERNAL_ERROR TAOS_DEF_ERROR_CODE(0, 0x26FF)
//planner //planner

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

@ -60,7 +60,7 @@ char* getFullJoinTypeString(EJoinType type, EJoinSubType stype) {
{"LEFT", "LEFT", "LEFT OUTER", "LEFT SEMI", "LEFT ANTI", "LEFT ANY", "LEFT ASOF", "LEFT WINDOW"}, {"LEFT", "LEFT", "LEFT OUTER", "LEFT SEMI", "LEFT ANTI", "LEFT ANY", "LEFT ASOF", "LEFT WINDOW"},
{"RIGHT", "RIGHT", "RIGHT OUTER", "RIGHT SEMI", "RIGHT ANTI", "RIGHT ANY", "RIGHT ASOF", "RIGHT WINDOW"}, {"RIGHT", "RIGHT", "RIGHT OUTER", "RIGHT SEMI", "RIGHT ANTI", "RIGHT ANY", "RIGHT ASOF", "RIGHT WINDOW"},
{"FULL", "FULL", "FULL OUTER", "FULL", "FULL", "FULL ANY", "FULL", "FULL"} {"FULL", "FULL", "FULL OUTER", "FULL", "FULL", "FULL ANY", "FULL", "FULL"}
}; };
return joinFullType[type][stype]; return joinFullType[type][stype];
} }
@ -89,7 +89,7 @@ int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) {
} }
nodesDestroyNode(*ppSrc); nodesDestroyNode(*ppSrc);
*ppSrc = NULL; *ppSrc = NULL;
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
} }
@ -422,6 +422,8 @@ SNode* nodesMakeNode(ENodeType type) {
return makeNode(type, sizeof(SCreateTableStmt)); return makeNode(type, sizeof(SCreateTableStmt));
case QUERY_NODE_CREATE_SUBTABLE_CLAUSE: case QUERY_NODE_CREATE_SUBTABLE_CLAUSE:
return makeNode(type, sizeof(SCreateSubTableClause)); return makeNode(type, sizeof(SCreateSubTableClause));
case QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE:
return makeNode(type, sizeof(SCreateSubTableFromFileClause));
case QUERY_NODE_CREATE_MULTI_TABLES_STMT: case QUERY_NODE_CREATE_MULTI_TABLES_STMT:
return makeNode(type, sizeof(SCreateMultiTablesStmt)); return makeNode(type, sizeof(SCreateMultiTablesStmt));
case QUERY_NODE_DROP_TABLE_CLAUSE: case QUERY_NODE_DROP_TABLE_CLAUSE:
@ -1006,7 +1008,7 @@ void nodesDestroyNode(SNode* pNode) {
nodesDestroyNode(pWin->pStartOffset); nodesDestroyNode(pWin->pStartOffset);
nodesDestroyNode(pWin->pEndOffset); nodesDestroyNode(pWin->pEndOffset);
break; break;
} }
case QUERY_NODE_SET_OPERATOR: { case QUERY_NODE_SET_OPERATOR: {
SSetOperator* pStmt = (SSetOperator*)pNode; SSetOperator* pStmt = (SSetOperator*)pNode;
nodesDestroyList(pStmt->pProjectionList); nodesDestroyList(pStmt->pProjectionList);
@ -1089,6 +1091,20 @@ void nodesDestroyNode(SNode* pNode) {
nodesDestroyNode((SNode*)pStmt->pOptions); nodesDestroyNode((SNode*)pStmt->pOptions);
break; break;
} }
case QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE: {
SCreateSubTableFromFileClause* pStmt = (SCreateSubTableFromFileClause*)pNode;
if (pStmt->aCreateTbData) {
taosArrayDestroy(pStmt->aCreateTbData);
}
if (pStmt->aTagIndexs) {
taosArrayDestroy(pStmt->aTagIndexs);
}
if (pStmt->fp) {
taosCloseFile(&pStmt->fp);
}
nodesDestroyList(pStmt->pSpecificTags);
break;
}
case QUERY_NODE_CREATE_MULTI_TABLES_STMT: case QUERY_NODE_CREATE_MULTI_TABLES_STMT:
nodesDestroyList(((SCreateMultiTablesStmt*)pNode)->pSubTables); nodesDestroyList(((SCreateMultiTablesStmt*)pNode)->pSubTables);
break; break;

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

@ -201,6 +201,8 @@ SNode* createCreateTableStmt(SAstCreateContext* pCxt, bool ignoreExists, SNode*
SNodeList* pTags, SNode* pOptions); SNodeList* pTags, SNode* pOptions);
SNode* createCreateSubTableClause(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNode* pUseRealTable, SNode* createCreateSubTableClause(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNode* pUseRealTable,
SNodeList* pSpecificTags, SNodeList* pValsOfTags, SNode* pOptions); SNodeList* pSpecificTags, SNodeList* pValsOfTags, SNode* pOptions);
SNode* createCreateSubTableFromFileClause(SAstCreateContext* pCxt, bool ignoreExists, SNode* pUseRealTable,
SNodeList* pSpecificTags, const SToken* pFilePath);
SNode* createCreateMultiTableStmt(SAstCreateContext* pCxt, SNodeList* pSubTables); SNode* createCreateMultiTableStmt(SAstCreateContext* pCxt, SNodeList* pSubTables);
SNode* createDropTableClause(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* pRealTable); SNode* createDropTableClause(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* pRealTable);
SNode* createDropTableStmt(SAstCreateContext* pCxt, SNodeList* pTables); SNode* createDropTableStmt(SAstCreateContext* pCxt, SNodeList* pTables);

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

@ -135,6 +135,7 @@ int32_t getVnodeSysTableTargetName(int32_t acctId, SNode* pWhere, SName* pName);
int32_t checkAndTrimValue(SToken* pToken, char* tmpTokenBuf, SMsgBuf* pMsgBuf, int8_t type); int32_t checkAndTrimValue(SToken* pToken, char* tmpTokenBuf, SMsgBuf* pMsgBuf, int8_t type);
int32_t parseTagValue(SMsgBuf* pMsgBuf, const char** pSql, uint8_t precision, SSchema* pTagSchema, SToken* pToken, int32_t parseTagValue(SMsgBuf* pMsgBuf, const char** pSql, uint8_t precision, SSchema* pTagSchema, SToken* pToken,
SArray* pTagName, SArray* pTagVals, STag** pTag); SArray* pTagName, SArray* pTagVals, STag** pTag);
int32_t parseTbnameToken(SMsgBuf* pMsgBuf, char* tname, SToken* pToken, bool* pFoundCtbName);
int32_t buildCatalogReq(const SParseMetaCache* pMetaCache, SCatalogReq* pCatalogReq); int32_t buildCatalogReq(const SParseMetaCache* pMetaCache, SCatalogReq* pCatalogReq);
int32_t putMetaDataToCache(const SCatalogReq* pCatalogReq, const SMetaData* pMetaData, SParseMetaCache* pMetaCache); int32_t putMetaDataToCache(const SCatalogReq* pCatalogReq, const SMetaData* pMetaData, SParseMetaCache* pMetaCache);
@ -150,7 +151,7 @@ int32_t reserveDbCfgInCache(int32_t acctId, const char* pDb, SParseMetaCache* pM
int32_t reserveUserAuthInCache(int32_t acctId, const char* pUser, const char* pDb, const char* pTable, AUTH_TYPE type, int32_t reserveUserAuthInCache(int32_t acctId, const char* pUser, const char* pDb, const char* pTable, AUTH_TYPE type,
SParseMetaCache* pMetaCache); SParseMetaCache* pMetaCache);
int32_t reserveViewUserAuthInCache(int32_t acctId, const char* pUser, const char* pDb, const char* pTable, AUTH_TYPE type, int32_t reserveViewUserAuthInCache(int32_t acctId, const char* pUser, const char* pDb, const char* pTable, AUTH_TYPE type,
SParseMetaCache* pMetaCache); SParseMetaCache* pMetaCache);
int32_t reserveUdfInCache(const char* pFunc, SParseMetaCache* pMetaCache); 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);

58
source/libs/parser/inc/sql.y
View File

@ -385,11 +385,15 @@ alter_table_clause(A) ::=
%destructor multi_create_clause { nodesDestroyList($$); } %destructor multi_create_clause { nodesDestroyList($$); }
multi_create_clause(A) ::= create_subtable_clause(B). { A = createNodeList(pCxt, B); } multi_create_clause(A) ::= create_subtable_clause(B). { A = createNodeList(pCxt, B); }
multi_create_clause(A) ::= multi_create_clause(B) create_subtable_clause(C). { A = addNodeToList(pCxt, B, C); } multi_create_clause(A) ::= multi_create_clause(B) create_subtable_clause(C). { A = addNodeToList(pCxt, B, C); }
multi_create_clause(A) ::= create_from_file_clause(B). { A = createNodeList(pCxt, B); }
create_subtable_clause(A) ::= create_subtable_clause(A) ::=
not_exists_opt(B) full_table_name(C) USING full_table_name(D) not_exists_opt(B) full_table_name(C) USING full_table_name(D)
specific_cols_opt(E) TAGS NK_LP tags_literal_list(F) NK_RP table_options(G). { A = createCreateSubTableClause(pCxt, B, C, D, E, F, G); } specific_cols_opt(E) TAGS NK_LP tags_literal_list(F) NK_RP table_options(G). { A = createCreateSubTableClause(pCxt, B, C, D, E, F, G); }
create_from_file_clause(A) ::= not_exists_opt(B) USING full_table_name(C)
NK_LP tag_list_opt(D) NK_RP FILE NK_STRING(E). { A = createCreateSubTableFromFileClause(pCxt, B, C, D, &E); }
%type multi_drop_clause { SNodeList* } %type multi_drop_clause { SNodeList* }
%destructor multi_drop_clause { nodesDestroyList($$); } %destructor multi_drop_clause { nodesDestroyList($$); }
multi_drop_clause(A) ::= drop_table_clause(B). { A = createNodeList(pCxt, B); } multi_drop_clause(A) ::= drop_table_clause(B). { A = createNodeList(pCxt, B); }
@ -532,7 +536,7 @@ cmd ::= SHOW GRANTS LOGS.
cmd ::= SHOW CLUSTER MACHINES. { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT); } cmd ::= SHOW CLUSTER MACHINES. { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT); }
cmd ::= SHOW CREATE DATABASE db_name(A). { pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &A); } cmd ::= SHOW CREATE DATABASE db_name(A). { pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &A); }
cmd ::= SHOW CREATE TABLE full_table_name(A). { pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, A); } cmd ::= SHOW CREATE TABLE full_table_name(A). { pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, A); }
cmd ::= SHOW CREATE STABLE full_table_name(A). { pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, cmd ::= SHOW CREATE STABLE full_table_name(A). { pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT,
A); } A); }
cmd ::= SHOW ENCRYPTIONS. { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_ENCRYPTIONS_STMT); } cmd ::= SHOW ENCRYPTIONS. { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_ENCRYPTIONS_STMT); }
cmd ::= SHOW QUERIES. { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT); } cmd ::= SHOW QUERIES. { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT); }
@ -820,13 +824,13 @@ tags_literal(A) ::= NK_INTEGER(B).
tags_literal(A) ::= NK_INTEGER(B) NK_PLUS duration_literal(C). { tags_literal(A) ::= NK_INTEGER(B) NK_PLUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_INTEGER(B) NK_MINUS duration_literal(C). { tags_literal(A) ::= NK_INTEGER(B) NK_MINUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_PLUS(B) NK_INTEGER(C). { tags_literal(A) ::= NK_PLUS(B) NK_INTEGER(C). {
@ -837,13 +841,13 @@ tags_literal(A) ::= NK_PLUS(B) NK_INTEGER(C).
tags_literal(A) ::= NK_PLUS(B) NK_INTEGER NK_PLUS duration_literal(C). { tags_literal(A) ::= NK_PLUS(B) NK_INTEGER NK_PLUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_PLUS(B) NK_INTEGER NK_MINUS duration_literal(C). { tags_literal(A) ::= NK_PLUS(B) NK_INTEGER NK_MINUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_MINUS(B) NK_INTEGER(C). { tags_literal(A) ::= NK_MINUS(B) NK_INTEGER(C). {
@ -854,13 +858,13 @@ tags_literal(A) ::= NK_MINUS(B) NK_INTEGER(C).
tags_literal(A) ::= NK_MINUS(B) NK_INTEGER NK_PLUS duration_literal(C). { tags_literal(A) ::= NK_MINUS(B) NK_INTEGER NK_PLUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_MINUS(B) NK_INTEGER NK_MINUS duration_literal(C). { tags_literal(A) ::= NK_MINUS(B) NK_INTEGER NK_MINUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_FLOAT(B). { A = createRawValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &B, NULL); } tags_literal(A) ::= NK_FLOAT(B). { A = createRawValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &B, NULL); }
@ -879,13 +883,13 @@ tags_literal(A) ::= NK_BIN(B).
tags_literal(A) ::= NK_BIN(B) NK_PLUS duration_literal(C). { tags_literal(A) ::= NK_BIN(B) NK_PLUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_BIN(B) NK_MINUS duration_literal(C). { tags_literal(A) ::= NK_BIN(B) NK_MINUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_PLUS(B) NK_BIN(C). { tags_literal(A) ::= NK_PLUS(B) NK_BIN(C). {
@ -896,13 +900,13 @@ tags_literal(A) ::= NK_PLUS(B) NK_BIN(C).
tags_literal(A) ::= NK_PLUS(B) NK_BIN NK_PLUS duration_literal(C). { tags_literal(A) ::= NK_PLUS(B) NK_BIN NK_PLUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_PLUS(B) NK_BIN NK_MINUS duration_literal(C). { tags_literal(A) ::= NK_PLUS(B) NK_BIN NK_MINUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_MINUS(B) NK_BIN(C). { tags_literal(A) ::= NK_MINUS(B) NK_BIN(C). {
@ -913,26 +917,26 @@ tags_literal(A) ::= NK_MINUS(B) NK_BIN(C).
tags_literal(A) ::= NK_MINUS(B) NK_BIN NK_PLUS duration_literal(C). { tags_literal(A) ::= NK_MINUS(B) NK_BIN NK_PLUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_MINUS(B) NK_BIN NK_MINUS duration_literal(C). { tags_literal(A) ::= NK_MINUS(B) NK_BIN NK_MINUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_HEX(B). { A = createRawValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &B, NULL); } tags_literal(A) ::= NK_HEX(B). { A = createRawValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &B, NULL); }
tags_literal(A) ::= NK_HEX(B) NK_PLUS duration_literal(C). { tags_literal(A) ::= NK_HEX(B) NK_PLUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_HEX(B) NK_MINUS duration_literal(C). { tags_literal(A) ::= NK_HEX(B) NK_MINUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_PLUS(B) NK_HEX(C). { tags_literal(A) ::= NK_PLUS(B) NK_HEX(C). {
@ -943,13 +947,13 @@ tags_literal(A) ::= NK_PLUS(B) NK_HEX(C).
tags_literal(A) ::= NK_PLUS(B) NK_HEX NK_PLUS duration_literal(C). { tags_literal(A) ::= NK_PLUS(B) NK_HEX NK_PLUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_PLUS(B) NK_HEX NK_MINUS duration_literal(C). { tags_literal(A) ::= NK_PLUS(B) NK_HEX NK_MINUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_MINUS(B) NK_HEX(C). { tags_literal(A) ::= NK_MINUS(B) NK_HEX(C). {
@ -960,13 +964,13 @@ tags_literal(A) ::= NK_MINUS(B) NK_HEX(C).
tags_literal(A) ::= NK_MINUS(B) NK_HEX NK_PLUS duration_literal(C). { tags_literal(A) ::= NK_MINUS(B) NK_HEX NK_PLUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_MINUS(B) NK_HEX NK_MINUS duration_literal(C). { tags_literal(A) ::= NK_MINUS(B) NK_HEX NK_MINUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
@ -974,13 +978,13 @@ tags_literal(A) ::= NK_STRING(B).
tags_literal(A) ::= NK_STRING(B) NK_PLUS duration_literal(C). { tags_literal(A) ::= NK_STRING(B) NK_PLUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_STRING(B) NK_MINUS duration_literal(C). { tags_literal(A) ::= NK_STRING(B) NK_MINUS duration_literal(C). {
SToken l = B; SToken l = B;
SToken r = getTokenFromRawExprNode(pCxt, C); SToken r = getTokenFromRawExprNode(pCxt, C);
l.n = (r.z + r.n) - l.z; l.n = (r.z + r.n) - l.z;
A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C); A = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, C);
} }
tags_literal(A) ::= NK_BOOL(B). { A = createRawValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &B, NULL); } tags_literal(A) ::= NK_BOOL(B). { A = createRawValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &B, NULL); }
@ -1348,9 +1352,9 @@ parenthesized_joined_table(A) ::= NK_LP parenthesized_joined_table(B) NK_RP.
/************************************************ joined_table ********************************************************/ /************************************************ joined_table ********************************************************/
joined_table(A) ::= joined_table(A) ::=
table_reference(B) join_type(C) join_subtype(D) JOIN table_reference(E) join_on_clause_opt(F) table_reference(B) join_type(C) join_subtype(D) JOIN table_reference(E) join_on_clause_opt(F)
window_offset_clause_opt(G) jlimit_clause_opt(H). { window_offset_clause_opt(G) jlimit_clause_opt(H). {
A = createJoinTableNode(pCxt, C, D, B, E, F); A = createJoinTableNode(pCxt, C, D, B, E, F);
A = addWindowOffsetClause(pCxt, A, G); A = addWindowOffsetClause(pCxt, A, G);
A = addJLimitClause(pCxt, A, H); A = addJLimitClause(pCxt, A, H);
} }
@ -1376,16 +1380,16 @@ join_on_clause_opt(A) ::= .
join_on_clause_opt(A) ::= ON search_condition(B). { A = B; } join_on_clause_opt(A) ::= ON search_condition(B). { A = B; }
window_offset_clause_opt(A) ::= . { A = NULL; } window_offset_clause_opt(A) ::= . { A = NULL; }
window_offset_clause_opt(A) ::= WINDOW_OFFSET NK_LP window_offset_literal(B) window_offset_clause_opt(A) ::= WINDOW_OFFSET NK_LP window_offset_literal(B)
NK_COMMA window_offset_literal(C) NK_RP. { A = createWindowOffsetNode(pCxt, releaseRawExprNode(pCxt, B), releaseRawExprNode(pCxt, C)); } NK_COMMA window_offset_literal(C) NK_RP. { A = createWindowOffsetNode(pCxt, releaseRawExprNode(pCxt, B), releaseRawExprNode(pCxt, C)); }
window_offset_literal(A) ::= NK_VARIABLE(B). { A = createRawExprNode(pCxt, &B, createTimeOffsetValueNode(pCxt, &B)); } window_offset_literal(A) ::= NK_VARIABLE(B). { A = createRawExprNode(pCxt, &B, createTimeOffsetValueNode(pCxt, &B)); }
window_offset_literal(A) ::= NK_MINUS(B) NK_VARIABLE(C). { window_offset_literal(A) ::= NK_MINUS(B) NK_VARIABLE(C). {
SToken t = B; SToken t = B;
t.n = (C.z + C.n) - B.z; t.n = (C.z + C.n) - B.z;
A = createRawExprNode(pCxt, &t, createTimeOffsetValueNode(pCxt, &t)); A = createRawExprNode(pCxt, &t, createTimeOffsetValueNode(pCxt, &t));
} }
jlimit_clause_opt(A) ::= . { A = NULL; } jlimit_clause_opt(A) ::= . { A = NULL; }
jlimit_clause_opt(A) ::= JLIMIT NK_INTEGER(B). { A = createLimitNode(pCxt, &B, NULL); } jlimit_clause_opt(A) ::= JLIMIT NK_INTEGER(B). { A = createLimitNode(pCxt, &B, NULL); }

20
source/libs/parser/src/parAstCreater.c
View File

@ -1828,6 +1828,26 @@ SNode* createCreateSubTableClause(SAstCreateContext* pCxt, bool ignoreExists, SN
return (SNode*)pStmt; return (SNode*)pStmt;
} }
SNode* createCreateSubTableFromFileClause(SAstCreateContext* pCxt, bool ignoreExists, SNode* pUseRealTable,
SNodeList* pSpecificTags, const SToken* pFilePath) {
CHECK_PARSER_STATUS(pCxt);
SCreateSubTableFromFileClause* pStmt =
(SCreateSubTableFromFileClause*)nodesMakeNode(QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE);
CHECK_OUT_OF_MEM(pStmt);
strcpy(pStmt->useDbName, ((SRealTableNode*)pUseRealTable)->table.dbName);
strcpy(pStmt->useTableName, ((SRealTableNode*)pUseRealTable)->table.tableName);
pStmt->ignoreExists = ignoreExists;
pStmt->pSpecificTags = pSpecificTags;
if (TK_NK_STRING == pFilePath->type) {
trimString(pFilePath->z, pFilePath->n, pStmt->filePath, PATH_MAX);
} else {
strncpy(pStmt->filePath, pFilePath->z, pFilePath->n);
}
nodesDestroyNode(pUseRealTable);
return (SNode*)pStmt;
}
SNode* createCreateMultiTableStmt(SAstCreateContext* pCxt, SNodeList* pSubTables) { SNode* createCreateMultiTableStmt(SAstCreateContext* pCxt, SNodeList* pSubTables) {
CHECK_PARSER_STATUS(pCxt); CHECK_PARSER_STATUS(pCxt);
SCreateMultiTablesStmt* pStmt = (SCreateMultiTablesStmt*)nodesMakeNode(QUERY_NODE_CREATE_MULTI_TABLES_STMT); SCreateMultiTablesStmt* pStmt = (SCreateMultiTablesStmt*)nodesMakeNode(QUERY_NODE_CREATE_MULTI_TABLES_STMT);

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

@ -275,19 +275,34 @@ static int32_t collectMetaKeyFromCreateMultiTable(SCollectMetaKeyCxt* pCxt, SCre
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
SNode* pNode = NULL; SNode* pNode = NULL;
FOREACH(pNode, pStmt->pSubTables) { FOREACH(pNode, pStmt->pSubTables) {
SCreateSubTableClause* pClause = (SCreateSubTableClause*)pNode; if (pNode->type == QUERY_NODE_CREATE_SUBTABLE_CLAUSE) {
code = reserveDbCfgInCache(pCxt->pParseCxt->acctId, pClause->dbName, pCxt->pMetaCache); SCreateSubTableClause* pClause = (SCreateSubTableClause*)pNode;
if (TSDB_CODE_SUCCESS == code) { code = reserveDbCfgInCache(pCxt->pParseCxt->acctId, pClause->dbName, pCxt->pMetaCache);
code = if (TSDB_CODE_SUCCESS == code) {
reserveTableMetaInCache(pCxt->pParseCxt->acctId, pClause->useDbName, pClause->useTableName, pCxt->pMetaCache); code = reserveTableMetaInCache(pCxt->pParseCxt->acctId, pClause->useDbName, pClause->useTableName,
} pCxt->pMetaCache);
if (TSDB_CODE_SUCCESS == code) { }
code = reserveTableVgroupInCache(pCxt->pParseCxt->acctId, pClause->dbName, pClause->tableName, pCxt->pMetaCache); if (TSDB_CODE_SUCCESS == code) {
} code =
if (TSDB_CODE_SUCCESS == code) { reserveTableVgroupInCache(pCxt->pParseCxt->acctId, pClause->dbName, pClause->tableName, pCxt->pMetaCache);
code = reserveUserAuthInCache(pCxt->pParseCxt->acctId, pCxt->pParseCxt->pUser, pClause->dbName, NULL, }
AUTH_TYPE_WRITE, pCxt->pMetaCache); if (TSDB_CODE_SUCCESS == code) {
code = reserveUserAuthInCache(pCxt->pParseCxt->acctId, pCxt->pParseCxt->pUser, pClause->dbName, NULL,
AUTH_TYPE_WRITE, pCxt->pMetaCache);
}
} else {
SCreateSubTableFromFileClause* pClause = (SCreateSubTableFromFileClause*)pNode;
code = reserveDbCfgInCache(pCxt->pParseCxt->acctId, pClause->useDbName, pCxt->pMetaCache);
if (TSDB_CODE_SUCCESS == code) {
code = reserveTableMetaInCache(pCxt->pParseCxt->acctId, pClause->useDbName, pClause->useTableName,
pCxt->pMetaCache);
}
if (TSDB_CODE_SUCCESS == code) {
code = reserveUserAuthInCache(pCxt->pParseCxt->acctId, pCxt->pParseCxt->pUser, pClause->useDbName, NULL,
AUTH_TYPE_WRITE, pCxt->pMetaCache);
}
} }
if (TSDB_CODE_SUCCESS != code) { if (TSDB_CODE_SUCCESS != code) {
break; break;
} }

16
source/libs/parser/src/parAuthenticator.c
View File

@ -265,10 +265,18 @@ static int32_t authCreateMultiTable(SAuthCxt* pCxt, SCreateMultiTablesStmt* pStm
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
SNode* pNode = NULL; SNode* pNode = NULL;
FOREACH(pNode, pStmt->pSubTables) { FOREACH(pNode, pStmt->pSubTables) {
SCreateSubTableClause* pClause = (SCreateSubTableClause*)pNode; if (pNode->type == QUERY_NODE_CREATE_SUBTABLE_CLAUSE) {
code = checkAuth(pCxt, pClause->dbName, NULL, AUTH_TYPE_WRITE, NULL); SCreateSubTableClause* pClause = (SCreateSubTableClause*)pNode;
if (TSDB_CODE_SUCCESS != code) { code = checkAuth(pCxt, pClause->dbName, NULL, AUTH_TYPE_WRITE, NULL);
break; if (TSDB_CODE_SUCCESS != code) {
break;
}
} else {
SCreateSubTableFromFileClause* pClause = (SCreateSubTableFromFileClause*)pNode;
code = checkAuth(pCxt, pClause->useDbName, NULL, AUTH_TYPE_WRITE, NULL);
if (TSDB_CODE_SUCCESS != code) {
break;
}
} }
} }
return code; return code;

59
source/libs/parser/src/parInsertSql.c
View File

@ -1708,37 +1708,31 @@ typedef union SRowsDataContext {
SStbRowsDataContext* pStbRowsCxt; SStbRowsDataContext* pStbRowsCxt;
} SRowsDataContext; } SRowsDataContext;
static int32_t parseTbnameToken(SInsertParseContext* pCxt, SStbRowsDataContext* pStbRowsCxt, SToken* pToken, int32_t parseTbnameToken(SMsgBuf* pMsgBuf, char* tname, SToken* pToken, bool* pFoundCtbName) {
bool* pFoundCtbName) {
*pFoundCtbName = false; *pFoundCtbName = false;
int32_t code = checkAndTrimValue(pToken, pCxt->tmpTokenBuf, &pCxt->msg, TSDB_DATA_TYPE_BINARY);
if (TK_NK_VARIABLE == pToken->type) {
code = buildInvalidOperationMsg(&pCxt->msg, "not expected tbname");
}
if (code == TSDB_CODE_SUCCESS) {
if (isNullValue(TSDB_DATA_TYPE_BINARY, pToken)) {
return buildInvalidOperationMsg(&pCxt->msg, "tbname can not be null value");
}
if (pToken->n > 0) { if (isNullValue(TSDB_DATA_TYPE_BINARY, pToken)) {
if (pToken->n <= TSDB_TABLE_NAME_LEN - 1) { return buildInvalidOperationMsg(pMsgBuf, "tbname can not be null value");
for (int i = 0; i < pToken->n; ++i) {
if (pToken->z[i] == '.') {
return buildInvalidOperationMsg(&pCxt->msg, "tbname can not contain '.'");
} else {
pStbRowsCxt->ctbName.tname[i] = pToken->z[i];
}
}
pStbRowsCxt->ctbName.tname[pToken->n] = '\0';
*pFoundCtbName = true;
} else {
return buildInvalidOperationMsg(&pCxt->msg, "tbname is too long");
}
} else {
return buildInvalidOperationMsg(&pCxt->msg, "tbname can not be empty");
}
} }
return code;
if (pToken->n > 0) {
if (pToken->n <= TSDB_TABLE_NAME_LEN - 1) {
for (int i = 0; i < pToken->n; ++i) {
if (pToken->z[i] == '.') {
return buildInvalidOperationMsg(pMsgBuf, "tbname can not contain '.'");
} else {
tname[i] = pToken->z[i];
}
}
tname[pToken->n] = '\0';
*pFoundCtbName = true;
} else {
return buildInvalidOperationMsg(pMsgBuf, "tbname is too long");
}
} else {
return buildInvalidOperationMsg(pMsgBuf, "tbname can not be empty");
}
return TSDB_CODE_SUCCESS;
} }
static int32_t processCtbTagsAfterCtbName(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt, static int32_t processCtbTagsAfterCtbName(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt,
@ -1821,7 +1815,14 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt*
} }
} }
} else if (pCols->pColIndex[i] == tbnameIdx) { } else if (pCols->pColIndex[i] == tbnameIdx) {
code = parseTbnameToken(pCxt, pStbRowsCxt, pToken, bFoundTbName); code = checkAndTrimValue(pToken, pCxt->tmpTokenBuf, &pCxt->msg, TSDB_DATA_TYPE_BINARY);
if (TK_NK_VARIABLE == pToken->type) {
code = buildInvalidOperationMsg(&pCxt->msg, "not expected tbname");
}
if (code == TSDB_CODE_SUCCESS) {
code = parseTbnameToken(&pCxt->msg, pStbRowsCxt->ctbName.tname, pToken, bFoundTbName);
}
} }
if (code == TSDB_CODE_SUCCESS && i < pCols->numOfBound - 1) { if (code == TSDB_CODE_SUCCESS && i < pCols->numOfBound - 1) {

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

@ -12414,38 +12414,39 @@ static int32_t rewriteCreateTable(STranslateContext* pCxt, SQuery* pQuery) {
return code; return code;
} }
static void addCreateTbReqIntoVgroup(int32_t acctId, SHashObj* pVgroupHashmap, SCreateSubTableClause* pStmt, static int32_t addCreateTbReqIntoVgroup(SHashObj* pVgroupHashmap, const char* dbName, uint64_t suid,
const STag* pTag, uint64_t suid, const char* sTableNmae, SVgroupInfo* pVgInfo, const char* sTableName, const char* tableName, SArray* tagName, uint8_t tagNum,
SArray* tagName, uint8_t tagNum) { const STag* pTag, int32_t ttl, const char* comment, bool ignoreExists,
// char dbFName[TSDB_DB_FNAME_LEN] = {0}; SVgroupInfo* pVgInfo) {
// SName name = {.type = TSDB_DB_NAME_T, .acctId = acctId};
// strcpy(name.dbname, pStmt->dbName);
// tNameGetFullDbName(&name, dbFName);
struct SVCreateTbReq req = {0}; struct SVCreateTbReq req = {0};
req.type = TD_CHILD_TABLE; req.type = TD_CHILD_TABLE;
req.name = taosStrdup(pStmt->tableName); req.name = taosStrdup(tableName);
req.ttl = pStmt->pOptions->ttl; req.ttl = ttl;
if (pStmt->pOptions->commentNull == false) { if (comment != NULL) {
req.comment = taosStrdup(pStmt->pOptions->comment); req.comment = taosStrdup(comment);
req.commentLen = strlen(pStmt->pOptions->comment); req.commentLen = strlen(comment);
} else { } else {
req.commentLen = -1; req.commentLen = -1;
} }
req.ctb.suid = suid; req.ctb.suid = suid;
req.ctb.tagNum = tagNum; req.ctb.tagNum = tagNum;
req.ctb.stbName = taosStrdup(sTableNmae); req.ctb.stbName = taosStrdup(sTableName);
req.ctb.pTag = (uint8_t*)pTag; req.ctb.pTag = (uint8_t*)pTag;
req.ctb.tagName = taosArrayDup(tagName, NULL); req.ctb.tagName = taosArrayDup(tagName, NULL);
if (pStmt->ignoreExists) { if (ignoreExists) {
req.flags |= TD_CREATE_IF_NOT_EXISTS; req.flags |= TD_CREATE_IF_NOT_EXISTS;
} }
if (!req.name || !req.ctb.stbName || !req.ctb.tagName || (comment && !req.comment)) {
tdDestroySVCreateTbReq(&req);
return TSDB_CODE_OUT_OF_MEMORY;
}
SVgroupCreateTableBatch* pTableBatch = taosHashGet(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId)); SVgroupCreateTableBatch* pTableBatch = taosHashGet(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId));
if (pTableBatch == NULL) { if (pTableBatch == NULL) {
SVgroupCreateTableBatch tBatch = {0}; SVgroupCreateTableBatch tBatch = {0};
tBatch.info = *pVgInfo; tBatch.info = *pVgInfo;
strcpy(tBatch.dbName, pStmt->dbName); strcpy(tBatch.dbName, dbName);
tBatch.req.pArray = taosArrayInit(4, sizeof(struct SVCreateTbReq)); tBatch.req.pArray = taosArrayInit(4, sizeof(struct SVCreateTbReq));
taosArrayPush(tBatch.req.pArray, &req); taosArrayPush(tBatch.req.pArray, &req);
@ -12454,11 +12455,8 @@ static void addCreateTbReqIntoVgroup(int32_t acctId, SHashObj* pVgroupHashmap, S
} else { // add to the correct vgroup } else { // add to the correct vgroup
taosArrayPush(pTableBatch->req.pArray, &req); taosArrayPush(pTableBatch->req.pArray, &req);
} }
}
static SDataType schemaToDataType(uint8_t precision, SSchema* pSchema) { return TSDB_CODE_SUCCESS;
SDataType dt = {.type = pSchema->type, .bytes = pSchema->bytes, .precision = precision, .scale = 0};
return dt;
} }
static int32_t createCastFuncForTag(STranslateContext* pCxt, SNode* pNode, SDataType dt, SNode** pCast) { static int32_t createCastFuncForTag(STranslateContext* pCxt, SNode* pNode, SDataType dt, SNode** pCast) {
@ -12647,8 +12645,10 @@ static int32_t rewriteCreateSubTable(STranslateContext* pCxt, SCreateSubTableCla
code = getTableHashVgroup(pCxt, pStmt->dbName, pStmt->tableName, &info); code = getTableHashVgroup(pCxt, pStmt->dbName, pStmt->tableName, &info);
} }
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
addCreateTbReqIntoVgroup(pCxt->pParseCxt->acctId, pVgroupHashmap, pStmt, pTag, pSuperTableMeta->uid, const char* comment = pStmt->pOptions->commentNull ? NULL : pStmt->pOptions->comment;
pStmt->useTableName, &info, tagName, pSuperTableMeta->tableInfo.numOfTags); code = addCreateTbReqIntoVgroup(pVgroupHashmap, pStmt->dbName, pSuperTableMeta->uid, pStmt->useTableName,
pStmt->tableName, tagName, pSuperTableMeta->tableInfo.numOfTags, pTag,
pStmt->pOptions->ttl, comment, pStmt->ignoreExists, &info);
} else { } else {
taosMemoryFree(pTag); taosMemoryFree(pTag);
} }
@ -12658,6 +12658,352 @@ static int32_t rewriteCreateSubTable(STranslateContext* pCxt, SCreateSubTableCla
return code; return code;
} }
static int32_t buildTagIndexForBindTags(SMsgBuf* pMsgBuf, SCreateSubTableFromFileClause* pStmt,
STableMeta* pSuperTableMeta) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t numOfTags = getNumOfTags(pSuperTableMeta);
SSchema* pSchema = getTableTagSchema(pSuperTableMeta);
SHashObj* pIdxHash = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
if (NULL == pIdxHash) {
return TSDB_CODE_OUT_OF_MEMORY;
}
bool tbnameFound = false;
SNode* pTagNode;
FOREACH(pTagNode, pStmt->pSpecificTags) {
int32_t idx = -1;
do {
if (QUERY_NODE_COLUMN == nodeType(pTagNode)) {
SColumnNode* pColNode = (SColumnNode*)pTagNode;
for (int32_t index = 0; index < numOfTags; index++) {
if (strlen(pSchema[index].name) == strlen(pColNode->colName) &&
strcmp(pColNode->colName, pSchema[index].name) == 0) {
idx = index;
break;
}
}
if (idx < 0) {
code = generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_INVALID_TAG_NAME, pColNode->colName);
break;
}
if (NULL != taosHashGet(pIdxHash, &idx, sizeof(idx))) {
code = generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_TAG_NAME_DUPLICATED, pColNode->colName);
break;
}
} else if (QUERY_NODE_FUNCTION == nodeType(pTagNode)) {
SFunctionNode* funcNode = (SFunctionNode*)pTagNode;
if (strlen("tbname") != strlen(funcNode->functionName) || strcmp("tbname", funcNode->functionName) != 0) {
code = generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_INVALID_TAG_NAME, funcNode->functionName);
}
idx = numOfTags + 1;
tbnameFound = true;
if (NULL != taosHashGet(pIdxHash, &idx, sizeof(idx))) {
code = generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_TAG_NAME_DUPLICATED, funcNode->functionName);
break;
}
} else {
code = generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_INVALID_TAG_NAME, "invalid node type");
break;
}
} while (0);
if (code) break;
if (taosHashPut(pIdxHash, &idx, sizeof(idx), NULL, 0) < 0) {
code = terrno;
goto _OUT;
}
if (NULL == taosArrayPush(pStmt->aTagIndexs, &idx)) {
code = TSDB_CODE_OUT_OF_MEMORY;
goto _OUT;
}
}
if (!tbnameFound) {
code = generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_TBNAME_ERROR);
}
_OUT:
taosHashCleanup(pIdxHash);
return code;
}
typedef struct {
// refer
STableMeta* pSuperTableMeta;
SArray* pTagIndexs;
TdFilePtr fp;
// containers
SHashObj* pTbNameHash;
SArray* aTagNames;
bool tagNameFilled;
SArray* aTagVals;
char tmpTokenBuf[TSDB_MAX_BYTES_PER_ROW];
// per line
const char* pSql;
STag* pTag;
SName ctbName;
SVgroupInfo vg;
} SParseFileContext;
static int32_t fillVgroupInfo(SParseContext* pParseCxt, const SName* pName, SVgroupInfo* pVgInfo) {
SVgroupInfo vg;
SRequestConnInfo conn = {.pTrans = pParseCxt->pTransporter,
.requestId = pParseCxt->requestId,
.requestObjRefId = pParseCxt->requestRid,
.mgmtEps = pParseCxt->mgmtEpSet};
int32_t code = catalogGetTableHashVgroup(pParseCxt->pCatalog, &conn, pName, &vg);
if (code == TSDB_CODE_SUCCESS) {
*pVgInfo = vg;
} else {
parserError("0x%" PRIx64 " catalogGetTableHashVgroup error, code:%s, dbName:%s, tbName:%s", pParseCxt->requestId,
tstrerror(code), pName->dbname, pName->tname);
}
return code;
}
static int32_t parseOneStbRow(SMsgBuf* pMsgBuf, SParseFileContext* pParFileCtx) {
int32_t code = TSDB_CODE_SUCCESS;
int sz = taosArrayGetSize(pParFileCtx->pTagIndexs);
int32_t numOfTags = getNumOfTags(pParFileCtx->pSuperTableMeta);
uint8_t precision = getTableInfo(pParFileCtx->pSuperTableMeta).precision;
SSchema* pSchemas = getTableTagSchema(pParFileCtx->pSuperTableMeta);
for (int i = 0; i < sz; i++) {
const char* pSql = pParFileCtx->pSql;
int32_t pos = 0;
SToken token = tStrGetToken(pSql, &pos, true, NULL);
pParFileCtx->pSql += pos;
if (TK_NK_RP == token.type) {
code = generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_INVALID_COLUMNS_NUM);
break;
}
int16_t index = *(int16_t*)taosArrayGet(pParFileCtx->pTagIndexs, i);
if (index < numOfTags) {
// parse tag
const SSchema* pTagSchema = &pSchemas[index];
code = checkAndTrimValue(&token, pParFileCtx->tmpTokenBuf, pMsgBuf, pTagSchema->type);
if (TSDB_CODE_SUCCESS == code && TK_NK_VARIABLE == token.type) {
code = buildInvalidOperationMsg(pMsgBuf, "not expected row value");
}
if (TSDB_CODE_SUCCESS == code) {
SArray* aTagNames = pParFileCtx->tagNameFilled ? NULL : pParFileCtx->aTagNames;
code = parseTagValue(pMsgBuf, &pParFileCtx->pSql, precision, (SSchema*)pTagSchema, &token,
pParFileCtx->aTagNames, pParFileCtx->aTagVals, &pParFileCtx->pTag);
pParFileCtx->tagNameFilled = true;
}
} else {
// parse tbname
code = checkAndTrimValue(&token, pParFileCtx->tmpTokenBuf, pMsgBuf, TSDB_DATA_TYPE_BINARY);
if (TK_NK_VARIABLE == token.type) {
code = buildInvalidOperationMsg(pMsgBuf, "not expected tbname");
}
if (TSDB_CODE_SUCCESS == code) {
bool bFoundTbName = false;
code = parseTbnameToken(pMsgBuf, pParFileCtx->ctbName.tname, &token, &bFoundTbName);
}
}
}
if (TSDB_CODE_SUCCESS == code) { // may fail to handle json
code = tTagNew(pParFileCtx->aTagVals, 1, false, &pParFileCtx->pTag);
}
return code;
}
typedef struct {
SName ctbName;
SArray* aTagNames;
STag* pTag;
SVgroupInfo vg;
} SCreateTableData;
static void clearTagValArrayFp(void *data) {
STagVal* p = (STagVal*)data;
if (IS_VAR_DATA_TYPE(p->type)) {
taosMemoryFreeClear(p->pData);
}
}
static void clearCreateTbArrayFp(void *data) {
SCreateTableData* p = (SCreateTableData*)data;
taosMemoryFreeClear(p->pTag);
}
static int32_t parseCsvFile(SMsgBuf* pMsgBuf, SParseContext* pParseCxt, SParseFileContext* pParseFileCtx,
SArray* aCreateTbData) {
int32_t code = TSDB_CODE_SUCCESS;
char* pLine = NULL;
int64_t readLen = 0;
while (TSDB_CODE_SUCCESS == code && (readLen = taosGetLineFile(pParseFileCtx->fp, &pLine)) != -1) {
if (('\r' == pLine[readLen - 1]) || ('\n' == pLine[readLen - 1])) {
pLine[--readLen] = '\0';
}
if (readLen == 0) continue;
if (pLine[0] == '#') continue;
strtolower(pLine, pLine);
pParseFileCtx->pSql = pLine;
code = parseOneStbRow(pMsgBuf, pParseFileCtx);
if (TSDB_CODE_SUCCESS == code) {
if (taosHashGet(pParseFileCtx->pTbNameHash, pParseFileCtx->ctbName.tname,
strlen(pParseFileCtx->ctbName.tname) + 1) != NULL) {
taosMemoryFreeClear(pParseFileCtx->pTag);
code = generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_TBNAME_DUPLICATED, pParseFileCtx->ctbName.tname);
break;
}
code = taosHashPut(pParseFileCtx->pTbNameHash, pParseFileCtx->ctbName.tname,
strlen(pParseFileCtx->ctbName.tname) + 1, NULL, 0);
}
if (TSDB_CODE_SUCCESS == code) {
code = fillVgroupInfo(pParseCxt, &pParseFileCtx->ctbName, &pParseFileCtx->vg);
}
if (TSDB_CODE_SUCCESS == code) {
SCreateTableData data = {.ctbName = pParseFileCtx->ctbName,
.aTagNames = pParseFileCtx->aTagNames,
.pTag = pParseFileCtx->pTag,
.vg = pParseFileCtx->vg};
taosArrayPush(aCreateTbData, &data);
} else {
taosMemoryFreeClear(pParseFileCtx->pTag);
}
taosArrayClearEx(pParseFileCtx->aTagVals, clearTagValArrayFp);
}
if (TSDB_CODE_SUCCESS != code) {
taosArrayClearEx(aCreateTbData, clearCreateTbArrayFp);
}
taosMemoryFree(pLine);
return code;
}
static int32_t prepareReadFromFile(SCreateSubTableFromFileClause* pStmt) {
int32_t code = TSDB_CODE_SUCCESS;
if (NULL == pStmt->fp) {
pStmt->fp = taosOpenFile(pStmt->filePath, TD_FILE_READ | TD_FILE_STREAM);
if (NULL == pStmt->fp) {
code = TAOS_SYSTEM_ERROR(errno);
goto _ERR;
}
}
if (NULL == pStmt->aCreateTbData) {
pStmt->aCreateTbData = taosArrayInit(16, sizeof(SCreateTableData));
if (NULL == pStmt->aCreateTbData) {
code = TSDB_CODE_OUT_OF_MEMORY;
goto _ERR;
}
}
if (NULL == pStmt->aTagIndexs) {
pStmt->aTagIndexs = taosArrayInit(pStmt->pSpecificTags->length, sizeof(int16_t));
if (!pStmt->aTagIndexs) {
code = TSDB_CODE_OUT_OF_MEMORY;
goto _ERR;
}
}
return code;
_ERR:
taosCloseFile(&pStmt->fp);
taosArrayDestroy(pStmt->aCreateTbData);
taosArrayDestroy(pStmt->aTagIndexs);
return code;
}
static int32_t rewriteCreateSubTableFromFile(STranslateContext* pCxt, SCreateSubTableFromFileClause* pStmt,
SHashObj* pVgroupHashmap) {
int32_t code = 0;
STableMeta* pSuperTableMeta = NULL;
if (TSDB_CODE_SUCCESS == code) {
code = getTableMeta(pCxt, pStmt->useDbName, pStmt->useTableName, &pSuperTableMeta);
}
if (TSDB_CODE_SUCCESS == code) {
code = prepareReadFromFile(pStmt);
}
if (TSDB_CODE_SUCCESS == code) {
code = buildTagIndexForBindTags(&pCxt->msgBuf, pStmt, pSuperTableMeta);
}
SParseFileContext parseFileCtx = {
.pSuperTableMeta = pSuperTableMeta, .fp = pStmt->fp, .pTagIndexs = pStmt->aTagIndexs};
parseFileCtx.pTbNameHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), false, HASH_NO_LOCK);
parseFileCtx.aTagNames = taosArrayInit(8, TSDB_COL_NAME_LEN);
parseFileCtx.tagNameFilled = false;
parseFileCtx.aTagVals = taosArrayInit(8, sizeof(STagVal));
parseFileCtx.pTag = NULL;
parseFileCtx.ctbName.type = TSDB_TABLE_NAME_T;
parseFileCtx.ctbName.acctId = pCxt->pParseCxt->acctId;
strcpy(parseFileCtx.ctbName.dbname, pStmt->useDbName);
if (NULL == parseFileCtx.aTagNames || NULL == parseFileCtx.aTagVals || NULL == parseFileCtx.pTbNameHash) {
code = TSDB_CODE_OUT_OF_MEMORY;
goto _OUT;
}
if (TSDB_CODE_SUCCESS == code) {
code = parseCsvFile(&pCxt->msgBuf, pCxt->pParseCxt, &parseFileCtx, pStmt->aCreateTbData);
}
if (TSDB_CODE_SUCCESS == code) {
int sz = taosArrayGetSize(pStmt->aCreateTbData);
for (int i = 0; i < sz; i++) {
SCreateTableData* pData = taosArrayGet(pStmt->aCreateTbData, i);
code = collectUseTable(&pData->ctbName, pCxt->pTargetTables);
if (TSDB_CODE_SUCCESS != code) {
taosMemoryFree(pData->pTag);
}
code = addCreateTbReqIntoVgroup(pVgroupHashmap, pStmt->useDbName, pSuperTableMeta->uid, pStmt->useTableName,
pData->ctbName.tname, pData->aTagNames, pSuperTableMeta->tableInfo.numOfTags,
pData->pTag, TSDB_DEFAULT_TABLE_TTL, NULL, pStmt->ignoreExists, &pData->vg);
}
}
_OUT:
taosMemoryFreeClear(pSuperTableMeta);
taosHashCleanup(parseFileCtx.pTbNameHash);
taosArrayDestroy(parseFileCtx.aTagNames);
taosArrayDestroy(parseFileCtx.aTagVals);
return code;
}
SArray* serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap) { SArray* serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap) {
SArray* pBufArray = taosArrayInit(taosHashGetSize(pVgroupHashmap), sizeof(void*)); SArray* pBufArray = taosArrayInit(taosHashGetSize(pVgroupHashmap), sizeof(void*));
if (NULL == pBufArray) { if (NULL == pBufArray) {
@ -12690,8 +13036,13 @@ static int32_t rewriteCreateMultiTable(STranslateContext* pCxt, SQuery* pQuery)
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
SNode* pNode; SNode* pNode;
FOREACH(pNode, pStmt->pSubTables) { FOREACH(pNode, pStmt->pSubTables) {
SCreateSubTableClause* pClause = (SCreateSubTableClause*)pNode; if (pNode->type == QUERY_NODE_CREATE_SUBTABLE_CLAUSE) {
code = rewriteCreateSubTable(pCxt, pClause, pVgroupHashmap); SCreateSubTableClause* pClause = (SCreateSubTableClause*)pNode;
code = rewriteCreateSubTable(pCxt, pClause, pVgroupHashmap);
} else {
SCreateSubTableFromFileClause* pClause = (SCreateSubTableFromFileClause*)pNode;
code = rewriteCreateSubTableFromFile(pCxt, pClause, pVgroupHashmap);
}
if (TSDB_CODE_SUCCESS != code) { if (TSDB_CODE_SUCCESS != code) {
taosHashCleanup(pVgroupHashmap); taosHashCleanup(pVgroupHashmap);
return code; return code;

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

@ -212,10 +212,16 @@ static char* getSyntaxErrFormat(int32_t errCode) {
case TSDB_CODE_PAR_COL_PK_TYPE: case TSDB_CODE_PAR_COL_PK_TYPE:
return "primary key column must be of type int, uint, bigint, ubigint, and varchar"; return "primary key column must be of type int, uint, bigint, ubigint, and varchar";
case TSDB_CODE_PAR_INVALID_PK_OP: case TSDB_CODE_PAR_INVALID_PK_OP:
return "primary key column can not be added, modified, and dropped"; return "primary key column can not be added, modified, and dropped";
case TSDB_CODE_TSMA_NAME_TOO_LONG: case TSDB_CODE_TSMA_NAME_TOO_LONG:
return "Tsma name too long"; return "Tsma name too long";
default: case TSDB_CODE_PAR_TBNAME_ERROR:
return "Pseudo tag tbname not set";
case TSDB_CODE_PAR_TBNAME_DUPLICATED:
return "Table name:%s duplicated";
case TSDB_CODE_PAR_TAG_NAME_DUPLICATED:
return "Tag name:%s duplicated";
default:
return "Unknown error"; return "Unknown error";
} }
} }

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

File diff suppressed because it is too large Load Diff

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

@ -53,7 +53,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_RPC_TIMEOUT, "Conn read timeout")
TAOS_DEFINE_ERROR(TSDB_CODE_RPC_SOMENODE_NOT_CONNECTED, "some vnode/qnode/mnode(s) out of service") TAOS_DEFINE_ERROR(TSDB_CODE_RPC_SOMENODE_NOT_CONNECTED, "some vnode/qnode/mnode(s) out of service")
TAOS_DEFINE_ERROR(TSDB_CODE_RPC_MAX_SESSIONS, "rpc open too many session") TAOS_DEFINE_ERROR(TSDB_CODE_RPC_MAX_SESSIONS, "rpc open too many session")
TAOS_DEFINE_ERROR(TSDB_CODE_RPC_NETWORK_ERROR, "rpc network error") TAOS_DEFINE_ERROR(TSDB_CODE_RPC_NETWORK_ERROR, "rpc network error")
TAOS_DEFINE_ERROR(TSDB_CODE_RPC_NETWORK_BUSY, "rpc network busy") TAOS_DEFINE_ERROR(TSDB_CODE_RPC_NETWORK_BUSY, "rpc network busy")
//common & util //common & util
TAOS_DEFINE_ERROR(TSDB_CODE_TIME_UNSYNCED, "Client and server's time is not synchronized") TAOS_DEFINE_ERROR(TSDB_CODE_TIME_UNSYNCED, "Client and server's time is not synchronized")
@ -221,7 +221,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_COLUMN_NOT_EXIST, "Column does not exist
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STB_OPTION, "Invalid stable options") TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STB_OPTION, "Invalid stable options")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_ROW_BYTES, "Invalid row bytes") TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_ROW_BYTES, "Invalid row bytes")
// TAOS_DEFINE_ERROR(TSDB_CODE_MND_FIELD_VALUE_OVERFLOW, "out of range and overflow") // unused // TAOS_DEFINE_ERROR(TSDB_CODE_MND_FIELD_VALUE_OVERFLOW, "out of range and overflow") // unused
TAOS_DEFINE_ERROR(TSDB_CODE_MND_COLUMN_COMPRESS_ALREADY_EXIST, "Same with old param") TAOS_DEFINE_ERROR(TSDB_CODE_MND_COLUMN_COMPRESS_ALREADY_EXIST, "Same with old param")
// mnode-func // mnode-func
@ -674,6 +674,9 @@ TAOS_DEFINE_ERROR(TSDB_CODE_PAR_COL_PK_TYPE, "primary key column
TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_PK_OP, "primary key column can not be added, modified, and dropped") TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_PK_OP, "primary key column can not be added, modified, and dropped")
TAOS_DEFINE_ERROR(TSDB_CODE_PAR_PRIMARY_KEY_IS_NULL, "Primary key column should not be null") TAOS_DEFINE_ERROR(TSDB_CODE_PAR_PRIMARY_KEY_IS_NULL, "Primary key column should not be null")
TAOS_DEFINE_ERROR(TSDB_CODE_PAR_PRIMARY_KEY_IS_NONE, "Primary key column should not be none") TAOS_DEFINE_ERROR(TSDB_CODE_PAR_PRIMARY_KEY_IS_NONE, "Primary key column should not be none")
TAOS_DEFINE_ERROR(TSDB_CODE_PAR_TBNAME_ERROR, "Tbanme duplicated or not set")
TAOS_DEFINE_ERROR(TSDB_CODE_PAR_TBNAME_DUPLICATED, "Table name duplicated")
TAOS_DEFINE_ERROR(TSDB_CODE_PAR_TAG_NAME_DUPLICATED, "Tag name duplicated")
TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTERNAL_ERROR, "Parser internal error") TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTERNAL_ERROR, "Parser internal error")
//planner //planner